Swift Package Index

Build Information

Successful build of FP, reference v3.0.0 (a82563), with Swift 6.3 for macOS (SPM) on 16 Oct 2026 20:25:13 UTC.

Swift 6 data race errors: 0

Build Command

env DEVELOPER_DIR=/Applications/Xcode-26.5.0.app xcrun swift build --arch arm64

Build Log

 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:45:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 43 |         subscript<A>(optic optic: Lens<Value, A>) -> Binding<A> {
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
 47 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:46:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 47 |             )
 48 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:64:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 62 |         subscript<A>(optic optic: Iso<Value, A>) -> Binding<A> {
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
 66 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:65:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:45:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 43 |         subscript<A>(optic optic: Lens<Value, A>) -> Binding<A> {
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
 47 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:46:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 47 |             )
 48 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:64:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 62 |         subscript<A>(optic optic: Iso<Value, A>) -> Binding<A> {
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
 66 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:65:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:45:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 43 |         subscript<A>(optic optic: Lens<Value, A>) -> Binding<A> {
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
 47 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:46:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 47 |             )
 48 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:64:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 62 |         subscript<A>(optic optic: Iso<Value, A>) -> Binding<A> {
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
 66 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:65:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:45:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 43 |         subscript<A>(optic optic: Lens<Value, A>) -> Binding<A> {
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
 47 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:46:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 47 |             )
 48 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:64:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 62 |         subscript<A>(optic optic: Iso<Value, A>) -> Binding<A> {
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
 66 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:65:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:45:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 43 |         subscript<A>(optic optic: Lens<Value, A>) -> Binding<A> {
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
 47 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:46:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 44 |             Binding<A>(
 45 |                 get: { optic.get(wrappedValue) },
 46 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 47 |             )
 48 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:64:34: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 62 |         subscript<A>(optic optic: Iso<Value, A>) -> Binding<A> {
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
    |                                  `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
 66 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:65:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 63 |             Binding<A>(
 64 |                 get: { optic.get(wrappedValue) },
 65 |                 set: { wrappedValue = optic.reverseGet($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 66 |             )
 67 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:89:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 84 |         /// case while the binding is held, the getter falls back to the last known value until
 85 |         /// SwiftUI re-evaluates and discards the binding.
 86 |         subscript<A>(optic optic: Prism<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
 87 |             guard let current = optic.preview(wrappedValue) else { return nil }
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
 90 |                 set: { wrappedValue = optic.review($0) }
 91 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:90:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 88 |             return Binding<A>(
 89 |                 get: { optic.preview(wrappedValue) ?? current },
 90 |                 set: { wrappedValue = optic.review($0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
 91 |             )
 92 |         }
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:38: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                      `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: capture of 'current' with non-Sendable type 'A' in a '@Sendable' closure [#SendableClosureCaptures]
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:108:55: warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
103 |         /// }
104 |         /// ```
105 |         subscript<A>(optic optic: AffineTraversal<Value, A>) -> Binding<A>? {
    |                   `- note: consider making generic parameter 'A' conform to the 'Sendable' protocol
106 |             guard let current = optic.preview(wrappedValue) else { return nil }
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
    |                                                       `- warning: implicit capture of 'current' requires that 'A' conforms to 'Sendable'
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
110 |             )
/Users/admin/builder/spi-builder-workspace/Sources/CoreFP/Utilities/Binding+Optics.swift:109:24: warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
107 |             return Binding<A>(
108 |                 get: { optic.preview(wrappedValue) ?? current },
109 |                 set: { wrappedValue = optic.set(wrappedValue, $0) }
    |                        `- warning: capture of 'self' with non-Sendable type 'Binding<Value>' in a '@Sendable' closure [#SendableClosureCaptures]
110 |             )
111 |         }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[384/905] Emitting module CoreFPOperators
[386/913] Compiling DataStructure Either+BitraverseResult.swift
[387/913] Compiling DataStructure Either+Foldable.swift
[388/913] Compiling DataStructure Either+Functor.swift
[389/913] Compiling DataStructure Either+Inverted.swift
[390/913] Compiling DataStructure EitherTArray+Applicative.swift
[391/913] Compiling DataStructure EitherTArray+Functor.swift
[392/913] Compiling DataStructure EitherTArray+Traversable.swift
[393/913] Compiling DataStructure EitherTArray+TraversableFree.swift
[394/913] Compiling DataStructure ArrayTEither+Applicative.swift
[395/913] Compiling DataStructure ArrayTEither+Functor.swift
[396/913] Compiling DataStructure ArrayTEither+Monad.swift
[397/913] Compiling DataStructure AsyncSequenceTEither+Applicative.swift
[402/913] Compiling DataStructure AsyncSequenceTEither+Functor.swift
[403/913] Compiling DataStructure AsyncSequenceTEither+Monad.swift
[404/913] Compiling DataStructure AsyncThrowingStream+Either.swift
[405/913] Compiling DataStructure Completion+Either.swift
[406/913] Compiling DataStructure Either+Applicative.swift
[407/913] Compiling DataStructure Either+Bifoldable.swift
[408/913] Compiling DataStructure Either+BitraverseArray.swift
[409/913] Compiling DataStructure Either+BitraverseOptional.swift
[410/913] Compiling DataStructure StatefulTWriter+Monad.swift
[411/913] Compiling DataStructure These+Applicative.swift
[412/913] Compiling DataStructure These+Either.swift
[413/913] Compiling DataStructure These+Functor.swift
[414/913] Compiling DataStructure These+Monad.swift
[415/913] Compiling DataStructure These.swift
[416/913] Compiling DataStructure ArrayTEither.swift
[417/913] Compiling DataStructure ArrayTStateful.swift
[418/913] Compiling DataStructure Either+Monad.swift
[419/913] Compiling DataStructure Either+Prism.swift
[420/913] Compiling DataStructure Either+Result.swift
[421/913] Compiling DataStructure Either.swift
[442/913] Compiling DataStructure ArrayTWriter.swift
[443/913] Compiling DataStructure AsyncStreamTEither.swift
[444/913] Compiling DataStructure AsyncStreamTStateful.swift
[445/913] Compiling DataStructure AsyncStreamTWriter.swift
[458/913] Compiling CoreFPOperators OpticsComposition.swift
[459/913] Compiling CoreFPOperators PrecedenceGroups.swift
[460/913] Compiling CoreFPOperators Semigroup.swift
[461/913] Compiling CoreFPOperators TraversalComposition.swift
[466/913] Compiling DataStructure EitherTNonEmpty+Applicative.swift
[467/913] Compiling DataStructure EitherTNonEmpty+Functor.swift
[468/913] Compiling DataStructure EitherTOptional+Applicative.swift
[469/913] Compiling DataStructure EitherTOptional+Functor.swift
[470/913] Compiling DataStructure EitherTOptional+Monad.swift
[471/913] Compiling DataStructure EitherTOptional+Traversable.swift
[472/913] Compiling DataStructure EitherTOptional+TraversableFree.swift
[473/913] Compiling DataStructure EitherTResult+Applicative.swift
[474/913] Compiling DataStructure EitherTResult+Functor.swift
[475/913] Compiling DataStructure EitherTResult+Monad.swift
[476/913] Compiling DataStructure EitherTResult+Traversable.swift
[477/913] Compiling DataStructure EitherTResult+TraversableFree.swift
[478/913] Compiling DataStructure EitherTStateful+Applicative.swift
[479/913] Compiling DataStructure EitherTStateful+Functor.swift
[480/913] Compiling DataStructure EitherTValidation+Applicative.swift
[481/913] Compiling DataStructure EitherTValidation+Functor.swift
[482/913] Compiling DataStructure EitherTWriter+Applicative.swift
[483/913] Compiling DataStructure EitherTWriter+Functor.swift
[484/913] Compiling DataStructure EitherTWriter+Monad.swift
[485/913] Compiling DataStructure OptionalTEither+Applicative.swift
[486/913] Compiling DataStructure OptionalTEither+Functor.swift
[487/913] Compiling DataStructure OptionalTEither+Monad.swift
[488/913] Compiling DataStructure PublisherTEither+Applicative.swift
[489/913] Compiling DataStructure PublisherTEither+Functor.swift
[490/936] Compiling DataStructure ReaderTResult+Applicative.swift
[491/936] Compiling DataStructure ReaderTResult+Functor.swift
[492/936] Compiling DataStructure ReaderTResult+Monad.swift
[493/936] Compiling DataStructure ReaderTStateful+Applicative.swift
[494/936] Compiling DataStructure ReaderTStateful+Functor.swift
[495/936] Compiling DataStructure ReaderTStateful+Monad.swift
[496/936] Compiling DataStructure ReaderTValidation+Applicative.swift
[497/936] Compiling DataStructure ReaderTValidation+Functor.swift
[498/936] Compiling DataStructure ReaderTWriter+Applicative.swift
[499/936] Compiling DataStructure ReaderTWriter+Functor.swift
[500/936] Compiling DataStructure ReaderTWriter+Monad.swift
[501/936] Compiling DataStructure ArrayTStateful+Applicative.swift
[502/936] Compiling DataStructure ArrayTStateful+Functor.swift
[503/936] Compiling DataStructure AsyncStreamTStateful+Functor.swift
[504/936] Compiling DataStructure OptionalTStateful+Applicative.swift
[505/936] Compiling DataStructure OptionalTStateful+Functor.swift
[506/936] Compiling DataStructure PublisherTStateful+Applicative.swift
[507/936] Compiling DataStructure PublisherTStateful+Functor.swift
[508/936] Compiling DataStructure ResultTStateful+Applicative.swift
[509/936] Compiling DataStructure ResultTStateful+Functor.swift
[510/936] Compiling DataStructure Stateful+Applicative.swift
[511/936] Compiling DataStructure Stateful+EndoMut.swift
[512/936] Compiling DataStructure Stateful+Functor.swift
[513/936] Compiling DataStructure Stateful+Monad.swift
[538/982] Compiling DataStructure Reader+Functor.swift
[539/982] Compiling DataStructure OptionalTStateful.swift
[540/982] Compiling DataStructure OptionalTWriter.swift
[541/982] Compiling DataStructure PublisherTEither.swift
[542/982] Compiling DataStructure PublisherTStateful.swift
[543/982] Compiling DataStructure PublisherTWriter.swift
[544/982] Compiling DataStructure ReaderTArray.swift
[545/982] Compiling DataStructure ReaderTAsyncStream.swift
[546/982] Compiling DataStructure ReaderTEither.swift
[547/982] Compiling DataStructure ReaderTNonEmpty.swift
[548/982] Compiling DataStructure ReaderTOptional.swift
[549/982] Compiling DataStructure ReaderTPublisher.swift
[550/982] Compiling DataStructure ReaderTReader.swift
[551/982] Compiling DataStructure ReaderTResult.swift
[552/982] Compiling DataStructure ReaderTStateful.swift
[553/982] Compiling DataStructure ReaderTValidation.swift
[554/982] Compiling DataStructure ReaderTWriter.swift
[555/982] Compiling DataStructure ResultTStateful.swift
[556/982] Compiling DataStructure ResultTWriter.swift
[557/982] Compiling DataStructure StatefulTArray.swift
[558/982] Compiling DataStructure StatefulTAsyncStream.swift
[559/982] Compiling DataStructure StatefulTEither.swift
[560/982] Compiling DataStructure StatefulTNonEmpty.swift
[561/982] Compiling DataStructure StatefulTOptional.swift
[673/1074] Compiling DataStructure EitherTStateful.swift
[674/1074] Compiling DataStructure EitherTValidation.swift
[675/1074] Compiling DataStructure EitherTWriter.swift
[676/1074] Compiling DataStructure NonEmptyTEither.swift
[677/1074] Compiling DataStructure NonEmptyTOptional.swift
[678/1074] Compiling DataStructure NonEmptyTResult.swift
[679/1074] Compiling DataStructure OptionalTEither.swift
[680/1074] Compiling DataStructure OptionalTNonEmpty.swift
[681/1120] Compiling DataStructure InnerShape.swift
[682/1120] Compiling DataStructure JoinVoid.swift
[683/1120] Compiling DataStructure ResultTValidation+Traversable.swift
[684/1120] Compiling DataStructure ResultTValidation+TraversableFree.swift
[685/1120] Compiling DataStructure Validation+Alt.swift
[686/1120] Compiling DataStructure Validation+Applicative.swift
[687/1120] Compiling DataStructure Validation+Bifoldable.swift
[688/1120] Compiling DataStructure Validation+BitraverseArray.swift
[689/1120] Compiling DataStructure Validation+BitraverseOptional.swift
[690/1120] Compiling DataStructure Validation+BitraverseResult.swift
[691/1120] Compiling DataStructure Validation+Either.swift
[692/1120] Compiling DataStructure Validation+Foldable.swift
[693/1120] Compiling DataStructure Validation+Functor.swift
[694/1120] Compiling DataStructure Validation+Prism.swift
[695/1120] Compiling DataStructure Validation+Result.swift
[696/1120] Compiling DataStructure Validation.swift
[697/1120] Compiling DataStructure ValidationTArray+Applicative.swift
[698/1120] Compiling DataStructure ValidationTArray+Functor.swift
[699/1120] Compiling DataStructure ValidationTArray+Traversable.swift
[700/1120] Compiling DataStructure ValidationTArray+TraversableFree.swift
[701/1120] Compiling DataStructure ValidationTEither+Applicative.swift
[702/1120] Compiling DataStructure ValidationTEither+Functor.swift
[703/1120] Compiling DataStructure ValidationTNonEmpty+Applicative.swift
[704/1120] Compiling DataStructure ValidationTNonEmpty+Functor.swift
[705/1120] Compiling DataStructure ValidationTOptional+Applicative.swift
[706/1120] Compiling DataStructure ValidationTOptional+Functor.swift
[707/1120] Compiling DataStructure ValidationTOptional+Traversable.swift
[708/1120] Compiling DataStructure ValidationTOptional+TraversableFree.swift
[709/1120] Compiling DataStructure ValidationTReader+Applicative.swift
[710/1120] Compiling DataStructure ValidationTReader+Functor.swift
[711/1120] Compiling DataStructure ValidationTResult+Applicative.swift
[712/1120] Compiling DataStructure ValidationTResult+Functor.swift
[713/1120] Compiling DataStructure ValidationTResult+Traversable.swift
[714/1120] Compiling DataStructure ValidationTResult+TraversableFree.swift
[715/1120] Compiling DataStructure ValidationTStateful+Applicative.swift
[716/1120] Compiling DataStructure ValidationTStateful+Functor.swift
[717/1120] Compiling DataStructure ValidationTWriter+Applicative.swift
[718/1120] Compiling DataStructure ValidationTWriter+Functor.swift
[719/1120] Compiling DataStructure ArrayTWriter+Applicative.swift
[720/1120] Compiling DataStructure ArrayTWriter+Functor.swift
[721/1120] Compiling DataStructure ArrayTWriter+Monad.swift
[722/1120] Compiling DataStructure AsyncStreamTWriter+Applicative.swift
[723/1120] Compiling DataStructure AsyncStreamTWriter+Functor.swift
[724/1120] Compiling DataStructure AsyncStreamTWriter+Monad.swift
[725/1120] Compiling DataStructure OptionalTWriter+Applicative.swift
[726/1120] Compiling DataStructure OptionalTWriter+Functor.swift
[750/1143] Compiling DataStructure OptionalTWriter+Monad.swift
[751/1143] Compiling DataStructure PublisherTWriter+Applicative.swift
[752/1143] Compiling DataStructure PublisherTWriter+Functor.swift
[753/1143] Compiling DataStructure PublisherTWriter+Monad.swift
[754/1143] Compiling DataStructure ResultTWriter+Applicative.swift
[755/1143] Compiling DataStructure ResultTWriter+Functor.swift
[756/1143] Compiling DataStructure ResultTWriter+Monad.swift
[757/1143] Compiling DataStructure Writer+Applicative.swift
[758/1143] Compiling DataStructure Writer+Comonad.swift
[759/1143] Compiling DataStructure Writer+Functor.swift
[760/1143] Compiling DataStructure Writer+Monad.swift
[761/1143] Compiling DataStructure Writer+Primitives.swift
[762/1143] Compiling DataStructure Writer+Semigroup.swift
[763/1143] Compiling DataStructure Writer.swift
[764/1143] Compiling DataStructure WriterTArray+Applicative.swift
[765/1143] Compiling DataStructure WriterTArray+Functor.swift
[766/1143] Compiling DataStructure WriterTArray+Traversable.swift
[767/1143] Compiling DataStructure WriterTArray+TraversableFree.swift
[768/1143] Compiling DataStructure WriterTEither+Applicative.swift
[769/1143] Compiling DataStructure WriterTEither+Functor.swift
[770/1143] Compiling DataStructure WriterTEither+Monad.swift
[771/1143] Compiling DataStructure WriterTNonEmpty+Applicative.swift
[772/1143] Compiling DataStructure WriterTNonEmpty+Functor.swift
[773/1143] Emitting module DataStructure
[774/1143] Compiling DataStructure StatefulTWriter+Functor.swift
[775/1143] Compiling DataStructure NonEmpty+Applicative.swift
[776/1143] Compiling DataStructure NonEmpty+Comonad.swift
[777/1143] Compiling DataStructure NonEmpty+Foldable.swift
[778/1143] Compiling DataStructure NonEmpty+Functor.swift
[779/1143] Compiling DataStructure NonEmpty+Monad.swift
[780/1143] Compiling DataStructure NonEmpty+Primitives.swift
[781/1143] Compiling DataStructure NonEmpty+Semigroup.swift
[782/1143] Compiling DataStructure NonEmpty+Traversable.swift
[783/1143] Compiling DataStructure NonEmpty.swift
[784/1143] Compiling DataStructure NonEmptyTEither+Applicative.swift
[785/1143] Compiling DataStructure NonEmptyTEither+Functor.swift
[786/1143] Compiling DataStructure NonEmptyTEither+Monad.swift
[787/1143] Compiling DataStructure NonEmptyTOptional+Applicative.swift
[788/1143] Compiling DataStructure NonEmptyTOptional+Functor.swift
[789/1143] Compiling DataStructure NonEmptyTOptional+Monad.swift
[790/1143] Compiling DataStructure NonEmptyTResult+Applicative.swift
[791/1143] Compiling DataStructure NonEmptyTResult+Functor.swift
[792/1143] Compiling DataStructure NonEmptyTResult+Monad.swift
[793/1143] Compiling DataStructure OptionalTNonEmpty+Applicative.swift
[794/1143] Compiling DataStructure OptionalTNonEmpty+Functor.swift
[795/1143] Compiling DataStructure OptionalTNonEmpty+Monad.swift
[796/1143] Compiling DataStructure Reader+Applicative.swift
[797/1143] Compiling DataStructure Reader+Comonad.swift
[798/1143] Compiling DataStructure ReaderTReader+Monad.swift
[799/1143] Compiling DataStructure Stateful+Optics.swift
[800/1143] Compiling DataStructure Stateful+Primitives.swift
[801/1143] Compiling DataStructure Stateful.swift
[802/1143] Compiling DataStructure StatefulTArray+Applicative.swift
[803/1143] Compiling DataStructure StatefulTArray+Functor.swift
[804/1143] Compiling DataStructure StatefulTEither+Applicative.swift
[805/1143] Compiling DataStructure StatefulTEither+Functor.swift
[806/1143] Compiling DataStructure StatefulTEither+Monad.swift
[807/1143] Compiling DataStructure StatefulTNonEmpty+Applicative.swift
[808/1143] Compiling DataStructure StatefulTNonEmpty+Functor.swift
[809/1143] Compiling DataStructure StatefulTOptional+Applicative.swift
[810/1143] Compiling DataStructure StatefulTOptional+Functor.swift
[811/1143] Compiling DataStructure StatefulTOptional+Monad.swift
[812/1143] Compiling DataStructure StatefulTPublisher+Applicative.swift
[813/1143] Compiling DataStructure StatefulTPublisher+Functor.swift
[814/1143] Compiling DataStructure StatefulTReader+Applicative.swift
[815/1143] Compiling DataStructure StatefulTReader+Functor.swift
[816/1143] Compiling DataStructure StatefulTResult+Applicative.swift
[817/1143] Compiling DataStructure StatefulTResult+Functor.swift
[818/1143] Compiling DataStructure StatefulTResult+Monad.swift
[819/1143] Compiling DataStructure StatefulTValidation+Applicative.swift
[820/1143] Compiling DataStructure StatefulTValidation+Functor.swift
[821/1143] Compiling DataStructure StatefulTWriter+Applicative.swift
[846/1143] Emitting module DataStructure
[870/1143] Compiling DataStructure Reader+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[871/1143] Compiling DataStructure Reader+Monoid.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[872/1143] Compiling DataStructure Reader.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[873/1143] Compiling DataStructure ReaderTArray+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[874/1143] Compiling DataStructure ReaderTArray+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[875/1143] Compiling DataStructure ReaderTArray+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[876/1143] Compiling DataStructure ReaderTAsyncSequence+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[877/1143] Compiling DataStructure ReaderTAsyncSequence+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[878/1143] Compiling DataStructure ReaderTAsyncSequence+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[879/1143] Compiling DataStructure ReaderTEither+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[880/1143] Compiling DataStructure ReaderTEither+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[881/1143] Compiling DataStructure ReaderTEither+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[882/1143] Compiling DataStructure ReaderTNonEmpty+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[883/1143] Compiling DataStructure ReaderTNonEmpty+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[884/1143] Compiling DataStructure ReaderTNonEmpty+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[885/1143] Compiling DataStructure ReaderTOptional+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[886/1143] Compiling DataStructure ReaderTOptional+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[887/1143] Compiling DataStructure ReaderTOptional+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[888/1143] Compiling DataStructure ReaderTPublisher+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[889/1143] Compiling DataStructure ReaderTPublisher+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[890/1143] Compiling DataStructure ReaderTPublisher+Monad.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[891/1143] Compiling DataStructure ReaderTReader+Applicative.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[892/1143] Compiling DataStructure ReaderTReader+Functor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[894/1143] Compiling DataStructure PublisherTEither+Monad.swift
[895/1143] Compiling DataStructure ResultTEither+Traversable.swift
[896/1143] Compiling DataStructure ResultTEither+TraversableFree.swift
[897/1143] Compiling DataStructure Gen+Combinators.swift
[898/1143] Compiling DataStructure Gen+Primitives.swift
[899/1143] Compiling DataStructure Gen.swift
[900/1143] Compiling DataStructure IdentifiedArray+Collection.swift
[901/1143] Compiling DataStructure IdentifiedArray+Optics.swift
[902/1143] Compiling DataStructure IdentifiedArray+Semigroup.swift
[903/1143] Compiling DataStructure IdentifiedArray.swift
[904/1143] Compiling DataStructure Loading+Applicative.swift
[905/1143] Compiling DataStructure Loading+Catch.swift
[906/1143] Compiling DataStructure Loading+Functor.swift
[907/1143] Compiling DataStructure Loading+Monad.swift
[908/1143] Compiling DataStructure Loading+Prisms.swift
[909/1143] Compiling DataStructure Loading+Result.swift
[910/1143] Compiling DataStructure Loading.swift
[911/1143] Compiling DataStructure Newtype+Collection.swift
[912/1143] Compiling DataStructure Newtype+Iso.swift
[913/1143] Compiling DataStructure Newtype+Literals.swift
[914/1143] Compiling DataStructure Newtype+Numeric.swift
[915/1143] Compiling DataStructure Newtype+NumericMonoid.swift
[916/1143] Compiling DataStructure Newtype+Semigroup.swift
[917/1143] Compiling DataStructure Newtype.swift
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:17:27: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
15 |         Reader<Environment, AsyncThrowingFlatMapSequence<AsyncThrowingMapSequence<AsyncStream<A>, B>, B>> { env in
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
   |                           `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
18 |                 try await fn(element).runReader(env)
19 |             }
/Users/admin/builder/spi-builder-workspace/Sources/DataStructure/Reader/ReaderTAsyncSequence+Monad.swift:18:21: warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
16 |             let stream = self.runReader(env)
17 |             return stream.bind { element in
18 |                 try await fn(element).runReader(env)
   |                     `- warning: capture of non-Sendable type 'B.Type' in an isolated closure [#SendableMetatypes]
19 |             }
20 |         }
[#SendableMetatypes]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-metatypes>
[1013/1143] Compiling DataStructure StatefulTPublisher.swift
[1014/1143] Compiling DataStructure StatefulTReader.swift
[1015/1143] Compiling DataStructure StatefulTResult.swift
[1016/1143] Compiling DataStructure StatefulTValidation.swift
[1017/1143] Compiling DataStructure StatefulTWriter.swift
[1018/1143] Compiling DataStructure ValidationTArray.swift
[1019/1143] Compiling DataStructure ValidationTEither.swift
[1020/1143] Compiling DataStructure ValidationTNonEmpty.swift
[1021/1143] Compiling DataStructure ValidationTOptional.swift
[1022/1143] Compiling DataStructure ValidationTReader.swift
[1023/1143] Compiling DataStructure ValidationTResult.swift
[1024/1143] Compiling DataStructure ValidationTStateful.swift
[1025/1143] Compiling DataStructure ValidationTWriter.swift
[1026/1143] Compiling DataStructure WriterTArray.swift
[1027/1143] Compiling DataStructure WriterTAsyncStream.swift
[1028/1143] Compiling DataStructure WriterTEither.swift
[1029/1143] Compiling DataStructure WriterTNonEmpty.swift
[1030/1143] Compiling DataStructure WriterTOptional.swift
[1031/1143] Compiling DataStructure WriterTPublisher.swift
[1032/1143] Compiling DataStructure WriterTReader.swift
[1033/1143] Compiling DataStructure WriterTResult.swift
[1034/1143] Compiling DataStructure WriterTStateful.swift
[1035/1143] Compiling DataStructure WriterTValidation.swift
[1059/1143] Compiling DataStructure WriterTOptional+Applicative.swift
[1060/1143] Compiling DataStructure WriterTOptional+Functor.swift
[1061/1143] Compiling DataStructure WriterTOptional+Monad.swift
[1062/1143] Compiling DataStructure WriterTOptional+Traversable.swift
[1063/1143] Compiling DataStructure WriterTOptional+TraversableFree.swift
[1064/1143] Compiling DataStructure WriterTPublisher+Applicative.swift
[1065/1143] Compiling DataStructure WriterTPublisher+Functor.swift
[1066/1143] Compiling DataStructure WriterTReader+Applicative.swift
[1067/1143] Compiling DataStructure WriterTReader+Functor.swift
[1068/1143] Compiling DataStructure WriterTResult+Applicative.swift
[1069/1143] Compiling DataStructure WriterTResult+Functor.swift
[1070/1143] Compiling DataStructure WriterTResult+Monad.swift
[1071/1143] Compiling DataStructure WriterTResult+Traversable.swift
[1072/1143] Compiling DataStructure WriterTResult+TraversableFree.swift
[1073/1143] Compiling DataStructure WriterTStateful+Applicative.swift
[1074/1143] Compiling DataStructure WriterTStateful+Functor.swift
[1075/1143] Compiling DataStructure WriterTValidation+Applicative.swift
[1076/1143] Compiling DataStructure WriterTValidation+Functor.swift
[1077/1143] Compiling DataStructure Zipper+Comonad.swift
[1078/1143] Compiling DataStructure Zipper+Functor.swift
[1079/1143] Compiling DataStructure Zipper+Navigation.swift
[1080/1143] Compiling DataStructure Zipper+NonEmpty.swift
[1081/1143] Compiling DataStructure Zipper.swift
[1128/1315] Compiling DataStructureOperators OptionalTWriter+Operators.swift
[1129/1315] Compiling DataStructureOperators PublisherTEither+Operators.swift
[1130/1315] Compiling DataStructureOperators PublisherTStateful+Operators.swift
[1131/1315] Compiling DataStructureOperators PublisherTWriter+Operators.swift
[1132/1315] Compiling DataStructureOperators ReaderTArray+Operators.swift
[1133/1315] Compiling DataStructureOperators ReaderTAsyncStream+Operators.swift
[1134/1315] Compiling DataStructureOperators ReaderTEither+Operators.swift
[1135/1315] Compiling DataStructureOperators ReaderTNonEmpty+Operators.swift
[1136/1315] Compiling DataStructureOperators ReaderTOptional+Operators.swift
[1137/1315] Compiling DataStructureOperators These+MonadOperators.swift
[1138/1324] Emitting module DataStructureOperators
[1139/1333] Compiling DataStructureOperators ArrayTEither+Operators.swift
[1140/1333] Compiling DataStructureOperators ArrayTStateful+Operators.swift
[1141/1333] Compiling DataStructureOperators ArrayTWriter+Operators.swift
[1142/1333] Compiling DataStructureOperators AsyncStreamTEither+Operators.swift
[1143/1333] Compiling DataStructureOperators AsyncStreamTStateful+Operators.swift
[1144/1333] Compiling DataStructureOperators AsyncStreamTWriter+Operators.swift
[1145/1333] Compiling DataStructureOperators EitherTArray+Operators.swift
[1146/1333] Compiling DataStructureOperators EitherTNonEmpty+Operators.swift
[1147/1333] Compiling DataStructureOperators EitherTOptional+Operators.swift
[1148/1333] Compiling DataStructureOperators ValidationTArray+Operators.swift
[1149/1333] Compiling DataStructureOperators ValidationTEither+Operators.swift
[1150/1333] Compiling DataStructureOperators ValidationTNonEmpty+Operators.swift
[1151/1333] Compiling DataStructureOperators ValidationTOptional+Operators.swift
[1152/1333] Compiling DataStructureOperators ValidationTReader+Operators.swift
[1153/1333] Compiling DataStructureOperators ValidationTResult+Operators.swift
[1154/1333] Compiling DataStructureOperators ValidationTStateful+Operators.swift
[1155/1333] Compiling DataStructureOperators ValidationTWriter+Operators.swift
[1156/1333] Compiling DataStructureOperators WriterTArray+Operators.swift
[1157/1333] Compiling DataStructureOperators ReaderTPublisher+Operators.swift
[1158/1333] Compiling DataStructureOperators ReaderTReader+Operators.swift
[1159/1333] Compiling DataStructureOperators ReaderTResult+Operators.swift
[1160/1333] Compiling DataStructureOperators ReaderTStateful+Operators.swift
[1161/1333] Compiling DataStructureOperators ReaderTValidation+Operators.swift
[1162/1333] Compiling DataStructureOperators ReaderTWriter+Operators.swift
[1163/1333] Compiling DataStructureOperators ResultTStateful+Operators.swift
[1164/1333] Compiling DataStructureOperators ResultTWriter+Operators.swift
[1165/1333] Compiling DataStructureOperators StatefulTArray+Operators.swift
[1166/1333] Emitting module DataStructureOperators
[1167/1333] Compiling DataStructureOperators Either+ApplicativeOperators.swift
[1168/1333] Compiling DataStructureOperators Either+FunctorOperators.swift
[1169/1333] Compiling DataStructureOperators Either+MonadOperators.swift
[1170/1333] Compiling DataStructureOperators KleisliReverse.swift
[1171/1333] Compiling DataStructureOperators Loading+ApplicativeOperators.swift
[1172/1333] Compiling DataStructureOperators Loading+FunctorOperators.swift
[1173/1333] Compiling DataStructureOperators Loading+MonadOperators.swift
[1174/1333] Compiling DataStructureOperators NonEmpty+ApplicativeOperators.swift
[1175/1333] Compiling DataStructureOperators NonEmpty+ComonadOperators.swift
[1176/1333] Compiling DataStructureOperators NonEmpty+FunctorOperators.swift
[1177/1333] Compiling DataStructureOperators NonEmpty+MonadOperators.swift
[1178/1333] Compiling DataStructureOperators Reader+ApplicativeOperators.swift
[1179/1333] Compiling DataStructureOperators Reader+ComonadOperators.swift
[1180/1333] Compiling DataStructureOperators Reader+FunctorOperators.swift
[1181/1333] Compiling DataStructureOperators Reader+MonadOperators.swift
[1182/1333] Compiling DataStructureOperators Stateful+ApplicativeOperators.swift
[1183/1333] Compiling DataStructureOperators Stateful+FunctorOperators.swift
[1184/1333] Compiling DataStructureOperators Stateful+MonadOperators.swift
[1185/1333] Compiling DataStructureOperators These+ApplicativeOperators.swift
[1186/1333] Compiling DataStructureOperators These+FunctorOperators.swift
[1187/1333] Compiling DataStructureOperators StatefulTAsyncStream+Operators.swift
[1188/1333] Compiling DataStructureOperators StatefulTEither+Operators.swift
[1189/1333] Compiling DataStructureOperators StatefulTNonEmpty+Operators.swift
[1190/1333] Compiling DataStructureOperators StatefulTOptional+Operators.swift
[1191/1333] Compiling DataStructureOperators StatefulTPublisher+Operators.swift
[1192/1333] Compiling DataStructureOperators StatefulTReader+Operators.swift
[1193/1333] Compiling DataStructureOperators StatefulTResult+Operators.swift
[1194/1333] Compiling DataStructureOperators StatefulTValidation+Operators.swift
[1195/1333] Compiling DataStructureOperators StatefulTWriter+Operators.swift
[1196/1333] Compiling DataStructureOperators WriterTAsyncStream+Operators.swift
[1197/1333] Compiling DataStructureOperators WriterTEither+Operators.swift
[1198/1333] Compiling DataStructureOperators WriterTNonEmpty+Operators.swift
[1199/1333] Compiling DataStructureOperators WriterTOptional+Operators.swift
[1200/1333] Compiling DataStructureOperators WriterTPublisher+Operators.swift
[1201/1333] Compiling DataStructureOperators WriterTReader+Operators.swift
[1202/1333] Compiling DataStructureOperators WriterTResult+Operators.swift
[1203/1333] Compiling DataStructureOperators WriterTStateful+Operators.swift
[1204/1333] Compiling DataStructureOperators WriterTValidation+Operators.swift
[1205/1333] Compiling DataStructureOperators EitherTResult+Operators.swift
[1206/1333] Compiling DataStructureOperators EitherTStateful+Operators.swift
[1207/1333] Compiling DataStructureOperators EitherTValidation+Operators.swift
[1208/1333] Compiling DataStructureOperators EitherTWriter+Operators.swift
[1209/1333] Compiling DataStructureOperators NonEmptyTEither+Operators.swift
[1210/1333] Compiling DataStructureOperators NonEmptyTOptional+Operators.swift
[1211/1333] Compiling DataStructureOperators NonEmptyTResult+Operators.swift
[1212/1333] Compiling DataStructureOperators OptionalTEither+Operators.swift
[1213/1333] Compiling DataStructureOperators OptionalTNonEmpty+Operators.swift
[1214/1333] Compiling DataStructureOperators OptionalTStateful+Operators.swift
[1300/1333] Compiling DataStructureOperators Validation+AltOperators.swift
[1301/1333] Compiling DataStructureOperators Validation+ApplicativeOperators.swift
[1302/1333] Compiling DataStructureOperators Validation+FunctorOperators.swift
[1303/1333] Compiling DataStructureOperators Writer+ApplicativeOperators.swift
[1304/1333] Compiling DataStructureOperators Writer+ComonadOperators.swift
[1305/1333] Compiling DataStructureOperators Writer+FunctorOperators.swift
[1306/1333] Compiling DataStructureOperators Writer+MonadOperators.swift
[1307/1333] Compiling DataStructureOperators Zipper+ComonadOperators.swift
[1308/1333] Compiling DataStructureOperators Zipper+FunctorOperators.swift
[1325/1335] Emitting module FP
[1326/1335] Compiling FP FP.swift
[1334/1395] Compiling SwiftDiagnostics Message.swift
[1335/1396] Compiling SwiftBasicFormat Trivia+FormatExtensions.swift
[1336/1396] Compiling SwiftBasicFormat SyntaxProtocol+Formatted.swift
[1337/1396] Compiling SwiftDiagnostics Note.swift
[1338/1396] Compiling SwiftDiagnostics GroupedDiagnostics.swift
[1339/1396] Compiling SwiftDiagnostics FixIt.swift
[1340/1396] Compiling SwiftBasicFormat Syntax+Extensions.swift
[1341/1396] Compiling SwiftBasicFormat InferIndentation.swift
[1342/1396] Compiling SwiftDiagnostics DiagnosticDecorator.swift
[1343/1396] Compiling SwiftDiagnostics BasicDiagnosticDecorator.swift
[1344/1396] Compiling SwiftDiagnostics Diagnostic.swift
[1345/1396] Compiling SwiftDiagnostics Convenience.swift
[1346/1396] Emitting module SwiftDiagnostics
[1347/1396] Compiling SwiftDiagnostics ANSIDiagnosticDecorator.swift
[1348/1396] Compiling SwiftDiagnostics DiagnosticsFormatter.swift
[1349/1396] Compiling SwiftBasicFormat Indenter.swift
[1350/1396] Emitting module SwiftBasicFormat
[1351/1396] Compiling SwiftBasicFormat BasicFormat.swift
[1352/1396] Compiling SwiftParser TokenConsumer.swift
[1353/1396] Compiling SwiftParser TokenPrecedence.swift
[1354/1396] Compiling SwiftParser TokenSpec.swift
[1355/1396] Compiling SwiftParser TokenSpecSet.swift
[1356/1396] Compiling SwiftParser StringLiterals.swift
[1357/1396] Compiling SwiftParser SwiftParserCompatibility.swift
[1358/1396] Compiling SwiftParser SwiftVersion.swift
[1359/1396] Compiling SwiftParser SyntaxUtils.swift
[1360/1396] Compiling SwiftParser TopLevel.swift
[1361/1396] Compiling SwiftParser TriviaParser.swift
[1362/1396] Compiling SwiftParser Types.swift
[1363/1396] Compiling SwiftParser ExperimentalFeatures.swift
[1364/1400] Compiling SwiftParser Names.swift
[1365/1400] Compiling SwiftParser Nominals.swift
[1366/1400] Compiling SwiftParser Parameters.swift
[1367/1400] Compiling SwiftParser ParseSourceFile.swift
[1368/1400] Compiling SwiftParser Parser.swift
[1369/1400] Emitting module SwiftParser
[1370/1400] Compiling SwiftParser RegexLiteralLexer.swift
[1371/1400] Compiling SwiftParser UnicodeScalarExtensions.swift
[1372/1400] Compiling SwiftParser Lookahead.swift
[1373/1400] Compiling SwiftParser LoopProgressCondition.swift
[1374/1400] Compiling SwiftParser Modifiers.swift
[1375/1400] Compiling SwiftParser Patterns.swift
[1376/1400] Compiling SwiftParser Recovery.swift
[1377/1400] Compiling SwiftParser Specifiers.swift
[1378/1400] Compiling SwiftParser Statements.swift
[1379/1400] Compiling SwiftParser StringLiteralRepresentedLiteralValue.swift
[1380/1400] Compiling SwiftParser IsValidIdentifier.swift
[1381/1400] Compiling SwiftParser Cursor.swift
[1382/1400] Compiling SwiftParser Lexeme.swift
[1383/1400] Compiling SwiftParser LexemeSequence.swift
[1384/1400] Compiling SwiftParser Lexer.swift
[1385/1400] Compiling SwiftParser Attributes.swift
[1386/1400] Compiling SwiftParser Availability.swift
[1387/1400] Compiling SwiftParser CharacterInfo.swift
[1388/1400] Compiling SwiftParser CollectionNodes+Parsable.swift
[1389/1400] Compiling SwiftParser CompilerFiles.swift
[1390/1400] Compiling SwiftParser Declarations.swift
[1391/1400] Compiling SwiftParser Directives.swift
[1392/1400] Compiling SwiftParser ExpressionInterpretedAsVersionTuple.swift
[1393/1400] Compiling SwiftParser Expressions.swift
[1394/1400] Compiling SwiftParser IncrementalParseTransition.swift
[1395/1400] Compiling SwiftParser IsLexerClassified.swift
[1396/1400] Compiling SwiftParser LayoutNodes+Parsable.swift
[1397/1400] Compiling SwiftParser Parser+TokenSpecSet.swift
[1398/1400] Compiling SwiftParser TokenSpecStaticMembers.swift
[1399/1423] Compiling SwiftParserDiagnostics SyntaxKindNameForDiagnostics.swift
[1400/1424] Compiling SwiftOperators PrecedenceGraph.swift
[1401/1424] Compiling SwiftOperators PrecedenceGroup.swift
[1402/1425] Compiling SwiftParserDiagnostics SyntaxExtensions.swift
[1403/1425] Compiling SwiftParserDiagnostics TokenNameForDiagnostics.swift
[1404/1425] Compiling SwiftParserDiagnostics PresenceUtils.swift
[1405/1425] Compiling SwiftOperators SyntaxSynthesis.swift
[1406/1425] Compiling SwiftOperators OperatorTable.swift
[1407/1425] Compiling SwiftOperators OperatorTable+Semantics.swift
[1408/1425] Compiling SwiftOperators OperatorTable+Defaults.swift
[1409/1425] Compiling SwiftOperators OperatorError.swift
[1410/1425] Compiling SwiftOperators OperatorError+Diagnostics.swift
[1411/1425] Compiling SwiftOperators Operator.swift
[1412/1425] Emitting module SwiftOperators
[1413/1425] Compiling SwiftOperators OperatorTable+Folding.swift
[1414/1425] Compiling SwiftParserDiagnostics Utils.swift
[1415/1425] Compiling SwiftParserDiagnostics ChildNameForDiagnostics.swift
[1416/1425] Compiling SwiftParserDiagnostics ParserDiagnosticMessages.swift
[1417/1425] Emitting module SwiftParserDiagnostics
[1418/1425] Compiling SwiftParserDiagnostics MissingNodesError.swift
[1419/1425] Compiling SwiftParserDiagnostics MissingTokenError.swift
[1420/1425] Compiling SwiftParserDiagnostics MultiLineStringLiteralDiagnosticsGenerator.swift
[1421/1425] Compiling SwiftParserDiagnostics ParseDiagnosticsGenerator.swift
[1422/1425] Compiling SwiftParserDiagnostics DiagnosticExtensions.swift
[1423/1425] Compiling SwiftParserDiagnostics LexerDiagnosticMessages.swift
[1424/1440] Compiling SwiftSyntaxBuilder RenamedChildrenBuilderCompatibility.swift
[1425/1440] Compiling SwiftSyntaxBuilder ResultBuilders.swift
[1426/1440] Compiling SwiftSyntaxBuilder BuildableNodes.swift
[1427/1441] Compiling SwiftSyntaxBuilder WithTrailingCommaSyntax+EnsuringTrailingComma.swift
[1428/1441] Compiling SwiftSyntaxBuilder SyntaxParsable+ExpressibleByStringInterpolation.swift
[1429/1441] Compiling SwiftSyntaxBuilder ValidatingSyntaxNodes.swift
[1430/1441] Compiling SwiftSyntaxBuilder ResultBuilderExtensions.swift
[1431/1441] Compiling SwiftSyntaxBuilder SwiftSyntaxBuilderCompatibility.swift
[1432/1441] Compiling SwiftSyntaxBuilder Indenter.swift
[1433/1441] Compiling SwiftSyntaxBuilder ListBuilder.swift
[1434/1441] Compiling SwiftSyntaxBuilder ConvenienceInitializers.swift
[1435/1441] Compiling SwiftSyntaxBuilder DeclSyntaxParseable.swift
[1436/1441] Emitting module SwiftSyntaxBuilder
[1437/1441] Compiling SwiftSyntaxBuilder Syntax+StringInterpolation.swift
[1438/1441] Compiling SwiftSyntaxBuilder SyntaxNodeWithBody.swift
[1439/1441] Compiling SwiftSyntaxBuilder SyntaxExpressibleByStringInterpolationConformances.swift
[1440/1456] Compiling SwiftIfConfig SyntaxLiteralUtils.swift
[1441/1456] Compiling SwiftIfConfig VersionTuple+Parsing.swift
[1442/1457] Compiling SwiftIfConfig SyntaxProtocol+IfConfig.swift
[1443/1457] Compiling SwiftIfConfig IfConfigFunctions.swift
[1444/1457] Compiling SwiftIfConfig IfConfigRegionState.swift
[1445/1457] Compiling SwiftIfConfig StaticBuildConfiguration.swift
[1446/1457] Compiling SwiftIfConfig VersionTuple.swift
[1447/1457] Compiling SwiftIfConfig ConfiguredRegions.swift
[1448/1457] Compiling SwiftIfConfig IfConfigDecl+IfConfig.swift
[1449/1457] Compiling SwiftIfConfig ActiveClauseEvaluator.swift
[1450/1457] Compiling SwiftIfConfig ActiveSyntaxRewriter.swift
[1451/1457] Compiling SwiftIfConfig ActiveSyntaxVisitor.swift
[1452/1457] Compiling SwiftIfConfig BuildConfiguration.swift
[1453/1457] Compiling SwiftIfConfig IfConfigDiagnostic.swift
[1454/1457] Compiling SwiftIfConfig IfConfigEvaluation.swift
[1455/1457] Emitting module SwiftIfConfig
[1456/1475] Compiling SwiftSyntaxMacros PreambleMacro.swift
[1457/1475] Compiling SwiftSyntaxMacros Macro.swift
[1458/1475] Compiling SwiftSyntaxMacros MemberAttributeMacro.swift
[1459/1475] Compiling SwiftSyntaxMacros MemberMacro.swift
[1460/1475] Compiling SwiftSyntaxMacros PeerMacro.swift
[1461/1476] Compiling SwiftSyntaxMacros AttachedMacro.swift
[1462/1476] Compiling SwiftSyntaxMacros BodyMacro.swift
[1463/1476] Compiling SwiftSyntaxMacros ExpressionMacro.swift
[1464/1476] Compiling SwiftSyntaxMacros ExtensionMacro.swift
[1465/1476] Compiling SwiftSyntaxMacros CodeItemMacro.swift
[1466/1476] Compiling SwiftSyntaxMacros DeclarationMacro.swift
[1467/1476] Compiling SwiftSyntaxMacros FreestandingMacro.swift
[1468/1476] Compiling SwiftSyntaxMacros Macro+Format.swift
[1469/1476] Compiling SwiftSyntaxMacros MacroExpansionDiagnosticMessages.swift
[1470/1476] Compiling SwiftSyntaxMacros AccessorMacro.swift
[1471/1476] Emitting module SwiftSyntaxMacros
[1472/1476] Compiling SwiftSyntaxMacros AbstractSourceLocation.swift
[1473/1476] Compiling SwiftSyntaxMacros MacroExpansionContext.swift
[1474/1476] Compiling SwiftSyntaxMacros Syntax+LexicalContext.swift
[1475/1486] Compiling SwiftSyntaxMacroExpansion IndentationUtils.swift
[1476/1486] Compiling SwiftSyntaxMacroExpansion MacroExpansion.swift
[1477/1486] Compiling SwiftSyntaxMacroExpansion MacroSpec.swift
[1478/1486] Compiling SwiftSyntaxMacroExpansion BasicMacroExpansionContext.swift
[1479/1486] Compiling SwiftSyntaxMacroExpansion MacroSystem.swift
[1480/1486] Compiling SwiftSyntaxMacroExpansion FunctionParameterUtils.swift
[1481/1486] Emitting module SwiftSyntaxMacroExpansion
[1482/1486] Compiling SwiftSyntaxMacroExpansion MacroArgument.swift
[1483/1486] Compiling SwiftSyntaxMacroExpansion MacroExpansionDiagnosticMessages.swift
[1484/1486] Compiling SwiftSyntaxMacroExpansion MacroReplacement.swift
[1485/1498] Compiling SwiftCompilerPluginMessageHandling Macros.swift
[1486/1498] Compiling SwiftCompilerPluginMessageHandling CompilerPluginMessageHandler.swift
[1487/1498] Compiling SwiftCompilerPluginMessageHandling Diagnostics.swift
[1488/1498] Compiling SwiftCompilerPluginMessageHandling JSONDecoding.swift
[1489/1498] Compiling SwiftCompilerPluginMessageHandling CodingUtilities.swift
[1490/1498] Compiling SwiftCompilerPluginMessageHandling JSON.swift
[1491/1498] Compiling SwiftCompilerPluginMessageHandling JSONEncoding.swift
[1492/1498] Compiling SwiftCompilerPluginMessageHandling LRUCache.swift
[1493/1498] Emitting module SwiftCompilerPluginMessageHandling
[1494/1498] Compiling SwiftCompilerPluginMessageHandling PluginMessageCompatibility.swift
[1495/1498] Compiling SwiftCompilerPluginMessageHandling PluginMessages.swift
[1496/1498] Compiling SwiftCompilerPluginMessageHandling PluginMacroExpansionContext.swift
[1497/1499] Compiling SwiftCompilerPluginMessageHandling StandardIOMessageConnection.swift
[1498/1501] Compiling SwiftCompilerPlugin CompilerPlugin.swift
[1499/1501] Emitting module SwiftCompilerPlugin
[1500/1511] Compiling FPMacrosPlugin StoredProperties.swift
[1501/1511] Compiling FPMacrosPlugin MockMacro.swift
[1502/1511] Compiling FPMacrosPlugin ProtocolRequirements.swift
[1503/1511] Compiling FPMacrosPlugin Plugin.swift
[1504/1511] Compiling FPMacrosPlugin PrismsMacro.swift
[1505/1512] Compiling FPMacrosPlugin IsoMacro.swift
[1506/1512] Compiling FPMacrosPlugin DeriveMonoidMacro.swift
[1507/1512] Compiling FPMacrosPlugin LensesMacro.swift
[1508/1512] Compiling FPMacrosPlugin ApplyOpticsMacro.swift
[1509/1512] Emitting module FPMacrosPlugin
[1510/1512] Compiling FPMacrosPlugin WitnessMacro.swift
[1510/1512] Write Objects.LinkFileList
[1511/1512] Linking FPMacrosPlugin-tool
[1513/1528] Compiling FPMacros Witness.swift
[1514/1528] Compiling FPMacros Iso.swift
[1515/1528] Compiling FPMacros ApplyOptics.swift
[1516/1528] Compiling FPMacros DeriveMonoid.swift
[1517/1528] Compiling FPMacros Lenses.swift
[1518/1528] Emitting module FPMacros
[1519/1528] Compiling FPMacros Prisms.swift
[1520/1528] Compiling FPMacros Mock.swift
[1521/1528] Compiling FPMacros Lenses.swift
[1522/1528] Compiling FPMacros ApplyOptics.swift
[1523/1528] Emitting module FPMacros
[1524/1528] Compiling FPMacros DeriveMonoid.swift
[1525/1528] Compiling FPMacros Witness.swift
[1526/1528] Compiling FPMacros Mock.swift
[1527/1528] Compiling FPMacros Prisms.swift
[1528/1528] Compiling FPMacros Iso.swift
Build complete! (52.34s)
Fetching https://github.com/swiftlang/swift-docc-plugin
Fetching https://github.com/swiftlang/swift-syntax.git
[1/2345] Fetching swift-docc-plugin
[2346/83134] Fetching swift-docc-plugin, swift-syntax
Fetched https://github.com/swiftlang/swift-docc-plugin from cache (8.82s)
Fetched https://github.com/swiftlang/swift-syntax.git from cache (8.82s)
Computing version for https://github.com/swiftlang/swift-syntax.git
Computed https://github.com/swiftlang/swift-syntax.git at 603.0.2 (12.13s)
Computing version for https://github.com/swiftlang/swift-docc-plugin
Computed https://github.com/swiftlang/swift-docc-plugin at 1.5.0 (0.68s)
Fetching https://github.com/swiftlang/swift-docc-symbolkit
[1/3841] Fetching swift-docc-symbolkit
Fetched https://github.com/swiftlang/swift-docc-symbolkit from cache (1.23s)
Computing version for https://github.com/swiftlang/swift-docc-symbolkit
Computed https://github.com/swiftlang/swift-docc-symbolkit at 1.0.0 (1.95s)
Creating working copy for https://github.com/swiftlang/swift-docc-symbolkit
Working copy of https://github.com/swiftlang/swift-docc-symbolkit resolved at 1.0.0
Creating working copy for https://github.com/swiftlang/swift-syntax.git
Working copy of https://github.com/swiftlang/swift-syntax.git resolved at 603.0.2
Creating working copy for https://github.com/swiftlang/swift-docc-plugin
Working copy of https://github.com/swiftlang/swift-docc-plugin resolved at 1.5.0
Build complete.
{
  "dependencies" : [
    {
      "identity" : "swift-syntax",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "603.0.1",
            "upper_bound" : "604.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/swiftlang/swift-syntax.git"
    },
    {
      "identity" : "swift-docc-plugin",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.4.0",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/swiftlang/swift-docc-plugin"
    }
  ],
  "manifest_display_name" : "FP",
  "name" : "FP",
  "path" : "/Users/admin/builder/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "10.15"
    },
    {
      "name" : "ios",
      "version" : "13.0"
    },
    {
      "name" : "tvos",
      "version" : "13.0"
    },
    {
      "name" : "watchos",
      "version" : "6.0"
    },
    {
      "name" : "visionos",
      "version" : "1.0"
    }
  ],
  "products" : [
    {
      "name" : "FP",
      "targets" : [
        "FP"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "CoreFP",
      "targets" : [
        "CoreFP"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "CoreFPOperators",
      "targets" : [
        "CoreFPOperators"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "DataStructure",
      "targets" : [
        "DataStructure"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "DataStructureOperators",
      "targets" : [
        "DataStructureOperators"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "FPMacros",
      "targets" : [
        "FPMacros"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "FPMacrosPlugin",
      "targets" : [
        "FPMacrosPlugin"
      ],
      "type" : {
        "macro" : null
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "FPMacrosTests",
      "module_type" : "SwiftTarget",
      "name" : "FPMacrosTests",
      "path" : "Tests/FPMacrosTests",
      "product_dependencies" : [
        "SwiftParser",
        "SwiftSyntaxMacroExpansion",
        "SwiftSyntaxMacrosGenericTestSupport",
        "SwiftSyntaxMacrosTestSupport"
      ],
      "sources" : [
        "ApplyOpticsTests.swift",
        "LensesTests.swift",
        "MacroExpansionSupport.swift",
        "MockRegressionTests.swift",
        "MockTests.swift",
        "OpticsRegressionTests.swift",
        "PrismsTests.swift",
        "ProductMacroTests.swift",
        "StoredPropertyRegressionTests.swift",
        "WitnessRegressionTests.swift",
        "WitnessTests.swift"
      ],
      "target_dependencies" : [
        "FPMacros",
        "FPMacrosPlugin",
        "CoreFP",
        "CoreFPOperators"
      ],
      "type" : "test"
    },
    {
      "c99name" : "FPMacrosPlugin",
      "module_type" : "SwiftTarget",
      "name" : "FPMacrosPlugin",
      "path" : "Sources/FPMacrosPlugin",
      "product_dependencies" : [
        "SwiftSyntaxMacros",
        "SwiftCompilerPlugin"
      ],
      "product_memberships" : [
        "FPMacros",
        "FPMacrosPlugin"
      ],
      "sources" : [
        "ApplyOpticsMacro.swift",
        "DeriveMonoidMacro.swift",
        "IsoMacro.swift",
        "LensesMacro.swift",
        "MockMacro.swift",
        "Plugin.swift",
        "PrismsMacro.swift",
        "ProtocolRequirements.swift",
        "StoredProperties.swift",
        "WitnessMacro.swift"
      ],
      "type" : "macro"
    },
    {
      "c99name" : "FPMacros",
      "module_type" : "SwiftTarget",
      "name" : "FPMacros",
      "path" : "Sources/FPMacros",
      "product_memberships" : [
        "FPMacros"
      ],
      "sources" : [
        "ApplyOptics.swift",
        "DeriveMonoid.swift",
        "Iso.swift",
        "Lenses.swift",
        "Mock.swift",
        "Prisms.swift",
        "Witness.swift"
      ],
      "target_dependencies" : [
        "CoreFP",
        "FPMacrosPlugin"
      ],
      "type" : "library"
    },
    {
      "c99name" : "FP",
      "module_type" : "SwiftTarget",
      "name" : "FP",
      "path" : "Sources/FP",
      "product_memberships" : [
        "FP"
      ],
      "sources" : [
        "FP.swift"
      ],
      "target_dependencies" : [
        "CoreFP",
        "CoreFPOperators",
        "DataStructure",
        "DataStructureOperators"
      ],
      "type" : "library"
    },
    {
      "c99name" : "DataStructureTests",
      "module_type" : "SwiftTarget",
      "name" : "DataStructureTests",
      "path" : "Tests/DataStructureTests",
      "sources" : [
        "ArrayTNonEmptyTApLawTests.swift",
        "ArrayTStateful+ApplicativeTests.swift",
        "ArrayTWriter+ApplicativeTests.swift",
        "AsyncStreamTestSupport.swift",
        "AsyncStreamTransformerConcatTests.swift",
        "AsyncThrowingStreamEitherTests.swift",
        "BifoldableTests.swift",
        "BitraversableTests.swift",
        "ComonadTests.swift",
        "CompletionEitherTests.swift",
        "DataOuterStackLawTests.swift",
        "DataOuterStreamStackLawTests.swift",
        "Either+FoldableTests.swift",
        "Either+PrismTests.swift",
        "EitherCoreTests.swift",
        "EitherOptionalStacksApLawTests.swift",
        "EitherTNonEmpty+Tests.swift",
        "EitherTNonEmptyApplicativeTests.swift",
        "EitherTStateful+ApplicativeTests.swift",
        "EitherTWriter+ApplicativeTests.swift",
        "EitherTests.swift",
        "GenTests.swift",
        "IdentifiedArrayTests.swift",
        "JoinVoidPureTests.swift",
        "KleisliTEitherTests.swift",
        "KleisliTReaderTests.swift",
        "KleisliTStatefulTests.swift",
        "KleisliTWriterTests.swift",
        "LawHarness.swift",
        "LoadingApplicativeTests.swift",
        "LoadingTests.swift",
        "NewtypeIsoMonoidTests.swift",
        "NewtypeTests.swift",
        "NonEmptyComonadTests.swift",
        "NonEmptyTEither+Tests.swift",
        "NonEmptyTEitherApplicativeTests.swift",
        "NonEmptyTOptionalApplicativeTests.swift",
        "NonEmptyTResultApplicativeTests.swift",
        "NonEmptyTests.swift",
        "OpticLawTests.swift",
        "OptionalTNonEmptyApplicativeTests.swift",
        "OptionalTStateful+ApplicativeTests.swift",
        "OptionalTWriter+ApplicativeTests.swift",
        "PerformanceRegressionTests.swift",
        "PublisherStackLawTests.swift",
        "PublisherTransformerTests.swift",
        "ReaderCoreTests.swift",
        "ReaderStatefulWriterBindLawTests.swift",
        "ReaderTAsyncSequence+Tests.swift",
        "ReaderTEither+Tests.swift",
        "ReaderTNonEmpty+Tests.swift",
        "ReaderTNonEmptyApplicativeTests.swift",
        "ReaderTOuterTransformerTests.swift",
        "ReaderTPublisher+Tests.swift",
        "ReaderTStackLawTests.swift",
        "ReaderTStateful+ApplicativeTests.swift",
        "ReaderTStreamLawTests.swift",
        "ReaderTWriter+ApplicativeTests.swift",
        "ReaderTests.swift",
        "ResultTStateful+ApplicativeTests.swift",
        "ResultTWriter+ApplicativeTests.swift",
        "ResultTraversableTests.swift",
        "Stateful+EndoMutTests.swift",
        "Stateful+OpticsTests.swift",
        "StatefulCoreTests.swift",
        "StatefulTArray+Tests.swift",
        "StatefulTEither+Tests.swift",
        "StatefulTInnerApLawTests.swift",
        "StatefulTNonEmpty+Tests.swift",
        "StatefulTNonEmptyApplicativeTests.swift",
        "StatefulTOptional+Tests.swift",
        "StatefulTPublisherLawTests.swift",
        "StatefulTReader+Tests.swift",
        "StatefulTResult+Tests.swift",
        "StatefulTStackLawTests.swift",
        "StatefulTValidation+Tests.swift",
        "TheseTests.swift",
        "TransformerStackSmokeTests.swift",
        "TraversableTests.swift",
        "Validation+PrismTests.swift",
        "ValidationOuterTransformerTests.swift",
        "ValidationTests.swift",
        "WriterCoreTests.swift",
        "WriterEitherTests.swift",
        "WriterInnerApConsistencyTests.swift",
        "WriterMonoidTests.swift",
        "WriterOuterBindLawTests.swift",
        "WriterOuterStackLawTests.swift",
        "WriterReaderTests.swift",
        "WriterStatefulTests.swift",
        "WriterTArray+Tests.swift",
        "WriterTInnerApLawTests.swift",
        "WriterTNonEmpty+Tests.swift",
        "WriterTNonEmptyApplicativeTests.swift",
        "WriterTOptional+Tests.swift",
        "WriterTPublisherLawTests.swift",
        "WriterTResult+Tests.swift",
        "ZeroCopyTests.swift",
        "ZipperTests.swift"
      ],
      "target_dependencies" : [
        "DataStructure",
        "CoreFP"
      ],
      "type" : "test"
    },
    {
      "c99name" : "DataStructureOperatorsTests",
      "module_type" : "SwiftTarget",
      "name" : "DataStructureOperatorsTests",
      "path" : "Tests/DataStructureOperatorsTests",
      "sources" : [
        "ArrayTNonEmptyTApLawOperatorsTests.swift",
        "ArrayTStatefulOperatorsTests.swift",
        "ArrayTWriterOperatorsTests.swift",
        "AsyncStreamTestSupport.swift",
        "AsyncStreamTransformerConcatOperatorsTests.swift",
        "ComonadOperatorsTests.swift",
        "Either+ApplicativeOperatorsTests.swift",
        "Either+FunctorOperatorsTests.swift",
        "Either+MonadOperatorsTests.swift",
        "EitherOptionalStacksApOperatorTests.swift",
        "EitherTNonEmptyOperatorsTests.swift",
        "EitherTransformerTests.swift",
        "IdentifiedArrayOperatorsTests.swift",
        "Loading+ApplicativeOperatorsTests.swift",
        "Loading+FunctorOperatorsTests.swift",
        "Loading+MonadOperatorsTests.swift",
        "NonEmpty+ApplicativeOperatorsTests.swift",
        "NonEmpty+FunctorOperatorsTests.swift",
        "NonEmpty+MonadOperatorsTests.swift",
        "NonEmptyComonadOperatorsTests.swift",
        "NonEmptyTEitherOperatorsTests.swift",
        "NonEmptyTOptionalOperatorsTests.swift",
        "NonEmptyTResultOperatorsTests.swift",
        "OptionalTNonEmptyOperatorsTests.swift",
        "OptionalTStatefulOperatorsTests.swift",
        "OptionalTWriterOperatorsTests.swift",
        "PublisherStackOperatorsTests.swift",
        "PublisherTransformerOperatorsTests.swift",
        "Reader+ApplicativeOperatorsTests.swift",
        "Reader+FunctorOperatorsTests.swift",
        "Reader+MonadOperatorsTests.swift",
        "ReaderStatefulWriterBindOperatorsTests.swift",
        "ReaderTAsyncSequence+OperatorsTests.swift",
        "ReaderTEither+OperatorsTests.swift",
        "ReaderTNonEmptyOperatorsTests.swift",
        "ReaderTOuterTransformerOperatorsTests.swift",
        "ReaderTPublisher+OperatorsTests.swift",
        "ReaderTStackOperatorsTests.swift",
        "ResultTStatefulOperatorsTests.swift",
        "ResultTWriterOperatorsTests.swift",
        "StatefulEitherOperatorsTests.swift",
        "StatefulOperatorsTests.swift",
        "StatefulReaderOperatorsTests.swift",
        "StatefulTArrayOperatorsTests.swift",
        "StatefulTEitherOperatorsTests.swift",
        "StatefulTInnerApOperatorsTests.swift",
        "StatefulTNonEmptyOperatorsTests.swift",
        "StatefulTOptionalOperatorsTests.swift",
        "StatefulTReaderOperatorsTests.swift",
        "StatefulTResultOperatorsTests.swift",
        "StatefulTWriterOperatorsTests.swift",
        "TheseOperatorsTests.swift",
        "TransformerStackOperatorSmokeTests.swift",
        "ValidationOperatorsTests.swift",
        "ValidationOuterTransformerOperatorsTests.swift",
        "WriterEitherOperatorsTests.swift",
        "WriterOperatorsTests.swift",
        "WriterOuterStackOperatorsTests.swift",
        "WriterReaderOperatorsTests.swift",
        "WriterStatefulOperatorsTests.swift",
        "WriterTArrayOperatorsTests.swift",
        "WriterTEitherOperatorsTests.swift",
        "WriterTInnerApOperatorsTests.swift",
        "WriterTNonEmptyOperatorsTests.swift",
        "WriterTOptionalOperatorsTests.swift",
        "WriterTReaderOperatorsTests.swift",
        "WriterTResultOperatorsTests.swift",
        "WriterTStatefulOperatorsTests.swift",
        "ZipperOperatorsTests.swift"
      ],
      "target_dependencies" : [
        "DataStructure",
        "DataStructureOperators",
        "CoreFPOperators",
        "CoreFP"
      ],
      "type" : "test"
    },
    {
      "c99name" : "DataStructureOperators",
      "module_type" : "SwiftTarget",
      "name" : "DataStructureOperators",
      "path" : "Sources/DataStructureOperators",
      "product_memberships" : [
        "FP",
        "DataStructureOperators"
      ],
      "sources" : [
        "Either/Either+ApplicativeOperators.swift",
        "Either/Either+FunctorOperators.swift",
        "Either/Either+MonadOperators.swift",
        "KleisliReverse.swift",
        "Loading/Loading+ApplicativeOperators.swift",
        "Loading/Loading+FunctorOperators.swift",
        "Loading/Loading+MonadOperators.swift",
        "NonEmpty/NonEmpty+ApplicativeOperators.swift",
        "NonEmpty/NonEmpty+ComonadOperators.swift",
        "NonEmpty/NonEmpty+FunctorOperators.swift",
        "NonEmpty/NonEmpty+MonadOperators.swift",
        "Reader/Reader+ApplicativeOperators.swift",
        "Reader/Reader+ComonadOperators.swift",
        "Reader/Reader+FunctorOperators.swift",
        "Reader/Reader+MonadOperators.swift",
        "Stateful/Stateful+ApplicativeOperators.swift",
        "Stateful/Stateful+FunctorOperators.swift",
        "Stateful/Stateful+MonadOperators.swift",
        "These/These+ApplicativeOperators.swift",
        "These/These+FunctorOperators.swift",
        "These/These+MonadOperators.swift",
        "Transformer/Generated/ArrayTEither+Operators.swift",
        "Transformer/Generated/ArrayTStateful+Operators.swift",
        "Transformer/Generated/ArrayTWriter+Operators.swift",
        "Transformer/Generated/AsyncStreamTEither+Operators.swift",
        "Transformer/Generated/AsyncStreamTStateful+Operators.swift",
        "Transformer/Generated/AsyncStreamTWriter+Operators.swift",
        "Transformer/Generated/EitherTArray+Operators.swift",
        "Transformer/Generated/EitherTNonEmpty+Operators.swift",
        "Transformer/Generated/EitherTOptional+Operators.swift",
        "Transformer/Generated/EitherTResult+Operators.swift",
        "Transformer/Generated/EitherTStateful+Operators.swift",
        "Transformer/Generated/EitherTValidation+Operators.swift",
        "Transformer/Generated/EitherTWriter+Operators.swift",
        "Transformer/Generated/NonEmptyTEither+Operators.swift",
        "Transformer/Generated/NonEmptyTOptional+Operators.swift",
        "Transformer/Generated/NonEmptyTResult+Operators.swift",
        "Transformer/Generated/OptionalTEither+Operators.swift",
        "Transformer/Generated/OptionalTNonEmpty+Operators.swift",
        "Transformer/Generated/OptionalTStateful+Operators.swift",
        "Transformer/Generated/OptionalTWriter+Operators.swift",
        "Transformer/Generated/PublisherTEither+Operators.swift",
        "Transformer/Generated/PublisherTStateful+Operators.swift",
        "Transformer/Generated/PublisherTWriter+Operators.swift",
        "Transformer/Generated/ReaderTArray+Operators.swift",
        "Transformer/Generated/ReaderTAsyncStream+Operators.swift",
        "Transformer/Generated/ReaderTEither+Operators.swift",
        "Transformer/Generated/ReaderTNonEmpty+Operators.swift",
        "Transformer/Generated/ReaderTOptional+Operators.swift",
        "Transformer/Generated/ReaderTPublisher+Operators.swift",
        "Transformer/Generated/ReaderTReader+Operators.swift",
        "Transformer/Generated/ReaderTResult+Operators.swift",
        "Transformer/Generated/ReaderTStateful+Operators.swift",
        "Transformer/Generated/ReaderTValidation+Operators.swift",
        "Transformer/Generated/ReaderTWriter+Operators.swift",
        "Transformer/Generated/ResultTStateful+Operators.swift",
        "Transformer/Generated/ResultTWriter+Operators.swift",
        "Transformer/Generated/StatefulTArray+Operators.swift",
        "Transformer/Generated/StatefulTAsyncStream+Operators.swift",
        "Transformer/Generated/StatefulTEither+Operators.swift",
        "Transformer/Generated/StatefulTNonEmpty+Operators.swift",
        "Transformer/Generated/StatefulTOptional+Operators.swift",
        "Transformer/Generated/StatefulTPublisher+Operators.swift",
        "Transformer/Generated/StatefulTReader+Operators.swift",
        "Transformer/Generated/StatefulTResult+Operators.swift",
        "Transformer/Generated/StatefulTValidation+Operators.swift",
        "Transformer/Generated/StatefulTWriter+Operators.swift",
        "Transformer/Generated/ValidationTArray+Operators.swift",
        "Transformer/Generated/ValidationTEither+Operators.swift",
        "Transformer/Generated/ValidationTNonEmpty+Operators.swift",
        "Transformer/Generated/ValidationTOptional+Operators.swift",
        "Transformer/Generated/ValidationTReader+Operators.swift",
        "Transformer/Generated/ValidationTResult+Operators.swift",
        "Transformer/Generated/ValidationTStateful+Operators.swift",
        "Transformer/Generated/ValidationTWriter+Operators.swift",
        "Transformer/Generated/WriterTArray+Operators.swift",
        "Transformer/Generated/WriterTAsyncStream+Operators.swift",
        "Transformer/Generated/WriterTEither+Operators.swift",
        "Transformer/Generated/WriterTNonEmpty+Operators.swift",
        "Transformer/Generated/WriterTOptional+Operators.swift",
        "Transformer/Generated/WriterTPublisher+Operators.swift",
        "Transformer/Generated/WriterTReader+Operators.swift",
        "Transformer/Generated/WriterTResult+Operators.swift",
        "Transformer/Generated/WriterTStateful+Operators.swift",
        "Transformer/Generated/WriterTValidation+Operators.swift",
        "Validation/Validation+AltOperators.swift",
        "Validation/Validation+ApplicativeOperators.swift",
        "Validation/Validation+FunctorOperators.swift",
        "Writer/Writer+ApplicativeOperators.swift",
        "Writer/Writer+ComonadOperators.swift",
        "Writer/Writer+FunctorOperators.swift",
        "Writer/Writer+MonadOperators.swift",
        "Zipper/Zipper+ComonadOperators.swift",
        "Zipper/Zipper+FunctorOperators.swift"
      ],
      "target_dependencies" : [
        "DataStructure",
        "CoreFPOperators"
      ],
      "type" : "library"
    },
    {
      "c99name" : "DataStructure",
      "module_type" : "SwiftTarget",
      "name" : "DataStructure",
      "path" : "Sources/DataStructure",
      "product_memberships" : [
        "FP",
        "DataStructure",
        "DataStructureOperators"
      ],
      "sources" : [
        "Either/ArrayTEither+Applicative.swift",
        "Either/ArrayTEither+Functor.swift",
        "Either/ArrayTEither+Monad.swift",
        "Either/AsyncSequenceTEither+Applicative.swift",
        "Either/AsyncSequenceTEither+Functor.swift",
        "Either/AsyncSequenceTEither+Monad.swift",
        "Either/AsyncThrowingStream+Either.swift",
        "Either/Completion+Either.swift",
        "Either/Either+Applicative.swift",
        "Either/Either+Bifoldable.swift",
        "Either/Either+BitraverseArray.swift",
        "Either/Either+BitraverseOptional.swift",
        "Either/Either+BitraverseResult.swift",
        "Either/Either+Foldable.swift",
        "Either/Either+Functor.swift",
        "Either/Either+Inverted.swift",
        "Either/Either+Monad.swift",
        "Either/Either+Prism.swift",
        "Either/Either+Result.swift",
        "Either/Either.swift",
        "Either/EitherTArray+Applicative.swift",
        "Either/EitherTArray+Functor.swift",
        "Either/EitherTArray+Traversable.swift",
        "Either/EitherTArray+TraversableFree.swift",
        "Either/EitherTNonEmpty+Applicative.swift",
        "Either/EitherTNonEmpty+Functor.swift",
        "Either/EitherTOptional+Applicative.swift",
        "Either/EitherTOptional+Functor.swift",
        "Either/EitherTOptional+Monad.swift",
        "Either/EitherTOptional+Traversable.swift",
        "Either/EitherTOptional+TraversableFree.swift",
        "Either/EitherTResult+Applicative.swift",
        "Either/EitherTResult+Functor.swift",
        "Either/EitherTResult+Monad.swift",
        "Either/EitherTResult+Traversable.swift",
        "Either/EitherTResult+TraversableFree.swift",
        "Either/EitherTStateful+Applicative.swift",
        "Either/EitherTStateful+Functor.swift",
        "Either/EitherTValidation+Applicative.swift",
        "Either/EitherTValidation+Functor.swift",
        "Either/EitherTWriter+Applicative.swift",
        "Either/EitherTWriter+Functor.swift",
        "Either/EitherTWriter+Monad.swift",
        "Either/OptionalTEither+Applicative.swift",
        "Either/OptionalTEither+Functor.swift",
        "Either/OptionalTEither+Monad.swift",
        "Either/PublisherTEither+Applicative.swift",
        "Either/PublisherTEither+Functor.swift",
        "Either/PublisherTEither+Monad.swift",
        "Either/ResultTEither+Traversable.swift",
        "Either/ResultTEither+TraversableFree.swift",
        "Gen/Gen+Combinators.swift",
        "Gen/Gen+Primitives.swift",
        "Gen/Gen.swift",
        "IdentifiedArray/IdentifiedArray+Collection.swift",
        "IdentifiedArray/IdentifiedArray+Optics.swift",
        "IdentifiedArray/IdentifiedArray+Semigroup.swift",
        "IdentifiedArray/IdentifiedArray.swift",
        "Loading/Loading+Applicative.swift",
        "Loading/Loading+Catch.swift",
        "Loading/Loading+Functor.swift",
        "Loading/Loading+Monad.swift",
        "Loading/Loading+Prisms.swift",
        "Loading/Loading+Result.swift",
        "Loading/Loading.swift",
        "Newtype/Newtype+Collection.swift",
        "Newtype/Newtype+Iso.swift",
        "Newtype/Newtype+Literals.swift",
        "Newtype/Newtype+Numeric.swift",
        "Newtype/Newtype+NumericMonoid.swift",
        "Newtype/Newtype+Semigroup.swift",
        "Newtype/Newtype.swift",
        "NonEmpty/NonEmpty+Applicative.swift",
        "NonEmpty/NonEmpty+Comonad.swift",
        "NonEmpty/NonEmpty+Foldable.swift",
        "NonEmpty/NonEmpty+Functor.swift",
        "NonEmpty/NonEmpty+Monad.swift",
        "NonEmpty/NonEmpty+Primitives.swift",
        "NonEmpty/NonEmpty+Semigroup.swift",
        "NonEmpty/NonEmpty+Traversable.swift",
        "NonEmpty/NonEmpty.swift",
        "NonEmpty/NonEmptyTEither+Applicative.swift",
        "NonEmpty/NonEmptyTEither+Functor.swift",
        "NonEmpty/NonEmptyTEither+Monad.swift",
        "NonEmpty/NonEmptyTOptional+Applicative.swift",
        "NonEmpty/NonEmptyTOptional+Functor.swift",
        "NonEmpty/NonEmptyTOptional+Monad.swift",
        "NonEmpty/NonEmptyTResult+Applicative.swift",
        "NonEmpty/NonEmptyTResult+Functor.swift",
        "NonEmpty/NonEmptyTResult+Monad.swift",
        "NonEmpty/OptionalTNonEmpty+Applicative.swift",
        "NonEmpty/OptionalTNonEmpty+Functor.swift",
        "NonEmpty/OptionalTNonEmpty+Monad.swift",
        "Reader/Reader+Applicative.swift",
        "Reader/Reader+Comonad.swift",
        "Reader/Reader+Functor.swift",
        "Reader/Reader+Monad.swift",
        "Reader/Reader+Monoid.swift",
        "Reader/Reader.swift",
        "Reader/ReaderTArray+Applicative.swift",
        "Reader/ReaderTArray+Functor.swift",
        "Reader/ReaderTArray+Monad.swift",
        "Reader/ReaderTAsyncSequence+Applicative.swift",
        "Reader/ReaderTAsyncSequence+Functor.swift",
        "Reader/ReaderTAsyncSequence+Monad.swift",
        "Reader/ReaderTEither+Applicative.swift",
        "Reader/ReaderTEither+Functor.swift",
        "Reader/ReaderTEither+Monad.swift",
        "Reader/ReaderTNonEmpty+Applicative.swift",
        "Reader/ReaderTNonEmpty+Functor.swift",
        "Reader/ReaderTNonEmpty+Monad.swift",
        "Reader/ReaderTOptional+Applicative.swift",
        "Reader/ReaderTOptional+Functor.swift",
        "Reader/ReaderTOptional+Monad.swift",
        "Reader/ReaderTPublisher+Applicative.swift",
        "Reader/ReaderTPublisher+Functor.swift",
        "Reader/ReaderTPublisher+Monad.swift",
        "Reader/ReaderTReader+Applicative.swift",
        "Reader/ReaderTReader+Functor.swift",
        "Reader/ReaderTReader+Monad.swift",
        "Reader/ReaderTResult+Applicative.swift",
        "Reader/ReaderTResult+Functor.swift",
        "Reader/ReaderTResult+Monad.swift",
        "Reader/ReaderTStateful+Applicative.swift",
        "Reader/ReaderTStateful+Functor.swift",
        "Reader/ReaderTStateful+Monad.swift",
        "Reader/ReaderTValidation+Applicative.swift",
        "Reader/ReaderTValidation+Functor.swift",
        "Reader/ReaderTWriter+Applicative.swift",
        "Reader/ReaderTWriter+Functor.swift",
        "Reader/ReaderTWriter+Monad.swift",
        "Stateful/ArrayTStateful+Applicative.swift",
        "Stateful/ArrayTStateful+Functor.swift",
        "Stateful/AsyncStreamTStateful+Functor.swift",
        "Stateful/OptionalTStateful+Applicative.swift",
        "Stateful/OptionalTStateful+Functor.swift",
        "Stateful/PublisherTStateful+Applicative.swift",
        "Stateful/PublisherTStateful+Functor.swift",
        "Stateful/ResultTStateful+Applicative.swift",
        "Stateful/ResultTStateful+Functor.swift",
        "Stateful/Stateful+Applicative.swift",
        "Stateful/Stateful+EndoMut.swift",
        "Stateful/Stateful+Functor.swift",
        "Stateful/Stateful+Monad.swift",
        "Stateful/Stateful+Optics.swift",
        "Stateful/Stateful+Primitives.swift",
        "Stateful/Stateful.swift",
        "Stateful/StatefulTArray+Applicative.swift",
        "Stateful/StatefulTArray+Functor.swift",
        "Stateful/StatefulTEither+Applicative.swift",
        "Stateful/StatefulTEither+Functor.swift",
        "Stateful/StatefulTEither+Monad.swift",
        "Stateful/StatefulTNonEmpty+Applicative.swift",
        "Stateful/StatefulTNonEmpty+Functor.swift",
        "Stateful/StatefulTOptional+Applicative.swift",
        "Stateful/StatefulTOptional+Functor.swift",
        "Stateful/StatefulTOptional+Monad.swift",
        "Stateful/StatefulTPublisher+Applicative.swift",
        "Stateful/StatefulTPublisher+Functor.swift",
        "Stateful/StatefulTReader+Applicative.swift",
        "Stateful/StatefulTReader+Functor.swift",
        "Stateful/StatefulTResult+Applicative.swift",
        "Stateful/StatefulTResult+Functor.swift",
        "Stateful/StatefulTResult+Monad.swift",
        "Stateful/StatefulTValidation+Applicative.swift",
        "Stateful/StatefulTValidation+Functor.swift",
        "Stateful/StatefulTWriter+Applicative.swift",
        "Stateful/StatefulTWriter+Functor.swift",
        "Stateful/StatefulTWriter+Monad.swift",
        "These/These+Applicative.swift",
        "These/These+Either.swift",
        "These/These+Functor.swift",
        "These/These+Monad.swift",
        "These/These.swift",
        "Transformer/Generated/ArrayTEither.swift",
        "Transformer/Generated/ArrayTStateful.swift",
        "Transformer/Generated/ArrayTWriter.swift",
        "Transformer/Generated/AsyncStreamTEither.swift",
        "Transformer/Generated/AsyncStreamTStateful.swift",
        "Transformer/Generated/AsyncStreamTWriter.swift",
        "Transformer/Generated/EitherTArray.swift",
        "Transformer/Generated/EitherTNonEmpty.swift",
        "Transformer/Generated/EitherTOptional.swift",
        "Transformer/Generated/EitherTResult.swift",
        "Transformer/Generated/EitherTStateful.swift",
        "Transformer/Generated/EitherTValidation.swift",
        "Transformer/Generated/EitherTWriter.swift",
        "Transformer/Generated/NonEmptyTEither.swift",
        "Transformer/Generated/NonEmptyTOptional.swift",
        "Transformer/Generated/NonEmptyTResult.swift",
        "Transformer/Generated/OptionalTEither.swift",
        "Transformer/Generated/OptionalTNonEmpty.swift",
        "Transformer/Generated/OptionalTStateful.swift",
        "Transformer/Generated/OptionalTWriter.swift",
        "Transformer/Generated/PublisherTEither.swift",
        "Transformer/Generated/PublisherTStateful.swift",
        "Transformer/Generated/PublisherTWriter.swift",
        "Transformer/Generated/ReaderTArray.swift",
        "Transformer/Generated/ReaderTAsyncStream.swift",
        "Transformer/Generated/ReaderTEither.swift",
        "Transformer/Generated/ReaderTNonEmpty.swift",
        "Transformer/Generated/ReaderTOptional.swift",
        "Transformer/Generated/ReaderTPublisher.swift",
        "Transformer/Generated/ReaderTReader.swift",
        "Transformer/Generated/ReaderTResult.swift",
        "Transformer/Generated/ReaderTStateful.swift",
        "Transformer/Generated/ReaderTValidation.swift",
        "Transformer/Generated/ReaderTWriter.swift",
        "Transformer/Generated/ResultTStateful.swift",
        "Transformer/Generated/ResultTWriter.swift",
        "Transformer/Generated/StatefulTArray.swift",
        "Transformer/Generated/StatefulTAsyncStream.swift",
        "Transformer/Generated/StatefulTEither.swift",
        "Transformer/Generated/StatefulTNonEmpty.swift",
        "Transformer/Generated/StatefulTOptional.swift",
        "Transformer/Generated/StatefulTPublisher.swift",
        "Transformer/Generated/StatefulTReader.swift",
        "Transformer/Generated/StatefulTResult.swift",
        "Transformer/Generated/StatefulTValidation.swift",
        "Transformer/Generated/StatefulTWriter.swift",
        "Transformer/Generated/ValidationTArray.swift",
        "Transformer/Generated/ValidationTEither.swift",
        "Transformer/Generated/ValidationTNonEmpty.swift",
        "Transformer/Generated/ValidationTOptional.swift",
        "Transformer/Generated/ValidationTReader.swift",
        "Transformer/Generated/ValidationTResult.swift",
        "Transformer/Generated/ValidationTStateful.swift",
        "Transformer/Generated/ValidationTWriter.swift",
        "Transformer/Generated/WriterTArray.swift",
        "Transformer/Generated/WriterTAsyncStream.swift",
        "Transformer/Generated/WriterTEither.swift",
        "Transformer/Generated/WriterTNonEmpty.swift",
        "Transformer/Generated/WriterTOptional.swift",
        "Transformer/Generated/WriterTPublisher.swift",
        "Transformer/Generated/WriterTReader.swift",
        "Transformer/Generated/WriterTResult.swift",
        "Transformer/Generated/WriterTStateful.swift",
        "Transformer/Generated/WriterTValidation.swift",
        "Transformer/InnerShape.swift",
        "Utilities/JoinVoid.swift",
        "Validation/ResultTValidation+Traversable.swift",
        "Validation/ResultTValidation+TraversableFree.swift",
        "Validation/Validation+Alt.swift",
        "Validation/Validation+Applicative.swift",
        "Validation/Validation+Bifoldable.swift",
        "Validation/Validation+BitraverseArray.swift",
        "Validation/Validation+BitraverseOptional.swift",
        "Validation/Validation+BitraverseResult.swift",
        "Validation/Validation+Either.swift",
        "Validation/Validation+Foldable.swift",
        "Validation/Validation+Functor.swift",
        "Validation/Validation+Prism.swift",
        "Validation/Validation+Result.swift",
        "Validation/Validation.swift",
        "Validation/ValidationTArray+Applicative.swift",
        "Validation/ValidationTArray+Functor.swift",
        "Validation/ValidationTArray+Traversable.swift",
        "Validation/ValidationTArray+TraversableFree.swift",
        "Validation/ValidationTEither+Applicative.swift",
        "Validation/ValidationTEither+Functor.swift",
        "Validation/ValidationTNonEmpty+Applicative.swift",
        "Validation/ValidationTNonEmpty+Functor.swift",
        "Validation/ValidationTOptional+Applicative.swift",
        "Validation/ValidationTOptional+Functor.swift",
        "Validation/ValidationTOptional+Traversable.swift",
        "Validation/ValidationTOptional+TraversableFree.swift",
        "Validation/ValidationTReader+Applicative.swift",
        "Validation/ValidationTReader+Functor.swift",
        "Validation/ValidationTResult+Applicative.swift",
        "Validation/ValidationTResult+Functor.swift",
        "Validation/ValidationTResult+Traversable.swift",
        "Validation/ValidationTResult+TraversableFree.swift",
        "Validation/ValidationTStateful+Applicative.swift",
        "Validation/ValidationTStateful+Functor.swift",
        "Validation/ValidationTWriter+Applicative.swift",
        "Validation/ValidationTWriter+Functor.swift",
        "Writer/ArrayTWriter+Applicative.swift",
        "Writer/ArrayTWriter+Functor.swift",
        "Writer/ArrayTWriter+Monad.swift",
        "Writer/AsyncStreamTWriter+Applicative.swift",
        "Writer/AsyncStreamTWriter+Functor.swift",
        "Writer/AsyncStreamTWriter+Monad.swift",
        "Writer/OptionalTWriter+Applicative.swift",
        "Writer/OptionalTWriter+Functor.swift",
        "Writer/OptionalTWriter+Monad.swift",
        "Writer/PublisherTWriter+Applicative.swift",
        "Writer/PublisherTWriter+Functor.swift",
        "Writer/PublisherTWriter+Monad.swift",
        "Writer/ResultTWriter+Applicative.swift",
        "Writer/ResultTWriter+Functor.swift",
        "Writer/ResultTWriter+Monad.swift",
        "Writer/Writer+Applicative.swift",
        "Writer/Writer+Comonad.swift",
        "Writer/Writer+Functor.swift",
        "Writer/Writer+Monad.swift",
        "Writer/Writer+Primitives.swift",
        "Writer/Writer+Semigroup.swift",
        "Writer/Writer.swift",
        "Writer/WriterTArray+Applicative.swift",
        "Writer/WriterTArray+Functor.swift",
        "Writer/WriterTArray+Traversable.swift",
        "Writer/WriterTArray+TraversableFree.swift",
        "Writer/WriterTEither+Applicative.swift",
        "Writer/WriterTEither+Functor.swift",
        "Writer/WriterTEither+Monad.swift",
        "Writer/WriterTNonEmpty+Applicative.swift",
        "Writer/WriterTNonEmpty+Functor.swift",
        "Writer/WriterTOptional+Applicative.swift",
        "Writer/WriterTOptional+Functor.swift",
        "Writer/WriterTOptional+Monad.swift",
        "Writer/WriterTOptional+Traversable.swift",
        "Writer/WriterTOptional+TraversableFree.swift",
        "Writer/WriterTPublisher+Applicative.swift",
        "Writer/WriterTPublisher+Functor.swift",
        "Writer/WriterTReader+Applicative.swift",
        "Writer/WriterTReader+Functor.swift",
        "Writer/WriterTResult+Applicative.swift",
        "Writer/WriterTResult+Functor.swift",
        "Writer/WriterTResult+Monad.swift",
        "Writer/WriterTResult+Traversable.swift",
        "Writer/WriterTResult+TraversableFree.swift",
        "Writer/WriterTStateful+Applicative.swift",
        "Writer/WriterTStateful+Functor.swift",
        "Writer/WriterTValidation+Applicative.swift",
        "Writer/WriterTValidation+Functor.swift",
        "Zipper/Zipper+Comonad.swift",
        "Zipper/Zipper+Functor.swift",
        "Zipper/Zipper+Navigation.swift",
        "Zipper/Zipper+NonEmpty.swift",
        "Zipper/Zipper.swift"
      ],
      "target_dependencies" : [
        "CoreFP"
      ],
      "type" : "library"
    },
    {
      "c99name" : "CoreFPTests",
      "module_type" : "SwiftTarget",
      "name" : "CoreFPTests",
      "path" : "Tests/CoreFPTests",
      "sources" : [
        "AffineFocusTests.swift",
        "Array+ApplicativeTests.swift",
        "Array+CartesianTests.swift",
        "Array+FoldableTests.swift",
        "Array+FunctorTests.swift",
        "Array+MonadTests.swift",
        "ArrayOptionalResultTransformerTests.swift",
        "ArrayTApLawTests.swift",
        "AsyncSequenceTests.swift",
        "AsyncSequenceTransformerTests.swift",
        "AsyncStreamConcatSemanticsTests.swift",
        "AsyncStreamTestSupport.swift",
        "AsyncStreamTransformerConcatTests.swift",
        "AsyncThrowingStreamResultTests.swift",
        "BasicFreeFunctionsTests.swift",
        "Bool+MonoidTests.swift",
        "BoolOperationsTests.swift",
        "CastAndMutableTests.swift",
        "Collection+AffineTraversalTests.swift",
        "Collection+IdentifiedSubscriptTests.swift",
        "Comparable+ClampTests.swift",
        "ComparableMonoidTests.swift",
        "CompletionResultTests.swift",
        "CoreFPStackLawTests.swift",
        "EndoMutTests.swift",
        "EndoTests.swift",
        "FPTests.swift",
        "FanoutTests.swift",
        "Function+ApplicativeTests.swift",
        "IsoTests.swift",
        "KleisliTTests.swift",
        "MonadUtilitiesTests.swift",
        "MonoidConformanceTests.swift",
        "NumericMonoidTests.swift",
        "NumericOperationsTests.swift",
        "OpticsTests.swift",
        "Optional+ApplicativeTests.swift",
        "Optional+FoldableTests.swift",
        "Optional+PrismTests.swift",
        "Optional+SemigroupTests.swift",
        "OptionalTResultApLawTests.swift",
        "PerformanceRegressionTests.swift",
        "PrismFocusTests.swift",
        "PublisherConcatLawTests.swift",
        "PublisherTests.swift",
        "PublisherTransformerTests.swift",
        "Result+ApplicativeTests.swift",
        "Result+FoldableTests.swift",
        "Result+PrismTests.swift",
        "Result+SemigroupTests.swift",
        "ResultTraversableTests.swift",
        "SIMDMonoidTests.swift",
        "SemigroupConformanceTests.swift",
        "TransformerStackSmokeTests.swift",
        "TraversableTests.swift",
        "TraversalFoldTests.swift",
        "TraversalTests.swift",
        "WritableFocusTests.swift",
        "ZeroCopyTests.swift"
      ],
      "target_dependencies" : [
        "CoreFP"
      ],
      "type" : "test"
    },
    {
      "c99name" : "CoreFPOperatorsTests",
      "module_type" : "SwiftTarget",
      "name" : "CoreFPOperatorsTests",
      "path" : "Tests/CoreFPOperatorsTests",
      "sources" : [
        "Array+OperatorsTests.swift",
        "ArrayTApLawOperatorsTests.swift",
        "ArrayTOptionalTests.swift",
        "ArrayTResultTests.swift",
        "AsyncSequenceOperatorsTests.swift",
        "AsyncStreamConcatOperatorsTests.swift",
        "AsyncStreamTestSupport.swift",
        "CombineOperatorsTests.swift",
        "ComparableMonoidOperatorsTests.swift",
        "EndoMutOperatorsTests.swift",
        "EndoOperatorsTests.swift",
        "Function+ApplicativeOperatorsTests.swift",
        "Function+FunctorOperatorsTests.swift",
        "Function+MonadOperatorsTests.swift",
        "FunctionCompositionTests.swift",
        "IsoCompositionTests.swift",
        "KleisliChainOperatorsTests.swift",
        "NumericOperatorsTests.swift",
        "OperatorsTests.swift",
        "OpticsCompositionMatrixTests.swift",
        "OpticsCompositionTests.swift",
        "Optional+ApplicativeOperatorsTests.swift",
        "Optional+FunctorOperatorsTests.swift",
        "Optional+MonadOperatorsTests.swift",
        "OptionalTArrayTests.swift",
        "OptionalTResultTests.swift",
        "PrecedenceOrderTests.swift",
        "PublisherConcatOperatorsTests.swift",
        "Result+ApplicativeOperatorsTests.swift",
        "Result+FunctorOperatorsTests.swift",
        "Result+MonadOperatorsTests.swift",
        "SemigroupTests.swift",
        "TransformerStackOperatorSmokeTests.swift",
        "ZeroCopyOperatorsTests.swift"
      ],
      "target_dependencies" : [
        "CoreFPOperators",
        "CoreFP"
      ],
      "type" : "test"
    },
    {
      "c99name" : "CoreFPOperators",
      "module_type" : "SwiftTarget",
      "name" : "CoreFPOperators",
      "path" : "Sources/CoreFPOperators",
      "product_memberships" : [
        "FP",
        "CoreFPOperators",
        "DataStructureOperators"
      ],
      "sources" : [
        "Array/Array+AlternativeOperators.swift",
        "Array/Array+ApplicativeOperators.swift",
        "Array/Array+FunctorOperators.swift",
        "Array/Array+MonadOperators.swift",
        "Combine/Publisher+AlternativeOperators.swift",
        "Combine/Publisher+ApplicativeOperators.swift",
        "Combine/Publisher+FunctorOperators.swift",
        "Combine/Publisher+MonadOperators.swift",
        "Function/Function+ApplicativeOperators.swift",
        "Function/Function+FunctorOperators.swift",
        "Function/Function+MonadOperators.swift",
        "Function/FunctionComposition.swift",
        "Function/KleisliReverse.swift",
        "ModernConcurrency/AsyncSequence+ApplicativeOperators.swift",
        "ModernConcurrency/AsyncSequence+FunctorOperators.swift",
        "ModernConcurrency/AsyncSequence+MonadOperators.swift",
        "Optional/Optional+ApplicativeOperators.swift",
        "Optional/Optional+FunctorOperators.swift",
        "Optional/Optional+MonadOperators.swift",
        "Result/Result+ApplicativeOperators.swift",
        "Result/Result+FunctorOperators.swift",
        "Result/Result+MonadOperators.swift",
        "Transformer/Generated/ArrayTOptional+Operators.swift",
        "Transformer/Generated/ArrayTResult+Operators.swift",
        "Transformer/Generated/AsyncStreamTArray+Operators.swift",
        "Transformer/Generated/AsyncStreamTOptional+Operators.swift",
        "Transformer/Generated/AsyncStreamTResult+Operators.swift",
        "Transformer/Generated/OptionalTArray+Operators.swift",
        "Transformer/Generated/OptionalTResult+Operators.swift",
        "Transformer/Generated/PublisherTArray+Operators.swift",
        "Transformer/Generated/PublisherTOptional+Operators.swift",
        "Transformer/Generated/PublisherTResult+Operators.swift",
        "Utilities/IsoComposition.swift",
        "Utilities/KeyPath.swift",
        "Utilities/NumericOperators.swift",
        "Utilities/Operators.swift",
        "Utilities/OpticsComposition.swift",
        "Utilities/PrecedenceGroups.swift",
        "Utilities/Semigroup.swift",
        "Utilities/TraversalComposition.swift"
      ],
      "target_dependencies" : [
        "CoreFP"
      ],
      "type" : "library"
    },
    {
      "c99name" : "CoreFP",
      "module_type" : "SwiftTarget",
      "name" : "CoreFP",
      "path" : "Sources/CoreFP",
      "product_memberships" : [
        "FP",
        "CoreFP",
        "CoreFPOperators",
        "DataStructure",
        "DataStructureOperators",
        "FPMacros"
      ],
      "sources" : [
        "Array/Array+Applicative.swift",
        "Array/Array+Cartesian.swift",
        "Array/Array+Foldable.swift",
        "Array/Array+Functor.swift",
        "Array/Array+Monad.swift",
        "Array/Array+Semigroup.swift",
        "Array/ArrayTArray+Traversable.swift",
        "Array/ArrayTOptional+Applicative.swift",
        "Array/ArrayTOptional+Functor.swift",
        "Array/ArrayTOptional+Monad.swift",
        "Array/ArrayTOptional+Traversable.swift",
        "Array/ArrayTOptional+TraversableFree.swift",
        "Array/ArrayTResult+Applicative.swift",
        "Array/ArrayTResult+Functor.swift",
        "Array/ArrayTResult+Monad.swift",
        "Array/ArrayTResult+Traversable.swift",
        "Array/ArrayTResult+TraversableFree.swift",
        "Collection/Collection+AffineTraversal.swift",
        "Collection/Collection+IdentifiedSubscript.swift",
        "Collection/Collection+SafeSubscript.swift",
        "Collection/Collection+Traversal.swift",
        "Combine/Completion+Result.swift",
        "Combine/Completion+SumType.swift",
        "Combine/Publisher+Alternative.swift",
        "Combine/Publisher+Applicative.swift",
        "Combine/Publisher+Functor.swift",
        "Combine/Publisher+Monad.swift",
        "Combine/PublisherTArray+Applicative.swift",
        "Combine/PublisherTArray+Functor.swift",
        "Combine/PublisherTOptional+Applicative.swift",
        "Combine/PublisherTOptional+Functor.swift",
        "Combine/PublisherTOptional+Monad.swift",
        "Combine/PublisherTResult+Applicative.swift",
        "Combine/PublisherTResult+Functor.swift",
        "Combine/PublisherTResult+Monad.swift",
        "Dictionary/Dictionary+Semigroup.swift",
        "Function/Function+Applicative.swift",
        "Function/Function+Functor.swift",
        "Function/Function+Monad.swift",
        "Function/FunctionWrapper.swift",
        "ModernConcurrency/AsyncSequence+Applicative.swift",
        "ModernConcurrency/AsyncSequence+Functor.swift",
        "ModernConcurrency/AsyncSequence+Monad.swift",
        "ModernConcurrency/AsyncSequenceTArray+Applicative.swift",
        "ModernConcurrency/AsyncSequenceTArray+Functor.swift",
        "ModernConcurrency/AsyncSequenceTOptional+Applicative.swift",
        "ModernConcurrency/AsyncSequenceTOptional+Functor.swift",
        "ModernConcurrency/AsyncSequenceTOptional+Monad.swift",
        "ModernConcurrency/AsyncSequenceTResult+Applicative.swift",
        "ModernConcurrency/AsyncSequenceTResult+Functor.swift",
        "ModernConcurrency/AsyncSequenceTResult+Monad.swift",
        "ModernConcurrency/AsyncStream+Replay.swift",
        "ModernConcurrency/AsyncThrowingStream+Result.swift",
        "Monoid/BoolMonoid.swift",
        "Monoid/ComparableMonoid.swift",
        "Monoid/Monoid+Utilities.swift",
        "Monoid/Monoid.swift",
        "Monoid/NumericMonoid.swift",
        "Monoid/OrderingMonoid.swift",
        "Monoid/SIMDMonoid.swift",
        "Monoid/Semigroup.swift",
        "Optional/Optional+Applicative.swift",
        "Optional/Optional+Collection.swift",
        "Optional/Optional+Foldable.swift",
        "Optional/Optional+Functor.swift",
        "Optional/Optional+Monad.swift",
        "Optional/Optional+Prism.swift",
        "Optional/Optional+Semigroup.swift",
        "Optional/Optional+SumType.swift",
        "Optional/OptionalTArray+Applicative.swift",
        "Optional/OptionalTArray+Functor.swift",
        "Optional/OptionalTArray+Monad.swift",
        "Optional/OptionalTArray+Traversable.swift",
        "Optional/OptionalTOptional+Traversable.swift",
        "Optional/OptionalTResult+Applicative.swift",
        "Optional/OptionalTResult+Functor.swift",
        "Optional/OptionalTResult+Monad.swift",
        "Optional/OptionalTResult+Traversable.swift",
        "Result/Result+Applicative.swift",
        "Result/Result+Foldable.swift",
        "Result/Result+Functor.swift",
        "Result/Result+Monad.swift",
        "Result/Result+Prism.swift",
        "Result/Result+Semigroup.swift",
        "Result/Result+SumType.swift",
        "Result/ResultTArray+Traversable.swift",
        "Result/ResultTArray+TraversableFree.swift",
        "Result/ResultTOptional+Traversable.swift",
        "Result/ResultTOptional+TraversableFree.swift",
        "Set/Set+Semigroup.swift",
        "String/String+Semigroup.swift",
        "SumType/SumType+Match.swift",
        "SumType/SumType+Never.swift",
        "SumType/SumType.swift",
        "SumType/SumTypeCopyStrategy.swift",
        "Transformer/Generated/ArrayTOptional.swift",
        "Transformer/Generated/ArrayTResult.swift",
        "Transformer/Generated/AsyncStreamTArray.swift",
        "Transformer/Generated/AsyncStreamTOptional.swift",
        "Transformer/Generated/AsyncStreamTResult.swift",
        "Transformer/Generated/OptionalTArray.swift",
        "Transformer/Generated/OptionalTResult.swift",
        "Transformer/Generated/PublisherTArray.swift",
        "Transformer/Generated/PublisherTOptional.swift",
        "Transformer/Generated/PublisherTResult.swift",
        "Transformer/InnerShape.swift",
        "Transformer/TransformerStack.swift",
        "Utilities/AffineFocus.swift",
        "Utilities/AffineTraversal.swift",
        "Utilities/BasicFreeFunctions+Composition.swift",
        "Utilities/BasicFreeFunctions.swift",
        "Utilities/Binding+Optics.swift",
        "Utilities/BoolOperations.swift",
        "Utilities/CaseMatchable.swift",
        "Utilities/Cast.swift",
        "Utilities/Comparable+Clamp.swift",
        "Utilities/Endo+Semigroup.swift",
        "Utilities/Endo.swift",
        "Utilities/EndoMut+Bridge.swift",
        "Utilities/EndoMut+Semigroup.swift",
        "Utilities/EndoMut.swift",
        "Utilities/Fanout.swift",
        "Utilities/IndexedTraversal.swift",
        "Utilities/Iso+Semigroup.swift",
        "Utilities/Iso.swift",
        "Utilities/IsoComposition.swift",
        "Utilities/JoinVoid.swift",
        "Utilities/KeyPath+Sendable.swift",
        "Utilities/Lens.swift",
        "Utilities/Mutable.swift",
        "Utilities/NumericOperations.swift",
        "Utilities/OpticsComposition.swift",
        "Utilities/Prism.swift",
        "Utilities/PrismFocus.swift",
        "Utilities/Traversal.swift",
        "Utilities/TraversalComposition.swift",
        "Utilities/Tuple.swift",
        "Utilities/WritableFocus+Binding.swift",
        "Utilities/WritableFocus.swift"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "6.3"
}
Done.