What's new in Observation

extension ObservationTracking {

    @available(anyAppleOS 27.0, *)
    public struct Token : ~Copyable {

        @available(anyAppleOS 27.0, *)
        public consuming func cancel()

        deinit
    }
}

extension ObservationTracking.Options : SetAlgebra {

    /// Creates an instance initialized with the given elements.
    @available(anyAppleOS 27.0, *)
    public init(arrayLiteral elements: ObservationTracking.Options...)

    /// Returns a new set with the elements of both this and the given set.
    ///
    /// In the following example, the `attendeesAndVisitors` set is made up
    /// of the elements of the `attendees` and `visitors` sets:
    ///
    ///     let attendees: Set = ["Alicia", "Bethany", "Diana"]
    ///     let visitors = ["Marcia", "Nathaniel"]
    ///     let attendeesAndVisitors = attendees.union(visitors)
    ///     print(attendeesAndVisitors)
    ///     // Prints "["Diana", "Nathaniel", "Bethany", "Alicia", "Marcia"]"
    ///
    /// If the set already contains one or more elements that are also in
    /// `other`, the existing members are kept.
    ///
    ///     let initialIndices = Set(0..<5)
    ///     let expandedIndices = initialIndices.union([2, 3, 6, 7])
    ///     print(expandedIndices)
    ///     // Prints "[2, 4, 6, 7, 0, 1, 3]"
    ///
    /// - Parameter other: A set of the same type as the current set.
    /// - Returns: A new set with the unique elements of this set and `other`.
    ///
    /// - Note: if this set and `other` contain elements that are equal but
    ///   distinguishable (e.g. via `===`), which of these elements is present
    ///   in the result is unspecified.
    @available(anyAppleOS 27.0, *)
    public func union(_ other: ObservationTracking.Options) -> ObservationTracking.Options

    /// Returns a new set with the elements that are common to both this set and
    /// the given set.
    ///
    /// In the following example, the `bothNeighborsAndEmployees` set is made up
    /// of the elements that are in *both* the `employees` and `neighbors` sets.
    /// Elements that are in only one or the other are left out of the result of
    /// the intersection.
    ///
    ///     let employees: Set = ["Alicia", "Bethany", "Chris", "Diana", "Eric"]
    ///     let neighbors: Set = ["Bethany", "Eric", "Forlani", "Greta"]
    ///     let bothNeighborsAndEmployees = employees.intersection(neighbors)
    ///     print(bothNeighborsAndEmployees)
    ///     // Prints "["Bethany", "Eric"]"
    ///
    /// - Parameter other: A set of the same type as the current set.
    /// - Returns: A new set.
    ///
    /// - Note: if this set and `other` contain elements that are equal but
    ///   distinguishable (e.g. via `===`), which of these elements is present
    ///   in the result is unspecified.
    @available(anyAppleOS 27.0, *)
    public func intersection(_ other: ObservationTracking.Options) -> ObservationTracking.Options

    /// Returns a new set with the elements that are either in this set or in the
    /// given set, but not in both.
    ///
    /// In the following example, the `eitherNeighborsOrEmployees` set is made up
    /// of the elements of the `employees` and `neighbors` sets that are not in
    /// both `employees` *and* `neighbors`. In particular, the names `"Bethany"`
    /// and `"Eric"` do not appear in `eitherNeighborsOrEmployees`.
    ///
    ///     let employees: Set = ["Alicia", "Bethany", "Diana", "Eric"]
    ///     let neighbors: Set = ["Bethany", "Eric", "Forlani"]
    ///     let eitherNeighborsOrEmployees = employees.symmetricDifference(neighbors)
    ///     print(eitherNeighborsOrEmployees)
    ///     // Prints "["Diana", "Forlani", "Alicia"]"
    ///
    /// - Parameter other: A set of the same type as the current set.
    /// - Returns: A new set.
    @available(anyAppleOS 27.0, *)
    public func symmetricDifference(_ other: ObservationTracking.Options) -> ObservationTracking.Options

    /// Adds the elements of the given set to the set.
    ///
    /// In the following example, the elements of the `visitors` set are added to
    /// the `attendees` set:

Truncated.

extension ObservationTracking.Options : Sendable {
}

public struct Event : ~Copyable {

    @available(anyAppleOS 27.0, *)
    public struct Kind : Equatable, Sendable {

        @available(anyAppleOS 27.0, *)
        public static var initial: ObservationTracking.Event.Kind { get }

        @available(anyAppleOS 27.0, *)
        public static var willSet: ObservationTracking.Event.Kind { get }

        @available(anyAppleOS 27.0, *)
        public static var didSet: ObservationTracking.Event.Kind { get }

        @available(anyAppleOS 27.0, *)
        public static var `deinit`: ObservationTracking.Event.Kind { get }

        /// Returns a Boolean value indicating whether two values are equal.
        ///
        /// Equality is the inverse of inequality. For any values `a` and `b`,
        /// `a == b` implies that `a != b` is `false`.
        ///
        /// - Parameters:
        ///   - lhs: A value to compare.
        ///   - rhs: Another value to compare.
        public static func == (a: ObservationTracking.Event.Kind, b: ObservationTracking.Event.Kind) -> Bool
    }

    @available(anyAppleOS 27.0, *)
    public var kind: ObservationTracking.Event.Kind { get }

    @available(anyAppleOS 27.0, *)
    public func matches(_ keyPath: PartialKeyPath<some Observable>) -> Bool

    @available(anyAppleOS 27.0, *)
    public func cancel()
}

public struct Options {

    /// Creates an empty set.
    ///
    /// This initializer is equivalent to initializing with an empty array
    /// literal. For example, you create an empty `Set` instance with either
    /// this initializer or with an empty array literal.
    ///
    ///     var emptySet = Set<Int>()
    ///     print(emptySet.isEmpty)
    ///     // Prints "true"
    ///
    ///     emptySet = []
    ///     print(emptySet.isEmpty)
    ///     // Prints "true"
    @available(anyAppleOS 27.0, *)
    public init()

    @available(anyAppleOS 27.0, *)
    public static var willSet: ObservationTracking.Options { get }

    @available(anyAppleOS 27.0, *)
    public static var didSet: ObservationTracking.Options { get }

    @available(anyAppleOS 27.0, *)
    public static var `deinit`: ObservationTracking.Options { get }
}

public struct Token : ~Copyable {

    @available(anyAppleOS 27.0, *)
    public consuming func cancel()

    deinit
}

public struct Kind : Equatable, Sendable {

    @available(anyAppleOS 27.0, *)
    public static var initial: ObservationTracking.Event.Kind { get }

    @available(anyAppleOS 27.0, *)
    public static var willSet: ObservationTracking.Event.Kind { get }

    @available(anyAppleOS 27.0, *)
    public static var didSet: ObservationTracking.Event.Kind { get }

    @available(anyAppleOS 27.0, *)
    public static var `deinit`: ObservationTracking.Event.Kind { get }

    /// Returns a Boolean value indicating whether two values are equal.
    ///
    /// Equality is the inverse of inequality. For any values `a` and `b`,
    /// `a == b` implies that `a != b` is `false`.
    ///
    /// - Parameters:
    ///   - lhs: A value to compare.
    ///   - rhs: Another value to compare.
    public static func == (a: ObservationTracking.Event.Kind, b: ObservationTracking.Event.Kind) -> Bool
}