From 9b122045f8ce49b78cabb40915d720beeb48b2ac Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 4 Aug 2026 20:37:59 +0000 Subject: [PATCH 1/5] Prepare Swift interface update From 5ce9bb3c15e2bdee74af5f9bd6a6df698cb6b33e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 5 Aug 2026 07:04:53 +0200 Subject: [PATCH 2/5] Update ios Swift interfaces (#5) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .agents/interfaces/ios/Capture.swiftinterface | 574 ++++++++++++++++++ 1 file changed, 574 insertions(+) create mode 100644 .agents/interfaces/ios/Capture.swiftinterface diff --git a/.agents/interfaces/ios/Capture.swiftinterface b/.agents/interfaces/ios/Capture.swiftinterface new file mode 100644 index 0000000..34c8352 --- /dev/null +++ b/.agents/interfaces/ios/Capture.swiftinterface @@ -0,0 +1,574 @@ +// swift-interface-format-version: 1.0 +// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101) +// swift-module-flags: -target arm64-apple-ios12.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Capture -package-name swift_capture +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public protocol CapturableObjectProtocol : AnyObject { +} +public enum ObjectCaptureStrategy : Swift.Sendable { + case weak + case strong + case unowned + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Capture.ObjectCaptureStrategy, _ b: Capture.ObjectCaptureStrategy) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +extension Capture.CapturableObjectProtocol { + @inlinable public var capture: Capture.CaptureItem { + get { + CaptureItem(Captured(self, as: .weak)) + } + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } +} +extension Capture.CapturableObjectProtocol where Self : Swift.Sendable { + public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } +} +extension ObjectiveC.NSObject : Capture.CapturableObjectProtocol { +} +@inlinable public func capture(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) -> Capture.CaptureItem where Object : AnyObject { + Captured(object, as: strategy).capture +} +public typealias _SendableCaptureItemProtocol = Capture.CaptureItemProtocol & Swift.Sendable +public protocol CaptureItemProtocol : Capture.__OptionalReferenceContainerProtocol { + associatedtype Object where Self.Object == Self.__CaptureRefObject +} +public struct CaptureItem : Capture.CaptureItemProtocol where Object : AnyObject { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public struct UncheckedSendable : Capture.CaptureItemProtocol, @unchecked Swift.Sendable { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public typealias __CaptureRefObject = Object + } + public typealias __CaptureRefObject = Object +} +extension Capture._OptionalReferenceContainerProtocol { + public var capture: Capture.CaptureItem { + get + } +} +extension Capture.__OptionalReferenceContainerProtocol { + public var uncheckedSendable: Capture.CaptureItem.UncheckedSendable { + get + } +} +extension Capture.CaptureItemProtocol { + @usableFromInline + internal var object: Self.Object? { + get + } + @inlinable public func `as`(_ overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + safe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func `as`(unsafe overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + unsafe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +extension Capture.CaptureItemProtocol where Self : Swift.Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +@propertyWrapper public struct Captured : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Captured + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @_disfavoredOverload public init(wrappedValue: Object? = nil, strong: Swift.Bool = false) + public init(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(unsafe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(safe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + @inlinable public init(wrappedValue: Object, _ strategy: Capture.ObjectCaptureStrategy = .weak) { + self.init(wrappedValue, as: strategy) + } +} +extension Capture.Captured : @unchecked Swift.Sendable where Object : Swift.Sendable { +} +public protocol __OptionalReferenceContainerProtocol<__CaptureRefObject> { + associatedtype __CaptureRefObject : AnyObject +} +public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Capture.__OptionalReferenceContainerProtocol { +} +@propertyWrapper public struct Strong : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Strong + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Strong { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object? = nil) + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } +} +extension Capture.Strong : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Unowned : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Unowned + public typealias __CaptureRefObject = Object + unowned public var wrappedValue: Object { + get + set + _modify + } + unowned public var object: Object { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Unowned { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object) + @inlinable public init(_ object: Object) { + self.init(wrappedValue: object) + } +} +extension Capture.Unowned : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Weak : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Weak + public typealias __CaptureRefObject = Object + weak public var wrappedValue: Object? { + get + set + _modify + } + weak public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Weak { + get { self } + set { self = newValue } + _modify { yield &self } + } + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } + public init(wrappedValue: Object? = nil) +} +extension Capture.Weak : Swift.Sendable where Object : Swift.Sendable { +} +@available(*, deprecated, renamed: "CapturableObjectProtocol", message: "Use CapturableObjectProtocol protocol instead") +public typealias Weakifiable = Capture.CapturableObjectProtocol +extension Capture.ObjectCaptureStrategy : Swift.Equatable {} +extension Capture.ObjectCaptureStrategy : Swift.Hashable {} From d3e81cc094025b7fcb74b807248ef395e785be46 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 5 Aug 2026 07:04:56 +0200 Subject: [PATCH 3/5] Update macos Swift interfaces (#6) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../interfaces/macos/Capture.swiftinterface | 227 +++++++++--------- 1 file changed, 112 insertions(+), 115 deletions(-) diff --git a/.agents/interfaces/macos/Capture.swiftinterface b/.agents/interfaces/macos/Capture.swiftinterface index debfe9b..6c1fe15 100644 --- a/.agents/interfaces/macos/Capture.swiftinterface +++ b/.agents/interfaces/macos/Capture.swiftinterface @@ -1,7 +1,7 @@ // swift-interface-format-version: 1.0 -// swift-compiler-version: Apple Swift version 6.4 (swiftlang-6.4.0.25.4 clang-2100.3.25.1) -// swift-module-flags: -target arm64-apple-macos12.0 -enable-objc-interop -language-mode 6 -O -enable-experimental-feature DebugDescriptionMacro -module-name Capture -package-name swift_capture -// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.4 +// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101) +// swift-module-flags: -target arm64-apple-macosx10.13 -enable-objc-interop -swift-version 6 -O -module-name Capture -package-name swift_capture +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 import Foundation import Swift import _Concurrency @@ -9,280 +9,277 @@ import _StringProcessing import _SwiftConcurrencyShims public protocol CapturableObjectProtocol : AnyObject { } -public enum ObjectCaptureStrategy : Swift::Sendable { +public enum ObjectCaptureStrategy : Swift.Sendable { case weak case strong case unowned - @_semantics("derived_enum_equals") @_implements(Swift::Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Capture::ObjectCaptureStrategy, _ b: Capture::ObjectCaptureStrategy) -> Swift::Bool - public func hash(into hasher: inout Swift::Hasher) - public var hashValue: Swift::Int { + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Capture.ObjectCaptureStrategy, _ b: Capture.ObjectCaptureStrategy) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { get } } -extension Capture::CapturableObjectProtocol { - @inlinable public var capture: some Capture::CaptureItemProtocol { +extension Capture.CapturableObjectProtocol { + @inlinable public var capture: Capture.CaptureItem { get { CaptureItem(Captured(self, as: .weak)) } } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Swift::Void) -> (repeat each Arg) -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Swift::Void) -> (repeat each Arg) throws -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Swift::Void) -> (repeat each Arg) async -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Swift::Void) -> (repeat each Arg) async throws -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { capture.as(strategy)(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { capture.as(strategy)(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { capture.as(strategy)(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { capture.as(strategy)(orReturn: defaultValue, in: closure) } } -extension Capture::CapturableObjectProtocol where Self : Swift::Sendable { - public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Swift::Void) -> @Sendable (repeat each Arg) -> Swift::Void - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Swift::Void) -> @Sendable (repeat each Arg) throws -> Swift::Void { +extension Capture.CapturableObjectProtocol where Self : Swift.Sendable { + public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Swift::Void) -> @Sendable (repeat each Arg) async -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Swift::Void) -> @Sendable (repeat each Arg) async throws -> Swift::Void { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { capture( as: strategy, orReturn: (), in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { capture( as: strategy, orReturn: nil, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { capture( as: strategy, orReturn: { nil }, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { capture( as: strategy, orReturn: { nil }, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift::Sendable { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift::Sendable { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { capture( as: strategy, orReturn: defaultValue, in: closure ) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) } - @inlinable public func capture(as strategy: Capture::ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) } } -extension ObjectiveC::NSObject : Capture::CapturableObjectProtocol { +extension ObjectiveC.NSObject : Capture.CapturableObjectProtocol { } -@inlinable public func capture(_ object: Object, as strategy: Capture::ObjectCaptureStrategy = .weak) -> some Capture::CaptureItemProtocol where Object : AnyObject { +@inlinable public func capture(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) -> Capture.CaptureItem where Object : AnyObject { Captured(object, as: strategy).capture } - -public typealias _SendableCaptureItemProtocol = Capture::CaptureItemProtocol & Swift::Sendable -public protocol CaptureItemProtocol : Capture::__OptionalReferenceContainerProtocol { +public typealias _SendableCaptureItemProtocol = Capture.CaptureItemProtocol & Swift.Sendable +public protocol CaptureItemProtocol : Capture.__OptionalReferenceContainerProtocol { associatedtype Object where Self.Object == Self.__CaptureRefObject } -public struct CaptureItem : Capture::CaptureItemProtocol where Object : AnyObject { - public init(_ container: any Capture::__OptionalReferenceContainerProtocol) - public struct UncheckedSendable : Capture::CaptureItemProtocol, @unchecked Swift::Sendable { - public init(_ container: any Capture::__OptionalReferenceContainerProtocol) +public struct CaptureItem : Capture.CaptureItemProtocol where Object : AnyObject { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public struct UncheckedSendable : Capture.CaptureItemProtocol, @unchecked Swift.Sendable { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) public typealias __CaptureRefObject = Object } public typealias __CaptureRefObject = Object } -extension Capture::_OptionalReferenceContainerProtocol { - public var capture: some Capture::CaptureItemProtocol { +extension Capture._OptionalReferenceContainerProtocol { + public var capture: Capture.CaptureItem { get } } -extension Capture::__OptionalReferenceContainerProtocol { - public var uncheckedSendable: some Capture::CaptureItemProtocol & Swift::Sendable { +extension Capture.__OptionalReferenceContainerProtocol { + public var uncheckedSendable: Capture.CaptureItem.UncheckedSendable { get } } -extension Capture::CaptureItemProtocol { +extension Capture.CaptureItemProtocol { @usableFromInline internal var object: Self.Object? { get } - @inlinable public func `as`(_ overrideCaptureStrategy: Capture::ObjectCaptureStrategy) -> some Capture::CaptureItemProtocol { + @inlinable public func `as`(_ overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { return CaptureItem(Captured( safe: object, as: overrideCaptureStrategy )) } - - @inlinable public func `as`(unsafe overrideCaptureStrategy: Capture::ObjectCaptureStrategy) -> some Capture::CaptureItemProtocol { + @inlinable public func `as`(unsafe overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { return CaptureItem(Captured( unsafe: object, as: overrideCaptureStrategy )) } - @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { callAsFunction(orReturn: defaultValue, in: closure) } @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output where Output : Swift::Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output where Output : Swift::Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Swift::Void) -> (repeat each Arg) -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Swift::Void) -> (repeat each Arg) throws -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Swift::Void) -> (repeat each Arg) async -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift::Void) -> (repeat each Arg) async throws -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { callAsFunction(orReturn: (), in: closure) } @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { @@ -334,29 +331,29 @@ extension Capture::CaptureItemProtocol { } } } -extension Capture::CaptureItemProtocol where Self : Swift::Sendable { +extension Capture.CaptureItemProtocol where Self : Swift.Sendable { @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { callAsFunction(orReturn: defaultValue, in: closure) } @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift::Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift::Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift::Void) -> @Sendable (repeat each Arg) -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift::Void) -> @Sendable (repeat each Arg) throws -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift::Void) -> @Sendable (repeat each Arg) async -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { callAsFunction(orReturn: (), in: closure) } - @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift::Void) -> @Sendable (repeat each Arg) async throws -> Swift::Void { + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { callAsFunction(orReturn: (), in: closure) } @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { @@ -377,10 +374,10 @@ extension Capture::CaptureItemProtocol where Self : Swift::Sendable { @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift::Sendable { + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } - @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift::Sendable { + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { callAsFunction(orReturn: defaultValue, in: closure) } @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { @@ -407,69 +404,69 @@ extension Capture::CaptureItemProtocol where Self : Swift::Sendable { return try await closure(object, repeat each arg) } } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift::Void) -> @_Concurrency::MainActor @Sendable (repeat each Arg) -> Swift::Void { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Swift.Void { onMainActor(orReturn: (), in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift::Void) -> @_Concurrency::MainActor @Sendable (repeat each Arg) throws -> Swift::Void { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Swift.Void { onMainActor(orReturn: (), in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift::Void) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async -> Swift::Void { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Swift.Void { onMainActor(orReturn: (), in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift::Void) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async throws -> Swift::Void { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Swift.Void { onMainActor(orReturn: (), in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @_Concurrency::MainActor @Sendable (repeat each Arg) -> Output? { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output? { onMainActor(orReturn: nil, in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @_Concurrency::MainActor @Sendable (repeat each Arg) throws -> Output? { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output? { onMainActor(orReturn: nil, in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async -> Output? { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output? { onMainActor(orReturn: nil, in: closure) } - @inlinable public func onMainActor(in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async throws -> Output? { + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output? { onMainActor(orReturn: nil, in: closure) } - @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency::MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { onMainActor(orReturn: defaultValue, in: closure) } - @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency::MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) throws -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { onMainActor(orReturn: defaultValue, in: closure) } - @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency::MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { onMainActor(orReturn: defaultValue, in: closure) } - @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency::MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async throws -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { onMainActor(orReturn: defaultValue, in: closure) } - @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency::MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { return { [self] (arg: repeat each Arg) in guard let object else { return defaultValue() } return closure(object, repeat each arg) } } - @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency::MainActor @Sendable () throws -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) throws -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { return { [self] (arg: repeat each Arg) in guard let object else { return try defaultValue() } return try closure(object, repeat each arg) } } - @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency::MainActor @Sendable () async -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { return { [self] (arg: repeat each Arg) in guard let object else { return await defaultValue() } return await closure(object, repeat each arg) } } - @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency::MainActor @Sendable () async throws -> Output, in closure: @escaping @_Concurrency::MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency::MainActor @Sendable (repeat each Arg) async throws -> Output { + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { return { [self] (arg: repeat each Arg) in guard let object else { return try await defaultValue() } return try await closure(object, repeat each arg) } } } -@propertyWrapper public struct Captured : Capture::_OptionalReferenceContainerProtocol where Object : AnyObject { - public typealias RootContainer = Capture::Captured +@propertyWrapper public struct Captured : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Captured public typealias __CaptureRefObject = Object public var wrappedValue: Object? { get @@ -481,23 +478,23 @@ extension Capture::CaptureItemProtocol where Self : Swift::Sendable { set _modify } - @_disfavoredOverload public init(wrappedValue: Object? = nil, strong: Swift::Bool = false) - public init(_ object: Object, as strategy: Capture::ObjectCaptureStrategy = .weak) - public init(unsafe object: Object?, as strategy: Capture::ObjectCaptureStrategy = .weak) - public init(safe object: Object?, as strategy: Capture::ObjectCaptureStrategy = .weak) - @inlinable public init(wrappedValue: Object, _ strategy: Capture::ObjectCaptureStrategy = .weak) { + @_disfavoredOverload public init(wrappedValue: Object? = nil, strong: Swift.Bool = false) + public init(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(unsafe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(safe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + @inlinable public init(wrappedValue: Object, _ strategy: Capture.ObjectCaptureStrategy = .weak) { self.init(wrappedValue, as: strategy) } } -extension Capture::Captured : @unchecked Swift::Sendable where Object : Swift::Sendable { +extension Capture.Captured : @unchecked Swift.Sendable where Object : Swift.Sendable { } public protocol __OptionalReferenceContainerProtocol<__CaptureRefObject> { associatedtype __CaptureRefObject : AnyObject } -public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Capture::__OptionalReferenceContainerProtocol { +public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Capture.__OptionalReferenceContainerProtocol { } -@propertyWrapper public struct Strong : Capture::_OptionalReferenceContainerProtocol where Object : AnyObject { - public typealias RootContainer = Capture::Strong +@propertyWrapper public struct Strong : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Strong public typealias __CaptureRefObject = Object public var wrappedValue: Object? { get @@ -509,7 +506,7 @@ public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Captur set _modify } - @inlinable public var projectedValue: Capture::Strong { + @inlinable public var projectedValue: Capture.Strong { get { self } set { self = newValue } _modify { yield &self } @@ -519,10 +516,10 @@ public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Captur self.init(wrappedValue: object) } } -extension Capture::Strong : Swift::Sendable where Object : Swift::Sendable { +extension Capture.Strong : Swift.Sendable where Object : Swift.Sendable { } -@propertyWrapper public struct Unowned : Capture::_OptionalReferenceContainerProtocol where Object : AnyObject { - public typealias RootContainer = Capture::Unowned +@propertyWrapper public struct Unowned : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Unowned public typealias __CaptureRefObject = Object unowned public var wrappedValue: Object { get @@ -534,7 +531,7 @@ extension Capture::Strong : Swift::Sendable where Object : Swift::Sendable { set _modify } - @inlinable public var projectedValue: Capture::Unowned { + @inlinable public var projectedValue: Capture.Unowned { get { self } set { self = newValue } _modify { yield &self } @@ -544,10 +541,10 @@ extension Capture::Strong : Swift::Sendable where Object : Swift::Sendable { self.init(wrappedValue: object) } } -extension Capture::Unowned : Swift::Sendable where Object : Swift::Sendable { +extension Capture.Unowned : Swift.Sendable where Object : Swift.Sendable { } -@propertyWrapper public struct Weak : Capture::_OptionalReferenceContainerProtocol where Object : AnyObject { - public typealias RootContainer = Capture::Weak +@propertyWrapper public struct Weak : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Weak public typealias __CaptureRefObject = Object weak public var wrappedValue: Object? { get @@ -559,7 +556,7 @@ extension Capture::Unowned : Swift::Sendable where Object : Swift::Sendable { set _modify } - @inlinable public var projectedValue: Capture::Weak { + @inlinable public var projectedValue: Capture.Weak { get { self } set { self = newValue } _modify { yield &self } @@ -569,9 +566,9 @@ extension Capture::Unowned : Swift::Sendable where Object : Swift::Sendable { } public init(wrappedValue: Object? = nil) } -extension Capture::Weak : Swift::Sendable where Object : Swift::Sendable { +extension Capture.Weak : Swift.Sendable where Object : Swift.Sendable { } @available(*, deprecated, renamed: "CapturableObjectProtocol", message: "Use CapturableObjectProtocol protocol instead") -public typealias Weakifiable = Capture::CapturableObjectProtocol -extension Capture::ObjectCaptureStrategy : Swift::Equatable {} -extension Capture::ObjectCaptureStrategy : Swift::Hashable {} +public typealias Weakifiable = Capture.CapturableObjectProtocol +extension Capture.ObjectCaptureStrategy : Swift.Equatable {} +extension Capture.ObjectCaptureStrategy : Swift.Hashable {} From f01277873ac5f7f7a2b33b5770f7cdb06664964a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 5 Aug 2026 07:05:00 +0200 Subject: [PATCH 4/5] Update tvos Swift interfaces (#7) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../interfaces/tvos/Capture.swiftinterface | 574 ++++++++++++++++++ 1 file changed, 574 insertions(+) create mode 100644 .agents/interfaces/tvos/Capture.swiftinterface diff --git a/.agents/interfaces/tvos/Capture.swiftinterface b/.agents/interfaces/tvos/Capture.swiftinterface new file mode 100644 index 0000000..e2f059a --- /dev/null +++ b/.agents/interfaces/tvos/Capture.swiftinterface @@ -0,0 +1,574 @@ +// swift-interface-format-version: 1.0 +// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101) +// swift-module-flags: -target arm64-apple-tvos12.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Capture -package-name swift_capture +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public protocol CapturableObjectProtocol : AnyObject { +} +public enum ObjectCaptureStrategy : Swift.Sendable { + case weak + case strong + case unowned + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Capture.ObjectCaptureStrategy, _ b: Capture.ObjectCaptureStrategy) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +extension Capture.CapturableObjectProtocol { + @inlinable public var capture: Capture.CaptureItem { + get { + CaptureItem(Captured(self, as: .weak)) + } + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } +} +extension Capture.CapturableObjectProtocol where Self : Swift.Sendable { + public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } +} +extension ObjectiveC.NSObject : Capture.CapturableObjectProtocol { +} +@inlinable public func capture(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) -> Capture.CaptureItem where Object : AnyObject { + Captured(object, as: strategy).capture +} +public typealias _SendableCaptureItemProtocol = Capture.CaptureItemProtocol & Swift.Sendable +public protocol CaptureItemProtocol : Capture.__OptionalReferenceContainerProtocol { + associatedtype Object where Self.Object == Self.__CaptureRefObject +} +public struct CaptureItem : Capture.CaptureItemProtocol where Object : AnyObject { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public struct UncheckedSendable : Capture.CaptureItemProtocol, @unchecked Swift.Sendable { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public typealias __CaptureRefObject = Object + } + public typealias __CaptureRefObject = Object +} +extension Capture._OptionalReferenceContainerProtocol { + public var capture: Capture.CaptureItem { + get + } +} +extension Capture.__OptionalReferenceContainerProtocol { + public var uncheckedSendable: Capture.CaptureItem.UncheckedSendable { + get + } +} +extension Capture.CaptureItemProtocol { + @usableFromInline + internal var object: Self.Object? { + get + } + @inlinable public func `as`(_ overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + safe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func `as`(unsafe overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + unsafe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +extension Capture.CaptureItemProtocol where Self : Swift.Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +@propertyWrapper public struct Captured : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Captured + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @_disfavoredOverload public init(wrappedValue: Object? = nil, strong: Swift.Bool = false) + public init(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(unsafe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(safe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + @inlinable public init(wrappedValue: Object, _ strategy: Capture.ObjectCaptureStrategy = .weak) { + self.init(wrappedValue, as: strategy) + } +} +extension Capture.Captured : @unchecked Swift.Sendable where Object : Swift.Sendable { +} +public protocol __OptionalReferenceContainerProtocol<__CaptureRefObject> { + associatedtype __CaptureRefObject : AnyObject +} +public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Capture.__OptionalReferenceContainerProtocol { +} +@propertyWrapper public struct Strong : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Strong + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Strong { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object? = nil) + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } +} +extension Capture.Strong : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Unowned : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Unowned + public typealias __CaptureRefObject = Object + unowned public var wrappedValue: Object { + get + set + _modify + } + unowned public var object: Object { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Unowned { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object) + @inlinable public init(_ object: Object) { + self.init(wrappedValue: object) + } +} +extension Capture.Unowned : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Weak : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Weak + public typealias __CaptureRefObject = Object + weak public var wrappedValue: Object? { + get + set + _modify + } + weak public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Weak { + get { self } + set { self = newValue } + _modify { yield &self } + } + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } + public init(wrappedValue: Object? = nil) +} +extension Capture.Weak : Swift.Sendable where Object : Swift.Sendable { +} +@available(*, deprecated, renamed: "CapturableObjectProtocol", message: "Use CapturableObjectProtocol protocol instead") +public typealias Weakifiable = Capture.CapturableObjectProtocol +extension Capture.ObjectCaptureStrategy : Swift.Equatable {} +extension Capture.ObjectCaptureStrategy : Swift.Hashable {} From 7aa550ba916fde2d442311cb8301739bf4d9e110 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 5 Aug 2026 07:05:03 +0200 Subject: [PATCH 5/5] Update watchos Swift interfaces (#8) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../interfaces/watchos/Capture.swiftinterface | 574 ++++++++++++++++++ 1 file changed, 574 insertions(+) create mode 100644 .agents/interfaces/watchos/Capture.swiftinterface diff --git a/.agents/interfaces/watchos/Capture.swiftinterface b/.agents/interfaces/watchos/Capture.swiftinterface new file mode 100644 index 0000000..c4cac14 --- /dev/null +++ b/.agents/interfaces/watchos/Capture.swiftinterface @@ -0,0 +1,574 @@ +// swift-interface-format-version: 1.0 +// swift-compiler-version: Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101) +// swift-module-flags: -target arm64-apple-watchos4.0-simulator -enable-objc-interop -swift-version 6 -O -module-name Capture -package-name swift_capture +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public protocol CapturableObjectProtocol : AnyObject { +} +public enum ObjectCaptureStrategy : Swift.Sendable { + case weak + case strong + case unowned + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: Capture.ObjectCaptureStrategy, _ b: Capture.ObjectCaptureStrategy) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +extension Capture.CapturableObjectProtocol { + @inlinable public var capture: Capture.CaptureItem { + get { + CaptureItem(Captured(self, as: .weak)) + } + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping (Self, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + capture.as(strategy)(orReturn: defaultValue, in: closure) + } +} +extension Capture.CapturableObjectProtocol where Self : Swift.Sendable { + public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + capture( + as: strategy, + orReturn: (), + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + capture( + as: strategy, + orReturn: nil, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + capture( + as: strategy, + orReturn: { nil }, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + capture( + as: strategy, + orReturn: defaultValue, + in: closure + ) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } + @inlinable public func capture(as strategy: Capture.ObjectCaptureStrategy, orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + capture.as(strategy).uncheckedSendable(orReturn: defaultValue, in: closure) + } +} +extension ObjectiveC.NSObject : Capture.CapturableObjectProtocol { +} +@inlinable public func capture(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) -> Capture.CaptureItem where Object : AnyObject { + Captured(object, as: strategy).capture +} +public typealias _SendableCaptureItemProtocol = Capture.CaptureItemProtocol & Swift.Sendable +public protocol CaptureItemProtocol : Capture.__OptionalReferenceContainerProtocol { + associatedtype Object where Self.Object == Self.__CaptureRefObject +} +public struct CaptureItem : Capture.CaptureItemProtocol where Object : AnyObject { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public struct UncheckedSendable : Capture.CaptureItemProtocol, @unchecked Swift.Sendable { + public init(_ container: any Capture.__OptionalReferenceContainerProtocol) + public typealias __CaptureRefObject = Object + } + public typealias __CaptureRefObject = Object +} +extension Capture._OptionalReferenceContainerProtocol { + public var capture: Capture.CaptureItem { + get + } +} +extension Capture.__OptionalReferenceContainerProtocol { + public var uncheckedSendable: Capture.CaptureItem.UncheckedSendable { + get + } +} +extension Capture.CaptureItemProtocol { + @usableFromInline + internal var object: Self.Object? { + get + } + @inlinable public func `as`(_ overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + safe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func `as`(unsafe overrideCaptureStrategy: Capture.ObjectCaptureStrategy) -> Capture.CaptureItem { + return CaptureItem(Captured( + unsafe: object, + as: overrideCaptureStrategy + )) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> (repeat each Arg) async -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) -> Output) -> (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping () async throws -> Output, in closure: @escaping (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +extension Capture.CaptureItemProtocol where Self : Swift.Sendable { + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func orReturn(_ defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @Sendable (repeat each Arg) -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @Sendable (repeat each Arg) throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @Sendable (repeat each Arg) async -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @Sendable (repeat each Arg) async throws -> Swift.Void { + callAsFunction(orReturn: (), in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @Sendable (repeat each Arg) -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @Sendable (repeat each Arg) throws -> Output? { + callAsFunction(orReturn: nil, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @Sendable (repeat each Arg) async -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @Sendable (repeat each Arg) async throws -> Output? { + callAsFunction(orReturn: { nil }, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @autoclosure @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output where Output : Swift.Sendable { + callAsFunction(orReturn: defaultValue, in: closure) + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func callAsFunction(orReturn defaultValue: @escaping @Sendable () async throws -> Output, in closure: @escaping @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Swift.Void) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Swift.Void { + onMainActor(orReturn: (), in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output?) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output? { + onMainActor(orReturn: nil, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @autoclosure @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + onMainActor(orReturn: defaultValue, in: closure) + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return defaultValue() } + return closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try defaultValue() } + return try closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return await defaultValue() } + return await closure(object, repeat each arg) + } + } + @inlinable public func onMainActor(orReturn defaultValue: @escaping @_Concurrency.MainActor @Sendable () async throws -> Output, in closure: @escaping @_Concurrency.MainActor @Sendable (Self.__CaptureRefObject, repeat each Arg) async throws -> Output) -> @_Concurrency.MainActor @Sendable (repeat each Arg) async throws -> Output { + return { [self] (arg: repeat each Arg) in + guard let object else { return try await defaultValue() } + return try await closure(object, repeat each arg) + } + } +} +@propertyWrapper public struct Captured : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Captured + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @_disfavoredOverload public init(wrappedValue: Object? = nil, strong: Swift.Bool = false) + public init(_ object: Object, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(unsafe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + public init(safe object: Object?, as strategy: Capture.ObjectCaptureStrategy = .weak) + @inlinable public init(wrappedValue: Object, _ strategy: Capture.ObjectCaptureStrategy = .weak) { + self.init(wrappedValue, as: strategy) + } +} +extension Capture.Captured : @unchecked Swift.Sendable where Object : Swift.Sendable { +} +public protocol __OptionalReferenceContainerProtocol<__CaptureRefObject> { + associatedtype __CaptureRefObject : AnyObject +} +public protocol _OptionalReferenceContainerProtocol<__CaptureRefObject> : Capture.__OptionalReferenceContainerProtocol { +} +@propertyWrapper public struct Strong : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Strong + public typealias __CaptureRefObject = Object + public var wrappedValue: Object? { + get + set + _modify + } + public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Strong { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object? = nil) + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } +} +extension Capture.Strong : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Unowned : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Unowned + public typealias __CaptureRefObject = Object + unowned public var wrappedValue: Object { + get + set + _modify + } + unowned public var object: Object { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Unowned { + get { self } + set { self = newValue } + _modify { yield &self } + } + public init(wrappedValue: Object) + @inlinable public init(_ object: Object) { + self.init(wrappedValue: object) + } +} +extension Capture.Unowned : Swift.Sendable where Object : Swift.Sendable { +} +@propertyWrapper public struct Weak : Capture._OptionalReferenceContainerProtocol where Object : AnyObject { + public typealias RootContainer = Capture.Weak + public typealias __CaptureRefObject = Object + weak public var wrappedValue: Object? { + get + set + _modify + } + weak public var object: Object? { + get + set + _modify + } + @inlinable public var projectedValue: Capture.Weak { + get { self } + set { self = newValue } + _modify { yield &self } + } + @inlinable public init(_ object: Object?) { + self.init(wrappedValue: object) + } + public init(wrappedValue: Object? = nil) +} +extension Capture.Weak : Swift.Sendable where Object : Swift.Sendable { +} +@available(*, deprecated, renamed: "CapturableObjectProtocol", message: "Use CapturableObjectProtocol protocol instead") +public typealias Weakifiable = Capture.CapturableObjectProtocol +extension Capture.ObjectCaptureStrategy : Swift.Equatable {} +extension Capture.ObjectCaptureStrategy : Swift.Hashable {}