From c537e0ceeee60f783219a0609894c2112238d00f 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:38:12 +0000 Subject: [PATCH 1/5] Prepare Swift interface update From 56629a191cf80ab24a33b3e44a0f5f9a50dd9338 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:30 +0200 Subject: [PATCH 2/5] Update tvos Swift interfaces (#15) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../DeclarativeConfiguration.swiftinterface | 176 ++++++++++++ ...eclarativeConfigurationCore.swiftinterface | 253 ++++++++++++++++++ .../tvos/FunctionalBuilder.swiftinterface | 13 + .../tvos/FunctionalClosures.swiftinterface | 236 ++++++++++++++++ .../FunctionalConfigurator.swiftinterface | 38 +++ .../tvos/FunctionalKeyPath.swiftinterface | 162 +++++++++++ .../FunctionalModification.swiftinterface | 14 + 7 files changed, 892 insertions(+) create mode 100644 .agents/interfaces/tvos/DeclarativeConfiguration.swiftinterface create mode 100644 .agents/interfaces/tvos/DeclarativeConfigurationCore.swiftinterface create mode 100644 .agents/interfaces/tvos/FunctionalBuilder.swiftinterface create mode 100644 .agents/interfaces/tvos/FunctionalClosures.swiftinterface create mode 100644 .agents/interfaces/tvos/FunctionalConfigurator.swiftinterface create mode 100644 .agents/interfaces/tvos/FunctionalKeyPath.swiftinterface create mode 100644 .agents/interfaces/tvos/FunctionalModification.swiftinterface diff --git a/.agents/interfaces/tvos/DeclarativeConfiguration.swiftinterface b/.agents/interfaces/tvos/DeclarativeConfiguration.swiftinterface new file mode 100644 index 0000000..403e859 --- /dev/null +++ b/.agents/interfaces/tvos/DeclarativeConfiguration.swiftinterface @@ -0,0 +1,176 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfiguration -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Foundation +@_exported import FunctionalClosures +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@dynamicMemberLookup public struct Builder : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var initialValue: () -> Base + @_hasStorage public var configurator: DeclarativeConfiguration.Configurator { + get + } + @inlinable public var base: Base { + get { initialValue() } + } + @inlinable public init(_ initialValue: @autoclosure @escaping () -> Base) { + self.init( + initialValue: initialValue, + configurator: .empty + ) + } + public init(initialValue: @escaping () -> Base, configurator: DeclarativeConfiguration.Configurator) + @inlinable public func build() -> Base { configurator.configured(base) } + @inlinable public func apply() where Base : AnyObject { _ = build() } + @inlinable public func commit() -> DeclarativeConfiguration.Builder { .init(build()) } + @inlinable public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.combined(with: configurator) + ) + } + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Builder + @inlinable public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.modify(transform) + ) + } +} +public protocol BuilderProvider { +} +extension DeclarativeConfiguration.BuilderProvider { + @inlinable public var builder: DeclarativeConfiguration.Builder { + get { .init(self) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.BuilderProvider { +} +@dynamicMemberLookup public struct Configurator : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var storage: any DeclarativeConfigurationCore.ConfigurationStorage + public init(storage: any DeclarativeConfigurationCore.ConfigurationStorage) + @inlinable public init() { + self.init(storage: DefaultConfigurationStorage()) + } + @inlinable public init(config configuration: (DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator) { + self = configuration(.empty) + } + @inlinable public func configure(_ base: inout Base) { + base = configured(base) + } + public func configure(_ base: Base) where Base : AnyObject + public func configured(_ base: Base) -> Base + public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator + public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator + @inlinable public static var empty: DeclarativeConfiguration.Configurator { + get { + .init(storage: DefaultConfigurationStorage()) + } + } + @inlinable public static func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + empty.modify(transform) + } + @inlinable public static func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + empty.transform(transform) + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } +} +extension DeclarativeConfiguration.Configurator where Base : SwiftMarkerProtocols._OptionalProtocol { + public static var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks>.CallableIfLet { + get + } + public static func ifNil(_ newValue: Base) -> DeclarativeConfiguration.Configurator +} +extension DeclarativeConfigurationCore.AnyConfigurationContainer { + public static func config(_ config: DeclarativeConfiguration.Configurator) -> DeclarativeConfigurationCore.AnyConfigurationContainer +} +public protocol CallAsFunctionConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + @discardableResult + @inlinable public func callAsFunction(config configuration: (Self.Config) -> Self.Config) -> Self { + configuration(.empty).configured(self) + } +} +public protocol CustomConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CustomConfigurableProtocol { + @inlinable public func configured(using configuration: (Self.Config) -> Self.Config) -> Self { + configured(using: configuration(.empty)) + } + @inlinable public func configured(using configurator: Self.Config) -> Self { + configurator.configured(self) + } + @inlinable public mutating func configure(using configuration: (Self.Config) -> Self.Config) { + self = configured(using: configuration(.empty)) + } + @inlinable public mutating func configure(using configurator: Self.Config) { + self = configured(using: configurator) + } +} +extension DeclarativeConfiguration.CustomConfigurableProtocol where Self : AnyObject { + @inlinable public func configure(using configuration: (Self.Config) -> Self.Config) { + configure(using: configuration(.empty)) + } + @inlinable public func configure(using configurator: Self.Config) { + configurator.configure(self) + } +} +public protocol _BaseConfigurableProtocol { +} +extension DeclarativeConfiguration._BaseConfigurableProtocol { + public typealias Config = DeclarativeConfiguration.Configurator +} +extension DeclarativeConfiguration.Builder { + @available(*, deprecated, message: "Use `.combined(with: builder.configurator)` instead.\nThis API will be removed in v1.0.0.") + @inlinable public func combined(with builder: DeclarativeConfiguration.Builder) -> DeclarativeConfiguration.Builder { + combined(with: builder.configurator) + } + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + modify(transform) + } + @available(*, deprecated, message: "Use `modify` and capture arguments explicitly instead.\nThis API is likely to be removed in v1.0.0") + @inlinable public func reinforce(_ args: repeat each Arg, transform: @escaping (inout Base, repeat each Arg) -> Swift.Void) -> DeclarativeConfiguration.Builder { + commit().modify { transform(&$0, repeat each args) } + } +} +extension DeclarativeConfiguration.Configurator { + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + modify(transform) + } + @available(*, deprecated, renamed: "transform", message: "This API will be removed in v1.0.0.") + @inlinable public func appendingConfiguration(_ configuration: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + modify { $0 = configuration($0) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CustomConfigurableProtocol {} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol {} diff --git a/.agents/interfaces/tvos/DeclarativeConfigurationCore.swiftinterface b/.agents/interfaces/tvos/DeclarativeConfigurationCore.swiftinterface new file mode 100644 index 0000000..6f328d4 --- /dev/null +++ b/.agents/interfaces/tvos/DeclarativeConfigurationCore.swiftinterface @@ -0,0 +1,253 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfigurationCore -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import IssueReporting +import KeyPathsExtensions +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum ConfigurationBlocks where Container : DeclarativeConfigurationCore.ConfigurationContainer { + @dynamicMemberLookup public struct Callable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Value) -> Value) -> Container + public func modify(_ transform: @escaping (inout Value) -> Swift.Void) -> Container + public func callAsFunction(_ value: Value) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct CallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath.CallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath.CallableIfLet.Value>) + public func peek(_ operation: @escaping (Wrapped) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Wrapped) -> Wrapped) -> Container + public func modify(_ transform: @escaping (inout Wrapped) -> Swift.Void) -> Container + public func callAsFunction(_ newValue: Wrapped) -> Container + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value == Wrapped? { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value == Wrapped? { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath.NonCallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath.NonCallableIfLet.Value>) + public func peek(_ operation: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.Value) -> Swift.Void) -> Container + @available(*, unavailable, message: "Not available for non-writable key path") + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + public func configured(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func callAsFunction(ifLet newValue: Value?) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func callAsFunction(ifLet newValue: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value?) -> Container +} +public protocol ConfigurationContainer { + associatedtype Base +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks +} +extension DeclarativeConfigurationCore.ConfigurationContainer where Self.Base : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ newValue: Self.Base) -> Self +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + .init(container: self, keyPath: keyPath) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + .init(container: self, keyPath: keyPath) + } + } + public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Self.Base == Wrapped? { + get + } + public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Self.Base == Wrapped? { + get + } +} +@dynamicMemberLookup public struct AnyConfigurationContainer : DeclarativeConfigurationCore.ConfigurationContainer { + internal let underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer + public init(_ underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer) +} +public protocol ConfigurationStorage { + associatedtype Base +} +public struct DefaultConfigurationStorage : DeclarativeConfigurationCore.ConfigurationStorage { + internal var items: [any DeclarativeConfigurationCore._ConfigurationItem] + public init() +} +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +} diff --git a/.agents/interfaces/tvos/FunctionalBuilder.swiftinterface b/.agents/interfaces/tvos/FunctionalBuilder.swiftinterface new file mode 100644 index 0000000..2335f7b --- /dev/null +++ b/.agents/interfaces/tvos/FunctionalBuilder.swiftinterface @@ -0,0 +1,13 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalBuilder -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Builder = DeclarativeConfiguration.Builder +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias BuilderProvider = DeclarativeConfiguration.BuilderProvider diff --git a/.agents/interfaces/tvos/FunctionalClosures.swiftinterface b/.agents/interfaces/tvos/FunctionalClosures.swiftinterface new file mode 100644 index 0000000..79689d0 --- /dev/null +++ b/.agents/interfaces/tvos/FunctionalClosures.swiftinterface @@ -0,0 +1,236 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalClosures -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum HandlerContainerBehaviour { + case resetting + case preceding + case appending + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: FunctionalClosures.HandlerContainerBehaviour, _ b: FunctionalClosures.HandlerContainerBehaviour) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class _Handler { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((repeat each T) -> Swift.Void)? + public init(action: ((repeat each T) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((repeat each T) -> Swift.Void)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures._Handler.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures._Handler.Container + public var projectedValue: ((repeat each T) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: repeat each T) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +public typealias Handler = FunctionalClosures.Handler1 +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler1 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Swift.Void)? + public init(action: ((Input) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Swift.Void)?) { + self.action = action + } + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/CaptureContext/swift-declarative-configuration/issues/1") + @inlinable public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler1.Container.Behaviour, perform action: ((Input) -> Swift.Void)?) { + switch behaviour { + case .resetting: + self.action = action + case .preceding: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + case .appending: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + } + } + } + public init() + public init(wrappedValue: FunctionalClosures.Handler1.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler1.Container + public var projectedValue: ((Input) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: Input) + public func callAsFunction() where Input == () + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler2 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1) -> Swift.Void)? + public init(action: ((T0, T1) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler2.Container.Behaviour, perform action: ((T0, T1) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler2.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler2.Container + public var projectedValue: ((T0, T1) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler3 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2) -> Swift.Void)? + public init(action: ((T0, T1, T2) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler3.Container.Behaviour, perform action: ((T0, T1, T2) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler3.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler3.Container + public var projectedValue: ((T0, T1, T2) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler4 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler4.Container.Behaviour, perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler4.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler4.Container + public var projectedValue: ((T0, T1, T2, T3) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler5 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3, T4) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler5.Container.Behaviour, perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler5.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler5.Container + public var projectedValue: ((T0, T1, T2, T3, T4) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4) + @objc deinit +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class _DataSource { + public struct Container { + @usableFromInline + internal var action: (repeat each T) -> Output + public init(action: @escaping (repeat each T) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (repeat each T) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures._DataSource.Container) + public var wrappedValue: FunctionalClosures._DataSource.Container + @inlinable public var projectedValue: (repeat each T) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ args: repeat each T) -> Output? { + projectedValue(repeat each args) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class DataSource { + public struct Container { + @usableFromInline + internal var action: (Input) -> Output + public init(action: @escaping (Input) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (Input) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures.DataSource.Container) + public var wrappedValue: FunctionalClosures.DataSource.Container + @inlinable public var projectedValue: (Input) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue(input) + } + @inlinable public func callAsFunction() -> Output where Input == () { + projectedValue(()) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class OptionalDataSource { + public struct Container { + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Output)? + public init(action: ((Input) -> Output)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Output)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures.OptionalDataSource.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.OptionalDataSource.Container + @inlinable public var projectedValue: ((Input) -> Output)? { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue?(input) + } + @inlinable public func callAsFunction() -> Output? where Input == () { + projectedValue?(()) + } + @objc deinit +} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Equatable {} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Hashable {} diff --git a/.agents/interfaces/tvos/FunctionalConfigurator.swiftinterface b/.agents/interfaces/tvos/FunctionalConfigurator.swiftinterface new file mode 100644 index 0000000..7885765 --- /dev/null +++ b/.agents/interfaces/tvos/FunctionalConfigurator.swiftinterface @@ -0,0 +1,38 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalConfigurator -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Configurator = DeclarativeConfiguration.Configurator +public protocol ___ConfigInitializableProtocol_DEPRECATED : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias ConfigInitializable = FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED { + @available(*, deprecated, message: "Use `.init().configured(using: config) instead\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") + public init(config configurator: Self.Config) +} +public protocol ___CustomConfigurableProtocol_DEPRECATED : DeclarativeConfiguration.CustomConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` or `CustomConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias CustomConfigurable = FunctionalConfigurator.___CustomConfigurableProtocol_DEPRECATED +public protocol ___ConfigInitializableNSObject_DEPRECATED : ObjectiveC.NSObjectProtocol { +} +@available(*, deprecated, message: "Use CallAsFunctionConfigurableProtocol instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias __ConfigInitializableNSObject = FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED where Self : ObjectiveC.NSObject { + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configuration: (Self.Config) -> Self.Config) + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configurator: Self.Config) +} +extension ObjectiveC.NSObject : FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED { +} diff --git a/.agents/interfaces/tvos/FunctionalKeyPath.swiftinterface b/.agents/interfaces/tvos/FunctionalKeyPath.swiftinterface new file mode 100644 index 0000000..14b5210 --- /dev/null +++ b/.agents/interfaces/tvos/FunctionalKeyPath.swiftinterface @@ -0,0 +1,162 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalKeyPath -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, renamed: "ValuePath", message: "FunctionalKeyPath module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead.") +public typealias FunctionalKeyPath = FunctionalKeyPath.__ValuePath_DEPRECATED +public struct __ValuePath_DEPRECATED { + @usableFromInline + internal let _embed: (Value, Root) -> Root + @usableFromInline + internal let _extract: (Root) -> Value + public init(embed: @escaping (Value, Root) -> Root, extract: @escaping (Root) -> Value) +} +@available(*, deprecated, message: "Consider using KeyPaths or copying sources instead.\nhttps://github.com/capturecontext/swift-keypaths-extensions\ncan help with combining optional keypaths while keeping hashability.\nhttps://github.com/pointfreeco/swift-case-paths can help with\nboth simple optional keypaths and enum case paths (CasePaths).\nValuePaths are likely to be removed in v1.0.0") +public typealias ValuePath = FunctionalKeyPath.__ValuePath_DEPRECATED +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public func embed(_ value: Value, in root: Root) -> Root { + _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: Root) where Root : AnyObject { + _ = _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: inout Root) { + root = embed(value, in: root) + } + @inlinable public func extract(from root: Root) -> Value { + _extract(root) + } + @inlinable public init(_ keyPath: Swift.WritableKeyPath) { + self.init( + embed: { value, root in + var root = root + root[keyPath: keyPath] = value + return root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public static func getonly(_ keyPath: Swift.KeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { _, root in + root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public func unwrapped(withDefaultValue defaultValue: @autoclosure @escaping () -> Wrapped) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + __ValuePath_DEPRECATED( + embed: { value, root in + _embed(value, root) + }, + extract: { + _extract($0) ?? defaultValue() + } + ) + } + @inlinable public static func optional(_ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional() + } + @inlinable public static func optional(unwrapWithRoot: Swift.Bool, _ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional(unwrapWithRoot: unwrapWithRoot) + } + @inlinable public func optional() -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let value else { return root } + return self._embed(value, root) + }, + extract: { root in + return self._extract(root) + } + ) + } + @inlinable public func optional(unwrapWithRoot: Swift.Bool) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let root, let value else { return unwrapWithRoot ? root : nil } + return self._embed(value, root) + }, + extract: { root in + guard let root else { return nil } + return self._extract(root) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { appendedValue, root in + self.embed( + path.embed( + appendedValue, + in: self.extract(from: root) + ), + in: root + ) + }, + extract: { root in + path.extract( + from: self.extract(from: root) + ) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + appending(path: path.optional(unwrapWithRoot: true)) + } +} +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public static func key(_ key: Key) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root == [Key : Element], Value == Element?, Key : Swift.Hashable { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { $0[key] = value } + }, + extract: { $0[key] } + ) + } + @inlinable public static func index(_ index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + root[index] = value + } + }, + extract: { root in + root[index] + } + ) + } + @inlinable public static func index(getonly index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.Collection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { _, root in root }, + extract: { $0[index] } + ) + } + @inlinable public static func index(safe index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element? { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + guard + let value = value, + root.indices.contains(index) + else { return } + root[index] = value + } + }, + extract: { root in + root.indices.contains(index) + ? root[index] + : nil + } + ) + } +} diff --git a/.agents/interfaces/tvos/FunctionalModification.swiftinterface b/.agents/interfaces/tvos/FunctionalModification.swiftinterface new file mode 100644 index 0000000..0287566 --- /dev/null +++ b/.agents/interfaces/tvos/FunctionalModification.swiftinterface @@ -0,0 +1,14 @@ +// 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-tvos13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalModification -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalModification module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +} From 4ac1c94f846bd6aa99dcadfc2c9a5cbc3d56d9b9 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:32 +0200 Subject: [PATCH 3/5] Update watchos Swift interfaces (#16) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../DeclarativeConfiguration.swiftinterface | 176 ++++++++++++ ...eclarativeConfigurationCore.swiftinterface | 253 ++++++++++++++++++ .../watchos/FunctionalBuilder.swiftinterface | 13 + .../watchos/FunctionalClosures.swiftinterface | 236 ++++++++++++++++ .../FunctionalConfigurator.swiftinterface | 38 +++ .../watchos/FunctionalKeyPath.swiftinterface | 162 +++++++++++ .../FunctionalModification.swiftinterface | 14 + 7 files changed, 892 insertions(+) create mode 100644 .agents/interfaces/watchos/DeclarativeConfiguration.swiftinterface create mode 100644 .agents/interfaces/watchos/DeclarativeConfigurationCore.swiftinterface create mode 100644 .agents/interfaces/watchos/FunctionalBuilder.swiftinterface create mode 100644 .agents/interfaces/watchos/FunctionalClosures.swiftinterface create mode 100644 .agents/interfaces/watchos/FunctionalConfigurator.swiftinterface create mode 100644 .agents/interfaces/watchos/FunctionalKeyPath.swiftinterface create mode 100644 .agents/interfaces/watchos/FunctionalModification.swiftinterface diff --git a/.agents/interfaces/watchos/DeclarativeConfiguration.swiftinterface b/.agents/interfaces/watchos/DeclarativeConfiguration.swiftinterface new file mode 100644 index 0000000..8fa7a09 --- /dev/null +++ b/.agents/interfaces/watchos/DeclarativeConfiguration.swiftinterface @@ -0,0 +1,176 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfiguration -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Foundation +@_exported import FunctionalClosures +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@dynamicMemberLookup public struct Builder : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var initialValue: () -> Base + @_hasStorage public var configurator: DeclarativeConfiguration.Configurator { + get + } + @inlinable public var base: Base { + get { initialValue() } + } + @inlinable public init(_ initialValue: @autoclosure @escaping () -> Base) { + self.init( + initialValue: initialValue, + configurator: .empty + ) + } + public init(initialValue: @escaping () -> Base, configurator: DeclarativeConfiguration.Configurator) + @inlinable public func build() -> Base { configurator.configured(base) } + @inlinable public func apply() where Base : AnyObject { _ = build() } + @inlinable public func commit() -> DeclarativeConfiguration.Builder { .init(build()) } + @inlinable public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.combined(with: configurator) + ) + } + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Builder + @inlinable public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.modify(transform) + ) + } +} +public protocol BuilderProvider { +} +extension DeclarativeConfiguration.BuilderProvider { + @inlinable public var builder: DeclarativeConfiguration.Builder { + get { .init(self) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.BuilderProvider { +} +@dynamicMemberLookup public struct Configurator : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var storage: any DeclarativeConfigurationCore.ConfigurationStorage + public init(storage: any DeclarativeConfigurationCore.ConfigurationStorage) + @inlinable public init() { + self.init(storage: DefaultConfigurationStorage()) + } + @inlinable public init(config configuration: (DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator) { + self = configuration(.empty) + } + @inlinable public func configure(_ base: inout Base) { + base = configured(base) + } + public func configure(_ base: Base) where Base : AnyObject + public func configured(_ base: Base) -> Base + public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator + public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator + @inlinable public static var empty: DeclarativeConfiguration.Configurator { + get { + .init(storage: DefaultConfigurationStorage()) + } + } + @inlinable public static func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + empty.modify(transform) + } + @inlinable public static func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + empty.transform(transform) + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } +} +extension DeclarativeConfiguration.Configurator where Base : SwiftMarkerProtocols._OptionalProtocol { + public static var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks>.CallableIfLet { + get + } + public static func ifNil(_ newValue: Base) -> DeclarativeConfiguration.Configurator +} +extension DeclarativeConfigurationCore.AnyConfigurationContainer { + public static func config(_ config: DeclarativeConfiguration.Configurator) -> DeclarativeConfigurationCore.AnyConfigurationContainer +} +public protocol CallAsFunctionConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + @discardableResult + @inlinable public func callAsFunction(config configuration: (Self.Config) -> Self.Config) -> Self { + configuration(.empty).configured(self) + } +} +public protocol CustomConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CustomConfigurableProtocol { + @inlinable public func configured(using configuration: (Self.Config) -> Self.Config) -> Self { + configured(using: configuration(.empty)) + } + @inlinable public func configured(using configurator: Self.Config) -> Self { + configurator.configured(self) + } + @inlinable public mutating func configure(using configuration: (Self.Config) -> Self.Config) { + self = configured(using: configuration(.empty)) + } + @inlinable public mutating func configure(using configurator: Self.Config) { + self = configured(using: configurator) + } +} +extension DeclarativeConfiguration.CustomConfigurableProtocol where Self : AnyObject { + @inlinable public func configure(using configuration: (Self.Config) -> Self.Config) { + configure(using: configuration(.empty)) + } + @inlinable public func configure(using configurator: Self.Config) { + configurator.configure(self) + } +} +public protocol _BaseConfigurableProtocol { +} +extension DeclarativeConfiguration._BaseConfigurableProtocol { + public typealias Config = DeclarativeConfiguration.Configurator +} +extension DeclarativeConfiguration.Builder { + @available(*, deprecated, message: "Use `.combined(with: builder.configurator)` instead.\nThis API will be removed in v1.0.0.") + @inlinable public func combined(with builder: DeclarativeConfiguration.Builder) -> DeclarativeConfiguration.Builder { + combined(with: builder.configurator) + } + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + modify(transform) + } + @available(*, deprecated, message: "Use `modify` and capture arguments explicitly instead.\nThis API is likely to be removed in v1.0.0") + @inlinable public func reinforce(_ args: repeat each Arg, transform: @escaping (inout Base, repeat each Arg) -> Swift.Void) -> DeclarativeConfiguration.Builder { + commit().modify { transform(&$0, repeat each args) } + } +} +extension DeclarativeConfiguration.Configurator { + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + modify(transform) + } + @available(*, deprecated, renamed: "transform", message: "This API will be removed in v1.0.0.") + @inlinable public func appendingConfiguration(_ configuration: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + modify { $0 = configuration($0) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CustomConfigurableProtocol {} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol {} diff --git a/.agents/interfaces/watchos/DeclarativeConfigurationCore.swiftinterface b/.agents/interfaces/watchos/DeclarativeConfigurationCore.swiftinterface new file mode 100644 index 0000000..d33d99e --- /dev/null +++ b/.agents/interfaces/watchos/DeclarativeConfigurationCore.swiftinterface @@ -0,0 +1,253 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfigurationCore -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import IssueReporting +import KeyPathsExtensions +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum ConfigurationBlocks where Container : DeclarativeConfigurationCore.ConfigurationContainer { + @dynamicMemberLookup public struct Callable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Value) -> Value) -> Container + public func modify(_ transform: @escaping (inout Value) -> Swift.Void) -> Container + public func callAsFunction(_ value: Value) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct CallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath.CallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath.CallableIfLet.Value>) + public func peek(_ operation: @escaping (Wrapped) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Wrapped) -> Wrapped) -> Container + public func modify(_ transform: @escaping (inout Wrapped) -> Swift.Void) -> Container + public func callAsFunction(_ newValue: Wrapped) -> Container + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value == Wrapped? { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value == Wrapped? { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath.NonCallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath.NonCallableIfLet.Value>) + public func peek(_ operation: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.Value) -> Swift.Void) -> Container + @available(*, unavailable, message: "Not available for non-writable key path") + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + public func configured(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func callAsFunction(ifLet newValue: Value?) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func callAsFunction(ifLet newValue: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value?) -> Container +} +public protocol ConfigurationContainer { + associatedtype Base +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks +} +extension DeclarativeConfigurationCore.ConfigurationContainer where Self.Base : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ newValue: Self.Base) -> Self +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + .init(container: self, keyPath: keyPath) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + .init(container: self, keyPath: keyPath) + } + } + public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Self.Base == Wrapped? { + get + } + public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Self.Base == Wrapped? { + get + } +} +@dynamicMemberLookup public struct AnyConfigurationContainer : DeclarativeConfigurationCore.ConfigurationContainer { + internal let underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer + public init(_ underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer) +} +public protocol ConfigurationStorage { + associatedtype Base +} +public struct DefaultConfigurationStorage : DeclarativeConfigurationCore.ConfigurationStorage { + internal var items: [any DeclarativeConfigurationCore._ConfigurationItem] + public init() +} +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +} diff --git a/.agents/interfaces/watchos/FunctionalBuilder.swiftinterface b/.agents/interfaces/watchos/FunctionalBuilder.swiftinterface new file mode 100644 index 0000000..2324743 --- /dev/null +++ b/.agents/interfaces/watchos/FunctionalBuilder.swiftinterface @@ -0,0 +1,13 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalBuilder -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Builder = DeclarativeConfiguration.Builder +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias BuilderProvider = DeclarativeConfiguration.BuilderProvider diff --git a/.agents/interfaces/watchos/FunctionalClosures.swiftinterface b/.agents/interfaces/watchos/FunctionalClosures.swiftinterface new file mode 100644 index 0000000..8132d33 --- /dev/null +++ b/.agents/interfaces/watchos/FunctionalClosures.swiftinterface @@ -0,0 +1,236 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalClosures -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum HandlerContainerBehaviour { + case resetting + case preceding + case appending + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: FunctionalClosures.HandlerContainerBehaviour, _ b: FunctionalClosures.HandlerContainerBehaviour) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class _Handler { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((repeat each T) -> Swift.Void)? + public init(action: ((repeat each T) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((repeat each T) -> Swift.Void)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures._Handler.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures._Handler.Container + public var projectedValue: ((repeat each T) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: repeat each T) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +public typealias Handler = FunctionalClosures.Handler1 +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler1 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Swift.Void)? + public init(action: ((Input) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Swift.Void)?) { + self.action = action + } + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/CaptureContext/swift-declarative-configuration/issues/1") + @inlinable public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler1.Container.Behaviour, perform action: ((Input) -> Swift.Void)?) { + switch behaviour { + case .resetting: + self.action = action + case .preceding: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + case .appending: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + } + } + } + public init() + public init(wrappedValue: FunctionalClosures.Handler1.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler1.Container + public var projectedValue: ((Input) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: Input) + public func callAsFunction() where Input == () + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler2 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1) -> Swift.Void)? + public init(action: ((T0, T1) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler2.Container.Behaviour, perform action: ((T0, T1) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler2.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler2.Container + public var projectedValue: ((T0, T1) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler3 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2) -> Swift.Void)? + public init(action: ((T0, T1, T2) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler3.Container.Behaviour, perform action: ((T0, T1, T2) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler3.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler3.Container + public var projectedValue: ((T0, T1, T2) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler4 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler4.Container.Behaviour, perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler4.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler4.Container + public var projectedValue: ((T0, T1, T2, T3) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler5 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3, T4) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler5.Container.Behaviour, perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler5.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler5.Container + public var projectedValue: ((T0, T1, T2, T3, T4) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4) + @objc deinit +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class _DataSource { + public struct Container { + @usableFromInline + internal var action: (repeat each T) -> Output + public init(action: @escaping (repeat each T) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (repeat each T) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures._DataSource.Container) + public var wrappedValue: FunctionalClosures._DataSource.Container + @inlinable public var projectedValue: (repeat each T) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ args: repeat each T) -> Output? { + projectedValue(repeat each args) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class DataSource { + public struct Container { + @usableFromInline + internal var action: (Input) -> Output + public init(action: @escaping (Input) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (Input) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures.DataSource.Container) + public var wrappedValue: FunctionalClosures.DataSource.Container + @inlinable public var projectedValue: (Input) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue(input) + } + @inlinable public func callAsFunction() -> Output where Input == () { + projectedValue(()) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class OptionalDataSource { + public struct Container { + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Output)? + public init(action: ((Input) -> Output)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Output)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures.OptionalDataSource.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.OptionalDataSource.Container + @inlinable public var projectedValue: ((Input) -> Output)? { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue?(input) + } + @inlinable public func callAsFunction() -> Output? where Input == () { + projectedValue?(()) + } + @objc deinit +} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Equatable {} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Hashable {} diff --git a/.agents/interfaces/watchos/FunctionalConfigurator.swiftinterface b/.agents/interfaces/watchos/FunctionalConfigurator.swiftinterface new file mode 100644 index 0000000..03fd726 --- /dev/null +++ b/.agents/interfaces/watchos/FunctionalConfigurator.swiftinterface @@ -0,0 +1,38 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalConfigurator -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Configurator = DeclarativeConfiguration.Configurator +public protocol ___ConfigInitializableProtocol_DEPRECATED : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias ConfigInitializable = FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED { + @available(*, deprecated, message: "Use `.init().configured(using: config) instead\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") + public init(config configurator: Self.Config) +} +public protocol ___CustomConfigurableProtocol_DEPRECATED : DeclarativeConfiguration.CustomConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` or `CustomConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias CustomConfigurable = FunctionalConfigurator.___CustomConfigurableProtocol_DEPRECATED +public protocol ___ConfigInitializableNSObject_DEPRECATED : ObjectiveC.NSObjectProtocol { +} +@available(*, deprecated, message: "Use CallAsFunctionConfigurableProtocol instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias __ConfigInitializableNSObject = FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED where Self : ObjectiveC.NSObject { + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configuration: (Self.Config) -> Self.Config) + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configurator: Self.Config) +} +extension ObjectiveC.NSObject : FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED { +} diff --git a/.agents/interfaces/watchos/FunctionalKeyPath.swiftinterface b/.agents/interfaces/watchos/FunctionalKeyPath.swiftinterface new file mode 100644 index 0000000..6f5db49 --- /dev/null +++ b/.agents/interfaces/watchos/FunctionalKeyPath.swiftinterface @@ -0,0 +1,162 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalKeyPath -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, renamed: "ValuePath", message: "FunctionalKeyPath module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead.") +public typealias FunctionalKeyPath = FunctionalKeyPath.__ValuePath_DEPRECATED +public struct __ValuePath_DEPRECATED { + @usableFromInline + internal let _embed: (Value, Root) -> Root + @usableFromInline + internal let _extract: (Root) -> Value + public init(embed: @escaping (Value, Root) -> Root, extract: @escaping (Root) -> Value) +} +@available(*, deprecated, message: "Consider using KeyPaths or copying sources instead.\nhttps://github.com/capturecontext/swift-keypaths-extensions\ncan help with combining optional keypaths while keeping hashability.\nhttps://github.com/pointfreeco/swift-case-paths can help with\nboth simple optional keypaths and enum case paths (CasePaths).\nValuePaths are likely to be removed in v1.0.0") +public typealias ValuePath = FunctionalKeyPath.__ValuePath_DEPRECATED +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public func embed(_ value: Value, in root: Root) -> Root { + _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: Root) where Root : AnyObject { + _ = _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: inout Root) { + root = embed(value, in: root) + } + @inlinable public func extract(from root: Root) -> Value { + _extract(root) + } + @inlinable public init(_ keyPath: Swift.WritableKeyPath) { + self.init( + embed: { value, root in + var root = root + root[keyPath: keyPath] = value + return root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public static func getonly(_ keyPath: Swift.KeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { _, root in + root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public func unwrapped(withDefaultValue defaultValue: @autoclosure @escaping () -> Wrapped) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + __ValuePath_DEPRECATED( + embed: { value, root in + _embed(value, root) + }, + extract: { + _extract($0) ?? defaultValue() + } + ) + } + @inlinable public static func optional(_ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional() + } + @inlinable public static func optional(unwrapWithRoot: Swift.Bool, _ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional(unwrapWithRoot: unwrapWithRoot) + } + @inlinable public func optional() -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let value else { return root } + return self._embed(value, root) + }, + extract: { root in + return self._extract(root) + } + ) + } + @inlinable public func optional(unwrapWithRoot: Swift.Bool) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let root, let value else { return unwrapWithRoot ? root : nil } + return self._embed(value, root) + }, + extract: { root in + guard let root else { return nil } + return self._extract(root) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { appendedValue, root in + self.embed( + path.embed( + appendedValue, + in: self.extract(from: root) + ), + in: root + ) + }, + extract: { root in + path.extract( + from: self.extract(from: root) + ) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + appending(path: path.optional(unwrapWithRoot: true)) + } +} +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public static func key(_ key: Key) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root == [Key : Element], Value == Element?, Key : Swift.Hashable { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { $0[key] = value } + }, + extract: { $0[key] } + ) + } + @inlinable public static func index(_ index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + root[index] = value + } + }, + extract: { root in + root[index] + } + ) + } + @inlinable public static func index(getonly index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.Collection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { _, root in root }, + extract: { $0[index] } + ) + } + @inlinable public static func index(safe index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element? { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + guard + let value = value, + root.indices.contains(index) + else { return } + root[index] = value + } + }, + extract: { root in + root.indices.contains(index) + ? root[index] + : nil + } + ) + } +} diff --git a/.agents/interfaces/watchos/FunctionalModification.swiftinterface b/.agents/interfaces/watchos/FunctionalModification.swiftinterface new file mode 100644 index 0000000..0143b85 --- /dev/null +++ b/.agents/interfaces/watchos/FunctionalModification.swiftinterface @@ -0,0 +1,14 @@ +// 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-watchos6.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalModification -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalModification module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +} From f08bd43d3b7f613cdf610f882fe39a509bb7d4e9 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:35 +0200 Subject: [PATCH 4/5] Update macos Swift interfaces (#17) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../DeclarativeConfiguration.swiftinterface | 96 +++++----- ...eclarativeConfigurationCore.swiftinterface | 178 +++++++++--------- .../macos/FunctionalBuilder.swiftinterface | 10 +- .../macos/FunctionalClosures.swiftinterface | 124 ++++++------ .../FunctionalConfigurator.swiftinterface | 26 +-- .../macos/FunctionalKeyPath.swiftinterface | 40 ++-- .../FunctionalModification.swiftinterface | 8 +- 7 files changed, 241 insertions(+), 241 deletions(-) diff --git a/.agents/interfaces/macos/DeclarativeConfiguration.swiftinterface b/.agents/interfaces/macos/DeclarativeConfiguration.swiftinterface index f9696dd..8b966ef 100644 --- a/.agents/interfaces/macos/DeclarativeConfiguration.swiftinterface +++ b/.agents/interfaces/macos/DeclarativeConfiguration.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 DeclarativeConfiguration -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfiguration -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 @_exported import DeclarativeConfigurationCore import Foundation @_exported import FunctionalClosures @@ -10,10 +10,10 @@ import SwiftMarkerProtocols import _Concurrency import _StringProcessing import _SwiftConcurrencyShims -@dynamicMemberLookup public struct Builder : DeclarativeConfigurationCore::ConfigurationContainer { +@dynamicMemberLookup public struct Builder : DeclarativeConfigurationCore.ConfigurationContainer { @usableFromInline internal var initialValue: () -> Base - @_hasStorage public var configurator: DeclarativeConfiguration::Configurator { + @_hasStorage public var configurator: DeclarativeConfiguration.Configurator { get } @inlinable public var base: Base { @@ -25,18 +25,18 @@ import _SwiftConcurrencyShims configurator: .empty ) } - public init(initialValue: @escaping () -> Base, configurator: DeclarativeConfiguration::Configurator) + public init(initialValue: @escaping () -> Base, configurator: DeclarativeConfiguration.Configurator) @inlinable public func build() -> Base { configurator.configured(base) } @inlinable public func apply() where Base : AnyObject { _ = build() } - @inlinable public func commit() -> DeclarativeConfiguration::Builder { .init(build()) } - @inlinable public func combined(with configurator: DeclarativeConfiguration::Configurator) -> DeclarativeConfiguration::Builder { + @inlinable public func commit() -> DeclarativeConfiguration.Builder { .init(build()) } + @inlinable public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Builder { Builder( initialValue: initialValue, configurator: configurator.combined(with: configurator) ) } - public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration::Builder - @inlinable public func modify(_ transform: @escaping (inout Base) -> Swift::Void) -> DeclarativeConfiguration::Builder { + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Builder + @inlinable public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { Builder( initialValue: initialValue, configurator: configurator.modify(transform) @@ -45,21 +45,21 @@ import _SwiftConcurrencyShims } public protocol BuilderProvider { } -extension DeclarativeConfiguration::BuilderProvider { - @inlinable public var builder: DeclarativeConfiguration::Builder { +extension DeclarativeConfiguration.BuilderProvider { + @inlinable public var builder: DeclarativeConfiguration.Builder { get { .init(self) } } } -extension ObjectiveC::NSObject : DeclarativeConfiguration::BuilderProvider { +extension ObjectiveC.NSObject : DeclarativeConfiguration.BuilderProvider { } -@dynamicMemberLookup public struct Configurator : DeclarativeConfigurationCore::ConfigurationContainer { +@dynamicMemberLookup public struct Configurator : DeclarativeConfigurationCore.ConfigurationContainer { @usableFromInline - internal var storage: any DeclarativeConfigurationCore::ConfigurationStorage - public init(storage: any DeclarativeConfigurationCore::ConfigurationStorage) + internal var storage: any DeclarativeConfigurationCore.ConfigurationStorage + public init(storage: any DeclarativeConfigurationCore.ConfigurationStorage) @inlinable public init() { self.init(storage: DefaultConfigurationStorage()) } - @inlinable public init(config configuration: (DeclarativeConfiguration::Configurator) -> DeclarativeConfiguration::Configurator) { + @inlinable public init(config configuration: (DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator) { self = configuration(.empty) } @inlinable public func configure(_ base: inout Base) { @@ -67,61 +67,61 @@ extension ObjectiveC::NSObject : DeclarativeConfiguration::BuilderProvider { } public func configure(_ base: Base) where Base : AnyObject public func configured(_ base: Base) -> Base - public func combined(with configurator: DeclarativeConfiguration::Configurator) -> DeclarativeConfiguration::Configurator - public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration::Configurator - public func modify(_ transform: @escaping (inout Base) -> Swift::Void) -> DeclarativeConfiguration::Configurator - @inlinable public static var empty: DeclarativeConfiguration::Configurator { + public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator + public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator + @inlinable public static var empty: DeclarativeConfiguration.Configurator { get { .init(storage: DefaultConfigurationStorage()) } } - @inlinable public static func modify(_ transform: @escaping (inout Base) -> Swift::Void) -> DeclarativeConfiguration::Configurator { + @inlinable public static func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { empty.modify(transform) } - @inlinable public static func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration::Configurator { + @inlinable public static func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { empty.transform(transform) } - @inlinable public static subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks>.DeclarativeConfigurationCore::Callable { + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable { get { empty[dynamicMember: keyPath] } } - @inlinable public static subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks>.DeclarativeConfigurationCore::Callable where Base == Wrapped? { + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable where Base == Wrapped? { get { empty[dynamicMember: keyPath] } } - @inlinable public static subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks>.DeclarativeConfigurationCore::NonCallable { + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable { get { empty[dynamicMember: keyPath] } } - @inlinable public static subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks>.DeclarativeConfigurationCore::NonCallable where Base == Wrapped? { + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable where Base == Wrapped? { get { empty[dynamicMember: keyPath] } } } -extension DeclarativeConfiguration::Configurator where Base : SwiftMarkerProtocols::_OptionalProtocol { - public static var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks>.DeclarativeConfigurationCore::CallableIfLet { +extension DeclarativeConfiguration.Configurator where Base : SwiftMarkerProtocols._OptionalProtocol { + public static var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks>.CallableIfLet { get } - public static func ifNil(_ newValue: Base) -> DeclarativeConfiguration::Configurator + public static func ifNil(_ newValue: Base) -> DeclarativeConfiguration.Configurator } -extension DeclarativeConfigurationCore::AnyConfigurationContainer { - public static func config(_ config: DeclarativeConfiguration::Configurator) -> DeclarativeConfigurationCore::AnyConfigurationContainer +extension DeclarativeConfigurationCore.AnyConfigurationContainer { + public static func config(_ config: DeclarativeConfiguration.Configurator) -> DeclarativeConfigurationCore.AnyConfigurationContainer } -public protocol CallAsFunctionConfigurableProtocol : DeclarativeConfiguration::_BaseConfigurableProtocol { +public protocol CallAsFunctionConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { } -extension DeclarativeConfiguration::CallAsFunctionConfigurableProtocol { +extension DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { @discardableResult @inlinable public func callAsFunction(config configuration: (Self.Config) -> Self.Config) -> Self { configuration(.empty).configured(self) } } -public protocol CustomConfigurableProtocol : DeclarativeConfiguration::_BaseConfigurableProtocol { +public protocol CustomConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { } -extension DeclarativeConfiguration::CustomConfigurableProtocol { +extension DeclarativeConfiguration.CustomConfigurableProtocol { @inlinable public func configured(using configuration: (Self.Config) -> Self.Config) -> Self { configured(using: configuration(.empty)) } @@ -135,7 +135,7 @@ extension DeclarativeConfiguration::CustomConfigurableProtocol { self = configured(using: configurator) } } -extension DeclarativeConfiguration::CustomConfigurableProtocol where Self : AnyObject { +extension DeclarativeConfiguration.CustomConfigurableProtocol where Self : AnyObject { @inlinable public func configure(using configuration: (Self.Config) -> Self.Config) { configure(using: configuration(.empty)) } @@ -145,32 +145,32 @@ extension DeclarativeConfiguration::CustomConfigurableProtocol where Self : AnyO } public protocol _BaseConfigurableProtocol { } -extension DeclarativeConfiguration::_BaseConfigurableProtocol { - public typealias Config = DeclarativeConfiguration::Configurator +extension DeclarativeConfiguration._BaseConfigurableProtocol { + public typealias Config = DeclarativeConfiguration.Configurator } -extension DeclarativeConfiguration::Builder { +extension DeclarativeConfiguration.Builder { @available(*, deprecated, message: "Use `.combined(with: builder.configurator)` instead.\nThis API will be removed in v1.0.0.") - @inlinable public func combined(with builder: DeclarativeConfiguration::Builder) -> DeclarativeConfiguration::Builder { + @inlinable public func combined(with builder: DeclarativeConfiguration.Builder) -> DeclarativeConfiguration.Builder { combined(with: builder.configurator) } @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") - @inlinable public func set(_ transform: @escaping (inout Base) -> Swift::Void) -> DeclarativeConfiguration::Builder { + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { modify(transform) } @available(*, deprecated, message: "Use `modify` and capture arguments explicitly instead.\nThis API is likely to be removed in v1.0.0") - @inlinable public func reinforce(_ args: repeat each Arg, transform: @escaping (inout Base, repeat each Arg) -> Swift::Void) -> DeclarativeConfiguration::Builder { + @inlinable public func reinforce(_ args: repeat each Arg, transform: @escaping (inout Base, repeat each Arg) -> Swift.Void) -> DeclarativeConfiguration.Builder { commit().modify { transform(&$0, repeat each args) } } } -extension DeclarativeConfiguration::Configurator { +extension DeclarativeConfiguration.Configurator { @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") - @inlinable public func set(_ transform: @escaping (inout Base) -> Swift::Void) -> DeclarativeConfiguration::Configurator { + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { modify(transform) } @available(*, deprecated, renamed: "transform", message: "This API will be removed in v1.0.0.") - @inlinable public func appendingConfiguration(_ configuration: @escaping (Base) -> Base) -> DeclarativeConfiguration::Configurator { + @inlinable public func appendingConfiguration(_ configuration: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { modify { $0 = configuration($0) } } } -extension ObjectiveC::NSObject : DeclarativeConfiguration::CustomConfigurableProtocol {} -extension ObjectiveC::NSObject : DeclarativeConfiguration::CallAsFunctionConfigurableProtocol {} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CustomConfigurableProtocol {} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol {} diff --git a/.agents/interfaces/macos/DeclarativeConfigurationCore.swiftinterface b/.agents/interfaces/macos/DeclarativeConfigurationCore.swiftinterface index 2f03426..7372a6f 100644 --- a/.agents/interfaces/macos/DeclarativeConfigurationCore.swiftinterface +++ b/.agents/interfaces/macos/DeclarativeConfigurationCore.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 DeclarativeConfigurationCore -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfigurationCore -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 import Foundation import IssueReporting import KeyPathsExtensions @@ -10,25 +10,25 @@ import SwiftMarkerProtocols import _Concurrency import _StringProcessing import _SwiftConcurrencyShims -public enum ConfigurationBlocks where Container : DeclarativeConfigurationCore::ConfigurationContainer { +public enum ConfigurationBlocks where Container : DeclarativeConfigurationCore.ConfigurationContainer { @dynamicMemberLookup public struct Callable { - public typealias Blocks = DeclarativeConfigurationCore::ConfigurationBlocks - public typealias ScopedContainer = DeclarativeConfigurationCore::AnyConfigurationContainer + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer @usableFromInline internal var container: Container @usableFromInline - internal var keyPath: Swift::WritableKeyPath + internal var keyPath: Swift.WritableKeyPath @usableFromInline - internal init(container: Container, keyPath: Swift::WritableKeyPath) - public func peek(_ operation: @escaping (Value) -> Swift::Void) -> Container + internal init(container: Container, keyPath: Swift.WritableKeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container public func transform(_ transform: @escaping (Value) -> Value) -> Container - public func modify(_ transform: @escaping (inout Value) -> Swift::Void) -> Container + public func modify(_ transform: @escaping (inout Value) -> Swift.Void) -> Container public func callAsFunction(_ value: Value) -> Container - public func scope(_ config: (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable.DeclarativeConfigurationCore::ScopedContainer) -> Container - public func configure(using config: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable.DeclarativeConfigurationCore::ScopedContainer) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container @available(*, deprecated, message: "Use `.ifLet.scope` instead.") - public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable.DeclarativeConfigurationCore::ScopedContainer) -> Container where Value == Wrapped? - @inlinable public subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable { + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { get { Callable( container: self.container, @@ -36,7 +36,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { get { NonCallable( container: self.container, @@ -47,22 +47,22 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur } @dynamicMemberLookup public struct CallableIfLet { public typealias Value = Wrapped? - public typealias Blocks = DeclarativeConfigurationCore::ConfigurationBlocks - public typealias ScopedContainer = DeclarativeConfigurationCore::AnyConfigurationContainer + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer @usableFromInline internal var container: Container @usableFromInline - internal var keyPath: Swift::WritableKeyPath.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::Value> + internal var keyPath: Swift.WritableKeyPath.CallableIfLet.Value> @usableFromInline - internal init(container: Container, keyPath: Swift::WritableKeyPath.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::Value>) - public func peek(_ operation: @escaping (Wrapped) -> Swift::Void) -> Container + internal init(container: Container, keyPath: Swift.WritableKeyPath.CallableIfLet.Value>) + public func peek(_ operation: @escaping (Wrapped) -> Swift.Void) -> Container public func transform(_ transform: @escaping (Wrapped) -> Wrapped) -> Container - public func modify(_ transform: @escaping (inout Wrapped) -> Swift::Void) -> Container + public func modify(_ transform: @escaping (inout Wrapped) -> Swift.Void) -> Container public func callAsFunction(_ newValue: Wrapped) -> Container - public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable - public func scope(_ config: @escaping (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> Container - public func configure(using config: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> Container - @inlinable public subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { get { CallableIfLet( container: self.container, @@ -70,7 +70,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { get { NonCallableIfLet( container: self.container, @@ -80,20 +80,20 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur } } @dynamicMemberLookup public struct NonCallable { - public typealias Blocks = DeclarativeConfigurationCore::ConfigurationBlocks - public typealias ScopedContainer = DeclarativeConfigurationCore::AnyConfigurationContainer + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer @usableFromInline internal var container: Container @usableFromInline - internal var keyPath: Swift::KeyPath + internal var keyPath: Swift.KeyPath @usableFromInline - internal init(container: Container, keyPath: Swift::KeyPath) - public func peek(_ operation: @escaping (Value) -> Swift::Void) -> Container - public func scope(_ config: (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable.DeclarativeConfigurationCore::ScopedContainer) -> Container - public func configure(using config: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable.DeclarativeConfigurationCore::ScopedContainer) -> Container + internal init(container: Container, keyPath: Swift.KeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container @available(*, deprecated, message: "Use `.ifLet.scope` instead.") - public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable.DeclarativeConfigurationCore::ScopedContainer) -> Container where Value == Wrapped? - @inlinable public subscript(dynamicMember keyPath: Swift::ReferenceWritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable { + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { get { Callable( container: self.container, @@ -101,7 +101,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { get { NonCallable( container: self.container, @@ -109,7 +109,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::ReferenceWritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable where Value == Wrapped? { + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value == Wrapped? { get { Callable( container: self.container, @@ -117,7 +117,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable where Value == Wrapped? { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value == Wrapped? { get { NonCallable( container: self.container, @@ -128,20 +128,20 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur } @dynamicMemberLookup public struct NonCallableIfLet { public typealias Value = Wrapped? - public typealias Blocks = DeclarativeConfigurationCore::ConfigurationBlocks - public typealias ScopedContainer = DeclarativeConfigurationCore::AnyConfigurationContainer + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer @usableFromInline internal var container: Container @usableFromInline - internal var keyPath: Swift::KeyPath.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::Value> + internal var keyPath: Swift.KeyPath.NonCallableIfLet.Value> @usableFromInline - internal init(container: Container, keyPath: Swift::KeyPath.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::Value>) - public func peek(_ operation: @escaping (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::Value) -> Swift::Void) -> Container + internal init(container: Container, keyPath: Swift.KeyPath.NonCallableIfLet.Value>) + public func peek(_ operation: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.Value) -> Swift.Void) -> Container @available(*, unavailable, message: "Not available for non-writable key path") - public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable - public func scope(_ config: @escaping (DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> Container - public func configured(using config: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet.DeclarativeConfigurationCore::ScopedContainer) -> Container - @inlinable public subscript(dynamicMember keyPath: Swift::ReferenceWritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + public func configured(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { get { CallableIfLet( container: self.container, @@ -149,7 +149,7 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur ) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { get { NonCallableIfLet( container: self.container, @@ -159,94 +159,94 @@ public enum ConfigurationBlocks where Container : DeclarativeConfigur } } } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable where Value : SwiftMarkerProtocols::_OptionalProtocol { - public var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { get } public func ifNil(_ value: Value) -> Container } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable where Value : SwiftMarkerProtocols::_OptionalProtocol { - public var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet { +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { get } } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet where Wrapped : SwiftMarkerProtocols::_OptionalProtocol { - public var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { get } - public func ifNil(_ value: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::Value) -> Container + public func ifNil(_ value: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value) -> Container } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet where Wrapped : SwiftMarkerProtocols::_OptionalProtocol { - public var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet { +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { get } } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable { - public func ifLet(_ keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet - public func ifLet(_ keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable { - public func ifLet(_ keyPath: Swift::ReferenceWritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet - public func ifLet(_ keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { - public func ifLet(_ keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet - public func ifLet(_ keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet { - public func ifLet(_ keyPath: Swift::ReferenceWritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet - public func ifLet(_ keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable { +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { public func callAsFunction(ifLet newValue: Value?) -> Container } -extension DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { - public func callAsFunction(ifLet newValue: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet.DeclarativeConfigurationCore::Value?) -> Container +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func callAsFunction(ifLet newValue: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value?) -> Container } public protocol ConfigurationContainer { associatedtype Base } -extension DeclarativeConfigurationCore::ConfigurationContainer { - public typealias Blocks = DeclarativeConfigurationCore::ConfigurationBlocks +extension DeclarativeConfigurationCore.ConfigurationContainer { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks } -extension DeclarativeConfigurationCore::ConfigurationContainer where Self.Base : SwiftMarkerProtocols::_OptionalProtocol { - public var ifLet: DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet { +extension DeclarativeConfigurationCore.ConfigurationContainer where Self.Base : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { get } public func ifNil(_ newValue: Self.Base) -> Self } -extension DeclarativeConfigurationCore::ConfigurationContainer { - public func ifLet(_ keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::CallableIfLet - public func ifLet(_ keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallableIfLet - @inlinable public subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable { +extension DeclarativeConfigurationCore.ConfigurationContainer { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { get { .init(container: self, keyPath: keyPath) } } - @inlinable public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable { + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { get { .init(container: self, keyPath: keyPath) } } - public subscript(dynamicMember keyPath: Swift::WritableKeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::Callable where Self.Base == Wrapped? { + public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Self.Base == Wrapped? { get } - public subscript(dynamicMember keyPath: Swift::KeyPath) -> DeclarativeConfigurationCore::ConfigurationBlocks.DeclarativeConfigurationCore::NonCallable where Self.Base == Wrapped? { + public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Self.Base == Wrapped? { get } } -@dynamicMemberLookup public struct AnyConfigurationContainer : DeclarativeConfigurationCore::ConfigurationContainer { - internal let underlyingContainer: any DeclarativeConfigurationCore::ConfigurationContainer - public init(_ underlyingContainer: any DeclarativeConfigurationCore::ConfigurationContainer) +@dynamicMemberLookup public struct AnyConfigurationContainer : DeclarativeConfigurationCore.ConfigurationContainer { + internal let underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer + public init(_ underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer) } public protocol ConfigurationStorage { associatedtype Base } -public struct DefaultConfigurationStorage : DeclarativeConfigurationCore::ConfigurationStorage { - internal var items: [any DeclarativeConfigurationCore::_ConfigurationItem] +public struct DefaultConfigurationStorage : DeclarativeConfigurationCore.ConfigurationStorage { + internal var items: [any DeclarativeConfigurationCore._ConfigurationItem] public init() } -@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift::Void) -> Value { +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { var _value = value transform(&_value) return _value diff --git a/.agents/interfaces/macos/FunctionalBuilder.swiftinterface b/.agents/interfaces/macos/FunctionalBuilder.swiftinterface index 64b9cb2..4b666f9 100644 --- a/.agents/interfaces/macos/FunctionalBuilder.swiftinterface +++ b/.agents/interfaces/macos/FunctionalBuilder.swiftinterface @@ -1,13 +1,13 @@ // 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 FunctionalBuilder -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name FunctionalBuilder -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 @_exported import DeclarativeConfiguration import Swift import _Concurrency import _StringProcessing import _SwiftConcurrencyShims @available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias Builder = DeclarativeConfiguration::Builder +public typealias Builder = DeclarativeConfiguration.Builder @available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias BuilderProvider = DeclarativeConfiguration::BuilderProvider +public typealias BuilderProvider = DeclarativeConfiguration.BuilderProvider diff --git a/.agents/interfaces/macos/FunctionalClosures.swiftinterface b/.agents/interfaces/macos/FunctionalClosures.swiftinterface index 8ec4c12..e942f86 100644 --- a/.agents/interfaces/macos/FunctionalClosures.swiftinterface +++ b/.agents/interfaces/macos/FunctionalClosures.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 FunctionalClosures -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name FunctionalClosures -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 import Swift import _Concurrency import _StringProcessing @@ -10,9 +10,9 @@ public enum HandlerContainerBehaviour { case resetting case preceding case appending - @_semantics("derived_enum_equals") @_implements(Swift::Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: FunctionalClosures::HandlerContainerBehaviour, _ b: FunctionalClosures::HandlerContainerBehaviour) -> 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: FunctionalClosures.HandlerContainerBehaviour, _ b: FunctionalClosures.HandlerContainerBehaviour) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { get } } @@ -20,18 +20,18 @@ public enum HandlerContainerBehaviour { @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class _Handler { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour @usableFromInline - @_hasInitialValue internal var action: ((repeat each T) -> Swift::Void)? - public init(action: ((repeat each T) -> Swift::Void)?) - @inlinable public mutating func callAsFunction(perform action: ((repeat each T) -> Swift::Void)?) { + @_hasInitialValue internal var action: ((repeat each T) -> Swift.Void)? + public init(action: ((repeat each T) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((repeat each T) -> Swift.Void)?) { self.action = action } } public init() - public init(wrappedValue: FunctionalClosures::_Handler.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::_Handler.FunctionalClosures::Container - public var projectedValue: ((repeat each T) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures._Handler.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures._Handler.Container + public var projectedValue: ((repeat each T) -> Swift.Void)? { get set } @@ -39,19 +39,19 @@ public enum HandlerContainerBehaviour { @objc deinit } @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") -public typealias Handler = FunctionalClosures::Handler1 +public typealias Handler = FunctionalClosures.Handler1 @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class Handler1 { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour @usableFromInline - @_hasInitialValue internal var action: ((Input) -> Swift::Void)? - public init(action: ((Input) -> Swift::Void)?) - @inlinable public mutating func callAsFunction(perform action: ((Input) -> Swift::Void)?) { + @_hasInitialValue internal var action: ((Input) -> Swift.Void)? + public init(action: ((Input) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Swift.Void)?) { self.action = action } @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/CaptureContext/swift-declarative-configuration/issues/1") - @inlinable public mutating func callAsFunction(_ behaviour: FunctionalClosures::Handler1.FunctionalClosures::Container.FunctionalClosures::Behaviour, perform action: ((Input) -> Swift::Void)?) { + @inlinable public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler1.Container.Behaviour, perform action: ((Input) -> Swift.Void)?) { switch behaviour { case .resetting: self.action = action @@ -71,9 +71,9 @@ public typealias Handler = FunctionalClosures::Handler1 } } public init() - public init(wrappedValue: FunctionalClosures::Handler1.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::Handler1.FunctionalClosures::Container - public var projectedValue: ((Input) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures.Handler1.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler1.Container + public var projectedValue: ((Input) -> Swift.Void)? { get set } @@ -84,17 +84,17 @@ public typealias Handler = FunctionalClosures::Handler1 @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class Handler2 { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour - @_hasInitialValue internal var action: ((T0, T1) -> Swift::Void)? - public init(action: ((T0, T1) -> Swift::Void)?) - public mutating func callAsFunction(perform action: ((T0, T1) -> Swift::Void)?) + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1) -> Swift.Void)? + public init(action: ((T0, T1) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1) -> Swift.Void)?) @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") - public mutating func callAsFunction(_ behaviour: FunctionalClosures::Handler2.FunctionalClosures::Container.FunctionalClosures::Behaviour, perform action: ((T0, T1) -> Swift::Void)?) + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler2.Container.Behaviour, perform action: ((T0, T1) -> Swift.Void)?) } public init() - public init(wrappedValue: FunctionalClosures::Handler2.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::Handler2.FunctionalClosures::Container - public var projectedValue: ((T0, T1) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures.Handler2.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler2.Container + public var projectedValue: ((T0, T1) -> Swift.Void)? { get set } @@ -104,17 +104,17 @@ public typealias Handler = FunctionalClosures::Handler1 @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class Handler3 { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour - @_hasInitialValue internal var action: ((T0, T1, T2) -> Swift::Void)? - public init(action: ((T0, T1, T2) -> Swift::Void)?) - public mutating func callAsFunction(perform action: ((T0, T1, T2) -> Swift::Void)?) + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2) -> Swift.Void)? + public init(action: ((T0, T1, T2) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2) -> Swift.Void)?) @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") - public mutating func callAsFunction(_ behaviour: FunctionalClosures::Handler3.FunctionalClosures::Container.FunctionalClosures::Behaviour, perform action: ((T0, T1, T2) -> Swift::Void)?) + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler3.Container.Behaviour, perform action: ((T0, T1, T2) -> Swift.Void)?) } public init() - public init(wrappedValue: FunctionalClosures::Handler3.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::Handler3.FunctionalClosures::Container - public var projectedValue: ((T0, T1, T2) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures.Handler3.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler3.Container + public var projectedValue: ((T0, T1, T2) -> Swift.Void)? { get set } @@ -124,17 +124,17 @@ public typealias Handler = FunctionalClosures::Handler1 @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class Handler4 { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour - @_hasInitialValue internal var action: ((T0, T1, T2, T3) -> Swift::Void)? - public init(action: ((T0, T1, T2, T3) -> Swift::Void)?) - public mutating func callAsFunction(perform action: ((T0, T1, T2, T3) -> Swift::Void)?) + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3) -> Swift.Void)?) @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") - public mutating func callAsFunction(_ behaviour: FunctionalClosures::Handler4.FunctionalClosures::Container.FunctionalClosures::Behaviour, perform action: ((T0, T1, T2, T3) -> Swift::Void)?) + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler4.Container.Behaviour, perform action: ((T0, T1, T2, T3) -> Swift.Void)?) } public init() - public init(wrappedValue: FunctionalClosures::Handler4.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::Handler4.FunctionalClosures::Container - public var projectedValue: ((T0, T1, T2, T3) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures.Handler4.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler4.Container + public var projectedValue: ((T0, T1, T2, T3) -> Swift.Void)? { get set } @@ -144,17 +144,17 @@ public typealias Handler = FunctionalClosures::Handler1 @available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") @propertyWrapper public class Handler5 { public struct Container { - public typealias Behaviour = FunctionalClosures::HandlerContainerBehaviour - @_hasInitialValue internal var action: ((T0, T1, T2, T3, T4) -> Swift::Void)? - public init(action: ((T0, T1, T2, T3, T4) -> Swift::Void)?) - public mutating func callAsFunction(perform action: ((T0, T1, T2, T3, T4) -> Swift::Void)?) + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3, T4) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") - public mutating func callAsFunction(_ behaviour: FunctionalClosures::Handler5.FunctionalClosures::Container.FunctionalClosures::Behaviour, perform action: ((T0, T1, T2, T3, T4) -> Swift::Void)?) + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler5.Container.Behaviour, perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) } public init() - public init(wrappedValue: FunctionalClosures::Handler5.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::Handler5.FunctionalClosures::Container - public var projectedValue: ((T0, T1, T2, T3, T4) -> Swift::Void)? { + public init(wrappedValue: FunctionalClosures.Handler5.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler5.Container + public var projectedValue: ((T0, T1, T2, T3, T4) -> Swift.Void)? { get set } @@ -172,8 +172,8 @@ public typealias Handler = FunctionalClosures::Handler1 self.action = action } } - public init(wrappedValue: FunctionalClosures::_DataSource.FunctionalClosures::Container) - public var wrappedValue: FunctionalClosures::_DataSource.FunctionalClosures::Container + public init(wrappedValue: FunctionalClosures._DataSource.Container) + public var wrappedValue: FunctionalClosures._DataSource.Container @inlinable public var projectedValue: (repeat each T) -> Output { get { wrappedValue.action } set { wrappedValue.action = newValue } @@ -193,8 +193,8 @@ public typealias Handler = FunctionalClosures::Handler1 self.action = action } } - public init(wrappedValue: FunctionalClosures::DataSource.FunctionalClosures::Container) - public var wrappedValue: FunctionalClosures::DataSource.FunctionalClosures::Container + public init(wrappedValue: FunctionalClosures.DataSource.Container) + public var wrappedValue: FunctionalClosures.DataSource.Container @inlinable public var projectedValue: (Input) -> Output { get { wrappedValue.action } set { wrappedValue.action = newValue } @@ -218,8 +218,8 @@ public typealias Handler = FunctionalClosures::Handler1 } } public init() - public init(wrappedValue: FunctionalClosures::OptionalDataSource.FunctionalClosures::Container) - @_hasInitialValue public var wrappedValue: FunctionalClosures::OptionalDataSource.FunctionalClosures::Container + public init(wrappedValue: FunctionalClosures.OptionalDataSource.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.OptionalDataSource.Container @inlinable public var projectedValue: ((Input) -> Output)? { get { wrappedValue.action } set { wrappedValue.action = newValue } @@ -232,5 +232,5 @@ public typealias Handler = FunctionalClosures::Handler1 } @objc deinit } -extension FunctionalClosures::HandlerContainerBehaviour : Swift::Equatable {} -extension FunctionalClosures::HandlerContainerBehaviour : Swift::Hashable {} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Equatable {} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Hashable {} diff --git a/.agents/interfaces/macos/FunctionalConfigurator.swiftinterface b/.agents/interfaces/macos/FunctionalConfigurator.swiftinterface index 53f3452..0f62c45 100644 --- a/.agents/interfaces/macos/FunctionalConfigurator.swiftinterface +++ b/.agents/interfaces/macos/FunctionalConfigurator.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 FunctionalConfigurator -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name FunctionalConfigurator -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 @_exported import DeclarativeConfiguration import Foundation import Swift @@ -9,30 +9,30 @@ import _Concurrency import _StringProcessing import _SwiftConcurrencyShims @available(*, deprecated, message: "FunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias Configurator = DeclarativeConfiguration::Configurator -public protocol ___ConfigInitializableProtocol_DEPRECATED : DeclarativeConfiguration::CallAsFunctionConfigurableProtocol { +public typealias Configurator = DeclarativeConfiguration.Configurator +public protocol ___ConfigInitializableProtocol_DEPRECATED : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { init() } @available(*, deprecated, message: "Use `DefaultConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias ConfigInitializable = FunctionalConfigurator::___ConfigInitializableProtocol_DEPRECATED -extension FunctionalConfigurator::___ConfigInitializableProtocol_DEPRECATED { +public typealias ConfigInitializable = FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED { @available(*, deprecated, message: "Use `.init().configured(using: config) instead\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") public init(config configurator: Self.Config) } -public protocol ___CustomConfigurableProtocol_DEPRECATED : DeclarativeConfiguration::CustomConfigurableProtocol { +public protocol ___CustomConfigurableProtocol_DEPRECATED : DeclarativeConfiguration.CustomConfigurableProtocol { init() } @available(*, deprecated, message: "Use `DefaultConfigurableProtocol` or `CustomConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias CustomConfigurable = FunctionalConfigurator::___CustomConfigurableProtocol_DEPRECATED -public protocol ___ConfigInitializableNSObject_DEPRECATED : ObjectiveC::NSObjectProtocol { +public typealias CustomConfigurable = FunctionalConfigurator.___CustomConfigurableProtocol_DEPRECATED +public protocol ___ConfigInitializableNSObject_DEPRECATED : ObjectiveC.NSObjectProtocol { } @available(*, deprecated, message: "Use CallAsFunctionConfigurableProtocol instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -public typealias __ConfigInitializableNSObject = FunctionalConfigurator::___ConfigInitializableNSObject_DEPRECATED -extension FunctionalConfigurator::___ConfigInitializableNSObject_DEPRECATED where Self : ObjectiveC::NSObject { +public typealias __ConfigInitializableNSObject = FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED where Self : ObjectiveC.NSObject { @available(*, deprecated, renamed: "init(unsafeConfig:)") @_disfavoredOverload public init(config configuration: (Self.Config) -> Self.Config) @available(*, deprecated, renamed: "init(unsafeConfig:)") @_disfavoredOverload public init(config configurator: Self.Config) } -extension ObjectiveC::NSObject : FunctionalConfigurator::___ConfigInitializableNSObject_DEPRECATED { +extension ObjectiveC.NSObject : FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED { } diff --git a/.agents/interfaces/macos/FunctionalKeyPath.swiftinterface b/.agents/interfaces/macos/FunctionalKeyPath.swiftinterface index 1fa9abf..d9eeef7 100644 --- a/.agents/interfaces/macos/FunctionalKeyPath.swiftinterface +++ b/.agents/interfaces/macos/FunctionalKeyPath.swiftinterface @@ -1,14 +1,14 @@ // 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 FunctionalKeyPath -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name FunctionalKeyPath -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 @_exported import DeclarativeConfigurationCore import Swift import _Concurrency import _StringProcessing import _SwiftConcurrencyShims @available(*, deprecated, renamed: "ValuePath", message: "FunctionalKeyPath module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead.") -public typealias FunctionalKeyPath = FunctionalKeyPath::__ValuePath_DEPRECATED +public typealias FunctionalKeyPath = FunctionalKeyPath.__ValuePath_DEPRECATED public struct __ValuePath_DEPRECATED { @usableFromInline internal let _embed: (Value, Root) -> Root @@ -17,8 +17,8 @@ public struct __ValuePath_DEPRECATED { public init(embed: @escaping (Value, Root) -> Root, extract: @escaping (Root) -> Value) } @available(*, deprecated, message: "Consider using KeyPaths or copying sources instead.\nhttps://github.com/capturecontext/swift-keypaths-extensions\ncan help with combining optional keypaths while keeping hashability.\nhttps://github.com/pointfreeco/swift-case-paths can help with\nboth simple optional keypaths and enum case paths (CasePaths).\nValuePaths are likely to be removed in v1.0.0") -public typealias ValuePath = FunctionalKeyPath::__ValuePath_DEPRECATED -extension FunctionalKeyPath::__ValuePath_DEPRECATED { +public typealias ValuePath = FunctionalKeyPath.__ValuePath_DEPRECATED +extension FunctionalKeyPath.__ValuePath_DEPRECATED { @inlinable public func embed(_ value: Value, in root: Root) -> Root { _embed(value, root) } @@ -31,7 +31,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { @inlinable public func extract(from root: Root) -> Value { _extract(root) } - @inlinable public init(_ keyPath: Swift::WritableKeyPath) { + @inlinable public init(_ keyPath: Swift.WritableKeyPath) { self.init( embed: { value, root in var root = root @@ -43,7 +43,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public static func getonly(_ keyPath: Swift::KeyPath) -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public static func getonly(_ keyPath: Swift.KeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED( embed: { _, root in root @@ -53,7 +53,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public func unwrapped(withDefaultValue defaultValue: @autoclosure @escaping () -> Wrapped) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Value == Wrapped? { + @inlinable public func unwrapped(withDefaultValue defaultValue: @autoclosure @escaping () -> Wrapped) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { __ValuePath_DEPRECATED( embed: { value, root in _embed(value, root) @@ -63,13 +63,13 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public static func optional(_ keyPath: Swift::WritableKeyPath) -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public static func optional(_ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED(keyPath).optional() } - @inlinable public static func optional(unwrapWithRoot: Swift::Bool, _ keyPath: Swift::WritableKeyPath) -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public static func optional(unwrapWithRoot: Swift.Bool, _ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED(keyPath).optional(unwrapWithRoot: unwrapWithRoot) } - @inlinable public func optional() -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public func optional() -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED( embed: { value, root in guard let value else { return root } @@ -80,7 +80,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public func optional(unwrapWithRoot: Swift::Bool) -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public func optional(unwrapWithRoot: Swift.Bool) -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED( embed: { value, root in guard let root, let value else { return unwrapWithRoot ? root : nil } @@ -92,7 +92,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public func appending(path: FunctionalKeyPath::__ValuePath_DEPRECATED) -> FunctionalKeyPath::__ValuePath_DEPRECATED { + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED { __ValuePath_DEPRECATED( embed: { appendedValue, root in self.embed( @@ -110,12 +110,12 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public func appending(path: FunctionalKeyPath::__ValuePath_DEPRECATED) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Value == Wrapped? { + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { appending(path: path.optional(unwrapWithRoot: true)) } } -extension FunctionalKeyPath::__ValuePath_DEPRECATED { - @inlinable public static func key(_ key: Key) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Root == [Key : Element], Value == Element?, Key : Swift::Hashable { +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public static func key(_ key: Key) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root == [Key : Element], Value == Element?, Key : Swift.Hashable { __ValuePath_DEPRECATED( embed: { value, root in reduce(root) { $0[key] = value } @@ -123,7 +123,7 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { extract: { $0[key] } ) } - @inlinable public static func index(_ index: Root.Index) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Root : Swift::MutableCollection, Value == Root.Element { + @inlinable public static func index(_ index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element { __ValuePath_DEPRECATED( embed: { value, root in reduce(root) { root in @@ -135,13 +135,13 @@ extension FunctionalKeyPath::__ValuePath_DEPRECATED { } ) } - @inlinable public static func index(getonly index: Root.Index) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Root : Swift::Collection, Value == Root.Element { + @inlinable public static func index(getonly index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.Collection, Value == Root.Element { __ValuePath_DEPRECATED( embed: { _, root in root }, extract: { $0[index] } ) } - @inlinable public static func index(safe index: Root.Index) -> FunctionalKeyPath::__ValuePath_DEPRECATED where Root : Swift::MutableCollection, Value == Root.Element? { + @inlinable public static func index(safe index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element? { __ValuePath_DEPRECATED( embed: { value, root in reduce(root) { root in diff --git a/.agents/interfaces/macos/FunctionalModification.swiftinterface b/.agents/interfaces/macos/FunctionalModification.swiftinterface index 6feb02c..3aeaf22 100644 --- a/.agents/interfaces/macos/FunctionalModification.swiftinterface +++ b/.agents/interfaces/macos/FunctionalModification.swiftinterface @@ -1,13 +1,13 @@ // 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 FunctionalModification -package-name swift_declarative_configuration -// 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.15 -enable-objc-interop -swift-version 6 -O -module-name FunctionalModification -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 import Swift import _Concurrency import _StringProcessing import _SwiftConcurrencyShims @available(*, deprecated, message: "FunctionalModification module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") -@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift::Void) -> Value { +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { var _value = value transform(&_value) return _value From 76afec63ddcdf22a7271b4857bbc8b0daddaead9 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:40 +0200 Subject: [PATCH 5/5] Update ios Swift interfaces (#18) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../DeclarativeConfiguration.swiftinterface | 176 ++++++++++++ ...eclarativeConfigurationCore.swiftinterface | 253 ++++++++++++++++++ .../ios/FunctionalBuilder.swiftinterface | 13 + .../ios/FunctionalClosures.swiftinterface | 236 ++++++++++++++++ .../ios/FunctionalConfigurator.swiftinterface | 38 +++ .../ios/FunctionalKeyPath.swiftinterface | 162 +++++++++++ .../ios/FunctionalModification.swiftinterface | 14 + 7 files changed, 892 insertions(+) create mode 100644 .agents/interfaces/ios/DeclarativeConfiguration.swiftinterface create mode 100644 .agents/interfaces/ios/DeclarativeConfigurationCore.swiftinterface create mode 100644 .agents/interfaces/ios/FunctionalBuilder.swiftinterface create mode 100644 .agents/interfaces/ios/FunctionalClosures.swiftinterface create mode 100644 .agents/interfaces/ios/FunctionalConfigurator.swiftinterface create mode 100644 .agents/interfaces/ios/FunctionalKeyPath.swiftinterface create mode 100644 .agents/interfaces/ios/FunctionalModification.swiftinterface diff --git a/.agents/interfaces/ios/DeclarativeConfiguration.swiftinterface b/.agents/interfaces/ios/DeclarativeConfiguration.swiftinterface new file mode 100644 index 0000000..209464f --- /dev/null +++ b/.agents/interfaces/ios/DeclarativeConfiguration.swiftinterface @@ -0,0 +1,176 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfiguration -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Foundation +@_exported import FunctionalClosures +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@dynamicMemberLookup public struct Builder : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var initialValue: () -> Base + @_hasStorage public var configurator: DeclarativeConfiguration.Configurator { + get + } + @inlinable public var base: Base { + get { initialValue() } + } + @inlinable public init(_ initialValue: @autoclosure @escaping () -> Base) { + self.init( + initialValue: initialValue, + configurator: .empty + ) + } + public init(initialValue: @escaping () -> Base, configurator: DeclarativeConfiguration.Configurator) + @inlinable public func build() -> Base { configurator.configured(base) } + @inlinable public func apply() where Base : AnyObject { _ = build() } + @inlinable public func commit() -> DeclarativeConfiguration.Builder { .init(build()) } + @inlinable public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.combined(with: configurator) + ) + } + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Builder + @inlinable public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + Builder( + initialValue: initialValue, + configurator: configurator.modify(transform) + ) + } +} +public protocol BuilderProvider { +} +extension DeclarativeConfiguration.BuilderProvider { + @inlinable public var builder: DeclarativeConfiguration.Builder { + get { .init(self) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.BuilderProvider { +} +@dynamicMemberLookup public struct Configurator : DeclarativeConfigurationCore.ConfigurationContainer { + @usableFromInline + internal var storage: any DeclarativeConfigurationCore.ConfigurationStorage + public init(storage: any DeclarativeConfigurationCore.ConfigurationStorage) + @inlinable public init() { + self.init(storage: DefaultConfigurationStorage()) + } + @inlinable public init(config configuration: (DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator) { + self = configuration(.empty) + } + @inlinable public func configure(_ base: inout Base) { + base = configured(base) + } + public func configure(_ base: Base) where Base : AnyObject + public func configured(_ base: Base) -> Base + public func combined(with configurator: DeclarativeConfiguration.Configurator) -> DeclarativeConfiguration.Configurator + public func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator + public func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator + @inlinable public static var empty: DeclarativeConfiguration.Configurator { + get { + .init(storage: DefaultConfigurationStorage()) + } + } + @inlinable public static func modify(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + empty.modify(transform) + } + @inlinable public static func transform(_ transform: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + empty.transform(transform) + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.Callable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable { + get { + empty[dynamicMember: keyPath] + } + } + @inlinable public static subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks>.NonCallable where Base == Wrapped? { + get { + empty[dynamicMember: keyPath] + } + } +} +extension DeclarativeConfiguration.Configurator where Base : SwiftMarkerProtocols._OptionalProtocol { + public static var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks>.CallableIfLet { + get + } + public static func ifNil(_ newValue: Base) -> DeclarativeConfiguration.Configurator +} +extension DeclarativeConfigurationCore.AnyConfigurationContainer { + public static func config(_ config: DeclarativeConfiguration.Configurator) -> DeclarativeConfigurationCore.AnyConfigurationContainer +} +public protocol CallAsFunctionConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + @discardableResult + @inlinable public func callAsFunction(config configuration: (Self.Config) -> Self.Config) -> Self { + configuration(.empty).configured(self) + } +} +public protocol CustomConfigurableProtocol : DeclarativeConfiguration._BaseConfigurableProtocol { +} +extension DeclarativeConfiguration.CustomConfigurableProtocol { + @inlinable public func configured(using configuration: (Self.Config) -> Self.Config) -> Self { + configured(using: configuration(.empty)) + } + @inlinable public func configured(using configurator: Self.Config) -> Self { + configurator.configured(self) + } + @inlinable public mutating func configure(using configuration: (Self.Config) -> Self.Config) { + self = configured(using: configuration(.empty)) + } + @inlinable public mutating func configure(using configurator: Self.Config) { + self = configured(using: configurator) + } +} +extension DeclarativeConfiguration.CustomConfigurableProtocol where Self : AnyObject { + @inlinable public func configure(using configuration: (Self.Config) -> Self.Config) { + configure(using: configuration(.empty)) + } + @inlinable public func configure(using configurator: Self.Config) { + configurator.configure(self) + } +} +public protocol _BaseConfigurableProtocol { +} +extension DeclarativeConfiguration._BaseConfigurableProtocol { + public typealias Config = DeclarativeConfiguration.Configurator +} +extension DeclarativeConfiguration.Builder { + @available(*, deprecated, message: "Use `.combined(with: builder.configurator)` instead.\nThis API will be removed in v1.0.0.") + @inlinable public func combined(with builder: DeclarativeConfiguration.Builder) -> DeclarativeConfiguration.Builder { + combined(with: builder.configurator) + } + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Builder { + modify(transform) + } + @available(*, deprecated, message: "Use `modify` and capture arguments explicitly instead.\nThis API is likely to be removed in v1.0.0") + @inlinable public func reinforce(_ args: repeat each Arg, transform: @escaping (inout Base, repeat each Arg) -> Swift.Void) -> DeclarativeConfiguration.Builder { + commit().modify { transform(&$0, repeat each args) } + } +} +extension DeclarativeConfiguration.Configurator { + @available(*, deprecated, renamed: "modify", message: "This API will be removed in v1.0.0.") + @inlinable public func set(_ transform: @escaping (inout Base) -> Swift.Void) -> DeclarativeConfiguration.Configurator { + modify(transform) + } + @available(*, deprecated, renamed: "transform", message: "This API will be removed in v1.0.0.") + @inlinable public func appendingConfiguration(_ configuration: @escaping (Base) -> Base) -> DeclarativeConfiguration.Configurator { + modify { $0 = configuration($0) } + } +} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CustomConfigurableProtocol {} +extension ObjectiveC.NSObject : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol {} diff --git a/.agents/interfaces/ios/DeclarativeConfigurationCore.swiftinterface b/.agents/interfaces/ios/DeclarativeConfigurationCore.swiftinterface new file mode 100644 index 0000000..4ef2a15 --- /dev/null +++ b/.agents/interfaces/ios/DeclarativeConfigurationCore.swiftinterface @@ -0,0 +1,253 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name DeclarativeConfigurationCore -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Foundation +import IssueReporting +import KeyPathsExtensions +import Swift +import SwiftMarkerProtocols +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum ConfigurationBlocks where Container : DeclarativeConfigurationCore.ConfigurationContainer { + @dynamicMemberLookup public struct Callable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Value) -> Value) -> Container + public func modify(_ transform: @escaping (inout Value) -> Swift.Void) -> Container + public func callAsFunction(_ value: Value) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct CallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.WritableKeyPath.CallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.WritableKeyPath.CallableIfLet.Value>) + public func peek(_ operation: @escaping (Wrapped) -> Swift.Void) -> Container + public func transform(_ transform: @escaping (Wrapped) -> Wrapped) -> Container + public func modify(_ transform: @escaping (inout Wrapped) -> Swift.Void) -> Container + public func callAsFunction(_ newValue: Wrapped) -> Container + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallable { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath) + public func peek(_ operation: @escaping (Value) -> Swift.Void) -> Container + public func scope(_ config: (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + public func configure(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container + @available(*, deprecated, message: "Use `.ifLet.scope` instead.") + public func ifLetScope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable.ScopedContainer) -> Container where Value == Wrapped? + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value == Wrapped? { + get { + Callable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value == Wrapped? { + get { + NonCallable( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } + @dynamicMemberLookup public struct NonCallableIfLet { + public typealias Value = Wrapped? + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks + public typealias ScopedContainer = DeclarativeConfigurationCore.AnyConfigurationContainer + @usableFromInline + internal var container: Container + @usableFromInline + internal var keyPath: Swift.KeyPath.NonCallableIfLet.Value> + @usableFromInline + internal init(container: Container, keyPath: Swift.KeyPath.NonCallableIfLet.Value>) + public func peek(_ operation: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.Value) -> Swift.Void) -> Container + @available(*, unavailable, message: "Not available for non-writable key path") + public func callAsFunction(else defaultValue: Wrapped) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable + public func scope(_ config: @escaping (DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + public func configured(using config: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet.ScopedContainer) -> Container + @inlinable public subscript(dynamicMember keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get { + CallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get { + NonCallableIfLet( + container: self.container, + keyPath: self.keyPath.appending(path: keyPath) + ) + } + } + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Value : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ value: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet where Wrapped : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + get + } +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet { + public func ifLet(_ keyPath: Swift.ReferenceWritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + public func callAsFunction(ifLet newValue: Value?) -> Container +} +extension DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + public func callAsFunction(ifLet newValue: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet.Value?) -> Container +} +public protocol ConfigurationContainer { + associatedtype Base +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public typealias Blocks = DeclarativeConfigurationCore.ConfigurationBlocks +} +extension DeclarativeConfigurationCore.ConfigurationContainer where Self.Base : SwiftMarkerProtocols._OptionalProtocol { + public var ifLet: DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet { + get + } + public func ifNil(_ newValue: Self.Base) -> Self +} +extension DeclarativeConfigurationCore.ConfigurationContainer { + public func ifLet(_ keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.CallableIfLet + public func ifLet(_ keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallableIfLet + @inlinable public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable { + get { + .init(container: self, keyPath: keyPath) + } + } + @inlinable public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable { + get { + .init(container: self, keyPath: keyPath) + } + } + public subscript(dynamicMember keyPath: Swift.WritableKeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.Callable where Self.Base == Wrapped? { + get + } + public subscript(dynamicMember keyPath: Swift.KeyPath) -> DeclarativeConfigurationCore.ConfigurationBlocks.NonCallable where Self.Base == Wrapped? { + get + } +} +@dynamicMemberLookup public struct AnyConfigurationContainer : DeclarativeConfigurationCore.ConfigurationContainer { + internal let underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer + public init(_ underlyingContainer: any DeclarativeConfigurationCore.ConfigurationContainer) +} +public protocol ConfigurationStorage { + associatedtype Base +} +public struct DefaultConfigurationStorage : DeclarativeConfigurationCore.ConfigurationStorage { + internal var items: [any DeclarativeConfigurationCore._ConfigurationItem] + public init() +} +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +} diff --git a/.agents/interfaces/ios/FunctionalBuilder.swiftinterface b/.agents/interfaces/ios/FunctionalBuilder.swiftinterface new file mode 100644 index 0000000..9650167 --- /dev/null +++ b/.agents/interfaces/ios/FunctionalBuilder.swiftinterface @@ -0,0 +1,13 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalBuilder -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Builder = DeclarativeConfiguration.Builder +@available(*, deprecated, message: "FunctionalBuilder module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias BuilderProvider = DeclarativeConfiguration.BuilderProvider diff --git a/.agents/interfaces/ios/FunctionalClosures.swiftinterface b/.agents/interfaces/ios/FunctionalClosures.swiftinterface new file mode 100644 index 0000000..c89896a --- /dev/null +++ b/.agents/interfaces/ios/FunctionalClosures.swiftinterface @@ -0,0 +1,236 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalClosures -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +public enum HandlerContainerBehaviour { + case resetting + case preceding + case appending + @_semantics("derived_enum_equals") @_implements(Swift.Equatable, ==(_:_:)) public static func __derived_enum_equals(_ a: FunctionalClosures.HandlerContainerBehaviour, _ b: FunctionalClosures.HandlerContainerBehaviour) -> Swift.Bool + public func hash(into hasher: inout Swift.Hasher) + public var hashValue: Swift.Int { + get + } +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class _Handler { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((repeat each T) -> Swift.Void)? + public init(action: ((repeat each T) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((repeat each T) -> Swift.Void)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures._Handler.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures._Handler.Container + public var projectedValue: ((repeat each T) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: repeat each T) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +public typealias Handler = FunctionalClosures.Handler1 +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler1 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Swift.Void)? + public init(action: ((Input) -> Swift.Void)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Swift.Void)?) { + self.action = action + } + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/CaptureContext/swift-declarative-configuration/issues/1") + @inlinable public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler1.Container.Behaviour, perform action: ((Input) -> Swift.Void)?) { + switch behaviour { + case .resetting: + self.action = action + case .preceding: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + case .appending: + let oldAction = self.action + self.action = { input in + action?(input) + oldAction?(input) + } + } + } + } + public init() + public init(wrappedValue: FunctionalClosures.Handler1.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler1.Container + public var projectedValue: ((Input) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ input: Input) + public func callAsFunction() where Input == () + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler2 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1) -> Swift.Void)? + public init(action: ((T0, T1) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler2.Container.Behaviour, perform action: ((T0, T1) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler2.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler2.Container + public var projectedValue: ((T0, T1) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler3 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2) -> Swift.Void)? + public init(action: ((T0, T1, T2) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler3.Container.Behaviour, perform action: ((T0, T1, T2) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler3.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler3.Container + public var projectedValue: ((T0, T1, T2) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler4 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler4.Container.Behaviour, perform action: ((T0, T1, T2, T3) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler4.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler4.Container + public var projectedValue: ((T0, T1, T2, T3) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3) + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo, our advice is to use Combine/Observation instead") +@propertyWrapper public class Handler5 { + public struct Container { + public typealias Behaviour = FunctionalClosures.HandlerContainerBehaviour + @_hasInitialValue internal var action: ((T0, T1, T2, T3, T4) -> Swift.Void)? + public init(action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + public mutating func callAsFunction(perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + @available(*, deprecated, message: "This API will be removed,\nconsider using redeclaration with `(Input) -> Output` signature function.\nFeel free to discuss the API here\nhttps://github.com/MakeupStudio/swift-declarative-configuration/issues/1") + public mutating func callAsFunction(_ behaviour: FunctionalClosures.Handler5.Container.Behaviour, perform action: ((T0, T1, T2, T3, T4) -> Swift.Void)?) + } + public init() + public init(wrappedValue: FunctionalClosures.Handler5.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.Handler5.Container + public var projectedValue: ((T0, T1, T2, T3, T4) -> Swift.Void)? { + get + set + } + public func callAsFunction(_ t0: T0, _ t1: T1, _ t2: T2, _ t3: T3, _ t4: T4) + @objc deinit +} +@available(macOS 14.0.0, iOS 17.0.0, tvOS 17.0.0, watchOS 10.0.0, *) +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class _DataSource { + public struct Container { + @usableFromInline + internal var action: (repeat each T) -> Output + public init(action: @escaping (repeat each T) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (repeat each T) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures._DataSource.Container) + public var wrappedValue: FunctionalClosures._DataSource.Container + @inlinable public var projectedValue: (repeat each T) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ args: repeat each T) -> Output? { + projectedValue(repeat each args) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class DataSource { + public struct Container { + @usableFromInline + internal var action: (Input) -> Output + public init(action: @escaping (Input) -> Output) + @inlinable public mutating func callAsFunction(perform action: @escaping (Input) -> Output) { + self.action = action + } + } + public init(wrappedValue: FunctionalClosures.DataSource.Container) + public var wrappedValue: FunctionalClosures.DataSource.Container + @inlinable public var projectedValue: (Input) -> Output { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue(input) + } + @inlinable public func callAsFunction() -> Output where Input == () { + projectedValue(()) + } + @objc deinit +} +@available(*, deprecated, message: "If you use this functionality, consider copying sources and please submit an issue to the repo") +@propertyWrapper public class OptionalDataSource { + public struct Container { + @usableFromInline + @_hasInitialValue internal var action: ((Input) -> Output)? + public init(action: ((Input) -> Output)?) + @inlinable public mutating func callAsFunction(perform action: ((Input) -> Output)?) { + self.action = action + } + } + public init() + public init(wrappedValue: FunctionalClosures.OptionalDataSource.Container) + @_hasInitialValue public var wrappedValue: FunctionalClosures.OptionalDataSource.Container + @inlinable public var projectedValue: ((Input) -> Output)? { + get { wrappedValue.action } + set { wrappedValue.action = newValue } + } + @inlinable public func callAsFunction(_ input: Input) -> Output? { + projectedValue?(input) + } + @inlinable public func callAsFunction() -> Output? where Input == () { + projectedValue?(()) + } + @objc deinit +} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Equatable {} +extension FunctionalClosures.HandlerContainerBehaviour : Swift.Hashable {} diff --git a/.agents/interfaces/ios/FunctionalConfigurator.swiftinterface b/.agents/interfaces/ios/FunctionalConfigurator.swiftinterface new file mode 100644 index 0000000..f095ccb --- /dev/null +++ b/.agents/interfaces/ios/FunctionalConfigurator.swiftinterface @@ -0,0 +1,38 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalConfigurator -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfiguration +import Foundation +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias Configurator = DeclarativeConfiguration.Configurator +public protocol ___ConfigInitializableProtocol_DEPRECATED : DeclarativeConfiguration.CallAsFunctionConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias ConfigInitializable = FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableProtocol_DEPRECATED { + @available(*, deprecated, message: "Use `.init().configured(using: config) instead\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") + public init(config configurator: Self.Config) +} +public protocol ___CustomConfigurableProtocol_DEPRECATED : DeclarativeConfiguration.CustomConfigurableProtocol { + init() +} +@available(*, deprecated, message: "Use `DefaultConfigurableProtocol` or `CustomConfigurableProtocol` instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias CustomConfigurable = FunctionalConfigurator.___CustomConfigurableProtocol_DEPRECATED +public protocol ___ConfigInitializableNSObject_DEPRECATED : ObjectiveC.NSObjectProtocol { +} +@available(*, deprecated, message: "Use CallAsFunctionConfigurableProtocol instead.\n\nFunctionalConfigurator module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +public typealias __ConfigInitializableNSObject = FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED +extension FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED where Self : ObjectiveC.NSObject { + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configuration: (Self.Config) -> Self.Config) + @available(*, deprecated, renamed: "init(unsafeConfig:)") + @_disfavoredOverload public init(config configurator: Self.Config) +} +extension ObjectiveC.NSObject : FunctionalConfigurator.___ConfigInitializableNSObject_DEPRECATED { +} diff --git a/.agents/interfaces/ios/FunctionalKeyPath.swiftinterface b/.agents/interfaces/ios/FunctionalKeyPath.swiftinterface new file mode 100644 index 0000000..5d75ef5 --- /dev/null +++ b/.agents/interfaces/ios/FunctionalKeyPath.swiftinterface @@ -0,0 +1,162 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalKeyPath -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +@_exported import DeclarativeConfigurationCore +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, renamed: "ValuePath", message: "FunctionalKeyPath module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead.") +public typealias FunctionalKeyPath = FunctionalKeyPath.__ValuePath_DEPRECATED +public struct __ValuePath_DEPRECATED { + @usableFromInline + internal let _embed: (Value, Root) -> Root + @usableFromInline + internal let _extract: (Root) -> Value + public init(embed: @escaping (Value, Root) -> Root, extract: @escaping (Root) -> Value) +} +@available(*, deprecated, message: "Consider using KeyPaths or copying sources instead.\nhttps://github.com/capturecontext/swift-keypaths-extensions\ncan help with combining optional keypaths while keeping hashability.\nhttps://github.com/pointfreeco/swift-case-paths can help with\nboth simple optional keypaths and enum case paths (CasePaths).\nValuePaths are likely to be removed in v1.0.0") +public typealias ValuePath = FunctionalKeyPath.__ValuePath_DEPRECATED +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public func embed(_ value: Value, in root: Root) -> Root { + _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: Root) where Root : AnyObject { + _ = _embed(value, root) + } + @inlinable public func embed(_ value: Value, in root: inout Root) { + root = embed(value, in: root) + } + @inlinable public func extract(from root: Root) -> Value { + _extract(root) + } + @inlinable public init(_ keyPath: Swift.WritableKeyPath) { + self.init( + embed: { value, root in + var root = root + root[keyPath: keyPath] = value + return root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public static func getonly(_ keyPath: Swift.KeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { _, root in + root + }, + extract: { root in + root[keyPath: keyPath] + } + ) + } + @inlinable public func unwrapped(withDefaultValue defaultValue: @autoclosure @escaping () -> Wrapped) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + __ValuePath_DEPRECATED( + embed: { value, root in + _embed(value, root) + }, + extract: { + _extract($0) ?? defaultValue() + } + ) + } + @inlinable public static func optional(_ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional() + } + @inlinable public static func optional(unwrapWithRoot: Swift.Bool, _ keyPath: Swift.WritableKeyPath) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED(keyPath).optional(unwrapWithRoot: unwrapWithRoot) + } + @inlinable public func optional() -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let value else { return root } + return self._embed(value, root) + }, + extract: { root in + return self._extract(root) + } + ) + } + @inlinable public func optional(unwrapWithRoot: Swift.Bool) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { value, root in + guard let root, let value else { return unwrapWithRoot ? root : nil } + return self._embed(value, root) + }, + extract: { root in + guard let root else { return nil } + return self._extract(root) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED { + __ValuePath_DEPRECATED( + embed: { appendedValue, root in + self.embed( + path.embed( + appendedValue, + in: self.extract(from: root) + ), + in: root + ) + }, + extract: { root in + path.extract( + from: self.extract(from: root) + ) + } + ) + } + @inlinable public func appending(path: FunctionalKeyPath.__ValuePath_DEPRECATED) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Value == Wrapped? { + appending(path: path.optional(unwrapWithRoot: true)) + } +} +extension FunctionalKeyPath.__ValuePath_DEPRECATED { + @inlinable public static func key(_ key: Key) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root == [Key : Element], Value == Element?, Key : Swift.Hashable { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { $0[key] = value } + }, + extract: { $0[key] } + ) + } + @inlinable public static func index(_ index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + root[index] = value + } + }, + extract: { root in + root[index] + } + ) + } + @inlinable public static func index(getonly index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.Collection, Value == Root.Element { + __ValuePath_DEPRECATED( + embed: { _, root in root }, + extract: { $0[index] } + ) + } + @inlinable public static func index(safe index: Root.Index) -> FunctionalKeyPath.__ValuePath_DEPRECATED where Root : Swift.MutableCollection, Value == Root.Element? { + __ValuePath_DEPRECATED( + embed: { value, root in + reduce(root) { root in + guard + let value = value, + root.indices.contains(index) + else { return } + root[index] = value + } + }, + extract: { root in + root.indices.contains(index) + ? root[index] + : nil + } + ) + } +} diff --git a/.agents/interfaces/ios/FunctionalModification.swiftinterface b/.agents/interfaces/ios/FunctionalModification.swiftinterface new file mode 100644 index 0000000..06d5139 --- /dev/null +++ b/.agents/interfaces/ios/FunctionalModification.swiftinterface @@ -0,0 +1,14 @@ +// 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-ios13.0-simulator -enable-objc-interop -swift-version 6 -O -module-name FunctionalModification -package-name swift_declarative_configuration +// swift-module-flags-ignorable: -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3.3 +import Swift +import _Concurrency +import _StringProcessing +import _SwiftConcurrencyShims +@available(*, deprecated, message: "FunctionalModification module is deprecated and will be removed in v1.0.0\nUse `import DeclarativeConfiguration` instead") +@inlinable public func reduce(_ value: Value, with transform: (inout Value) -> Swift.Void) -> Value { + var _value = value + transform(&_value) + return _value +}