Swift Package IndexBuild Information
Failed to build swift-function-composition, reference 0.0.1 (34eb8a), with Swift 6.1 for macOS (SPM) on 3 Apr 2026 13:57:37 UTC.
Build Command
env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64Build Log
========================================
RunAll
========================================
Builder version: 4.69.2
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/capturecontext/swift-function-composition.git
Reference: 0.0.1
Initialized empty Git repository in /Users/admin/builder/spi-builder-workspace/.git/
From https://github.com/capturecontext/swift-function-composition
* tag 0.0.1 -> FETCH_HEAD
HEAD is now at 34eb8af feat(CI): Enable all traits
Cloned https://github.com/capturecontext/swift-function-composition.git
Revision (git rev-parse @):
34eb8af7150a9bfb2967da255bacd30547b723a0
SPI manifest file found: $PWD/.spi.yml
SUCCESS checkout https://github.com/capturecontext/swift-function-composition.git at 0.0.1
========================================
Build
========================================
Selected platform: macosSpm
Swift version: 6.1
Building package at path: $PWD
https://github.com/capturecontext/swift-function-composition.git
https://github.com/capturecontext/swift-function-composition.git
{
"dependencies" : [
{
"identity" : "swift-concurrency-extras",
"requirement" : {
"range" : [
{
"lower_bound" : "1.3.2",
"upper_bound" : "2.0.0"
}
]
},
"type" : "sourceControl",
"url" : "https://github.com/pointfreeco/swift-concurrency-extras.git"
}
],
"manifest_display_name" : "swift-function-composition",
"name" : "swift-function-composition",
"path" : "/Users/admin/builder/spi-builder-workspace",
"platforms" : [
{
"name" : "ios",
"version" : "13.0"
},
{
"name" : "macos",
"version" : "10.15"
},
{
"name" : "tvos",
"version" : "13.0"
},
{
"name" : "watchos",
"version" : "6.0"
},
{
"name" : "maccatalyst",
"version" : "13.0"
},
{
"name" : "visionos",
"version" : "1.0"
}
],
"products" : [
{
"name" : "FunctionComposition",
"targets" : [
"FunctionComposition"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "Either",
"targets" : [
"Either"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "_Currying",
"targets" : [
"_Currying"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "NominalFunctionTypes",
"targets" : [
"NominalFunctionTypes"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "NominalFunctionTypesComposition",
"targets" : [
"NominalFunctionTypesComposition"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "NominalFunctionTypesCompositionFunctions",
"targets" : [
"NominalFunctionTypesCompositionFunctions"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "NominalFunctionTypesCompositionMethods",
"targets" : [
"NominalFunctionTypesCompositionMethods"
],
"type" : {
"library" : [
"automatic"
]
}
},
{
"name" : "NominalFunctionTypesCompositionOperators",
"targets" : [
"NominalFunctionTypesCompositionOperators"
],
"type" : {
"library" : [
"automatic"
]
}
}
],
"swift_languages_versions" : [
"6"
],
"targets" : [
{
"c99name" : "_Currying",
"module_type" : "SwiftTarget",
"name" : "_Currying",
"path" : "Sources/FreeFunctions/Curry",
"product_memberships" : [
"FunctionComposition",
"_Currying",
"NominalFunctionTypesComposition"
],
"sources" : [
"Curry.swift",
"Flip.swift",
"Uncurry.swift"
],
"type" : "library"
},
{
"c99name" : "NominalFunctionTypesCompositionOperatorsTests",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionOperatorsTests",
"path" : "Tests/NominalFunctionTypesCompositionTests/Operators",
"sources" : [
"ComposeTests.swift",
"Helpers.swift",
"PipeTests.swift"
],
"target_dependencies" : [
"NominalFunctionTypesCompositionOperators"
],
"type" : "test"
},
{
"c99name" : "NominalFunctionTypesCompositionOperators",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionOperators",
"path" : "Sources/NominalFunctionTypesComposition/Operators",
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionOperators"
],
"sources" : [
"Apply.swift",
"Compose+MainActor.swift",
"Compose+Sendable.swift",
"Compose.swift",
"Exports.swift",
"Pipe+MainActor.swift",
"Pipe+Sendable.swift",
"Pipe.swift"
],
"target_dependencies" : [
"NominalFunctionTypes",
"FunctionCompositionOperators"
],
"type" : "library"
},
{
"c99name" : "NominalFunctionTypesCompositionMethodsTests",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionMethodsTests",
"path" : "Tests/NominalFunctionTypesCompositionTests/Methods",
"sources" : [
"ComposeTests.swift",
"Helpers.swift",
"PipeTests.swift"
],
"target_dependencies" : [
"NominalFunctionTypesCompositionMethods"
],
"type" : "test"
},
{
"c99name" : "NominalFunctionTypesCompositionMethods",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionMethods",
"path" : "Sources/NominalFunctionTypesComposition/Methods",
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionMethods"
],
"sources" : [
"Compose+MainActor.swift",
"Compose+Sendable.swift",
"Compose.swift",
"Pipe+MainActor.swift",
"Pipe+Sendable.swift",
"Pipe.swift"
],
"target_dependencies" : [
"NominalFunctionTypes"
],
"type" : "library"
},
{
"c99name" : "NominalFunctionTypesCompositionFunctionsTests",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionFunctionsTests",
"path" : "Tests/NominalFunctionTypesCompositionTests/Functions",
"sources" : [
"ComposeTests.swift",
"Helpers.swift",
"PipeTests.swift"
],
"target_dependencies" : [
"NominalFunctionTypesCompositionFunctions"
],
"type" : "test"
},
{
"c99name" : "NominalFunctionTypesCompositionFunctions",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesCompositionFunctions",
"path" : "Sources/NominalFunctionTypesComposition/Functions",
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionFunctions"
],
"sources" : [
"Compose+MainActor.swift",
"Compose+Sendable.swift",
"Compose.swift",
"Pipe+MainActor.swift",
"Pipe+Sendable.swift",
"Pipe.swift"
],
"target_dependencies" : [
"NominalFunctionTypes"
],
"type" : "library"
},
{
"c99name" : "NominalFunctionTypesComposition",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypesComposition",
"path" : "Sources/NominalFunctionTypesComposition/Sources",
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypesComposition"
],
"sources" : [
"Exports.swift"
],
"target_dependencies" : [
"NominalFunctionTypes",
"NominalFunctionTypesCompositionFunctions",
"NominalFunctionTypesCompositionMethods",
"NominalFunctionTypesCompositionOperators",
"_Currying"
],
"type" : "library"
},
{
"c99name" : "NominalFunctionTypes",
"module_type" : "SwiftTarget",
"name" : "NominalFunctionTypes",
"path" : "Sources/NominalFunctionTypes",
"product_dependencies" : [
"ConcurrencyExtras"
],
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypes",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionFunctions",
"NominalFunctionTypesCompositionMethods",
"NominalFunctionTypesCompositionOperators"
],
"sources" : [
"Async/AsyncFunc.swift",
"Async/MainActorAsyncFunc.swift",
"Async/SendableAsyncFunc.swift",
"AsyncThrowing/AsyncThrowingFunc.swift",
"AsyncThrowing/MainActorAsyncThrowingFunc.swift",
"AsyncThrowing/SendableAsyncThrowingFunc.swift",
"Exports.swift",
"Sync/MainActorSyncFunc.swift",
"Sync/SendableSyncFunc.swift",
"Sync/SyncFunc.swift",
"SyncThrowing/MainActorSyncThrowingFunc.swift",
"SyncThrowing/SendableSyncThrowingFunc.swift",
"SyncThrowing/SyncThrowingFunc.swift",
"_AnyNominalFunctionType.swift",
"_MainActorMarkers.swift"
],
"target_dependencies" : [
"Either"
],
"type" : "library"
},
{
"c99name" : "FunctionCompositionOperators",
"module_type" : "SwiftTarget",
"name" : "FunctionCompositionOperators",
"path" : "Sources/FunctionCompositionOperators",
"product_memberships" : [
"FunctionComposition",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionOperators"
],
"sources" : [
"Operators.swift",
"PrecedenceGroups.swift"
],
"type" : "library"
},
{
"c99name" : "FunctionComposition",
"module_type" : "SwiftTarget",
"name" : "FunctionComposition",
"path" : "Sources/FunctionComposition",
"product_memberships" : [
"FunctionComposition"
],
"sources" : [
"Exports.swift"
],
"target_dependencies" : [
"NominalFunctionTypesComposition",
"_Currying"
],
"type" : "library"
},
{
"c99name" : "Either",
"module_type" : "SwiftTarget",
"name" : "Either",
"path" : "Sources/Monads/Either",
"product_memberships" : [
"FunctionComposition",
"Either",
"NominalFunctionTypes",
"NominalFunctionTypesComposition",
"NominalFunctionTypesCompositionFunctions",
"NominalFunctionTypesCompositionMethods",
"NominalFunctionTypesCompositionOperators"
],
"sources" : [
"Either.swift"
],
"type" : "library"
}
],
"tools_version" : "6.1"
}
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats
Building for debugging...
[0/11] Write sources
[10/11] Write swift-version-2F0A5646E1D333AE.txt
[12/31] Compiling _Currying Uncurry.swift
[13/31] Compiling Either Either.swift
[14/31] Emitting module Either
[15/31] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[16/31] Emitting module FunctionCompositionOperators
[17/31] Compiling FunctionCompositionOperators Operators.swift
[18/31] Emitting module _Currying
[19/31] Compiling _Currying Curry.swift
[20/31] Compiling _Currying Flip.swift
[21/31] Compiling ConcurrencyExtras Task.swift
[22/31] Compiling ConcurrencyExtras Result.swift
[23/31] Emitting module ConcurrencyExtras
[24/31] Compiling ConcurrencyExtras LockIsolated.swift
[25/31] Compiling ConcurrencyExtras UncheckedBox.swift
[26/31] Compiling ConcurrencyExtras Locking.swift
[27/31] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[28/31] Compiling ConcurrencyExtras AsyncStream.swift
[29/31] Compiling ConcurrencyExtras ActorIsolated.swift
[30/31] Compiling ConcurrencyExtras AnyHashableSendable.swift
[31/31] Compiling ConcurrencyExtras MainSerialExecutor.swift
[32/32] Compiling ConcurrencyExtras UncheckedSendable.swift
[33/47] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
[34/47] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
[35/47] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[36/48] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
[37/48] Compiling NominalFunctionTypes SendableSyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[38/48] Compiling NominalFunctionTypes SyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
error: emit-module command failed with exit code 1 (use -v to see invocation)
[39/48] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[40/48] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[41/48] Emitting module NominalFunctionTypes
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[42/48] Compiling NominalFunctionTypes AsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[43/48] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[44/48] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[45/48] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[46/48] Compiling NominalFunctionTypes Exports.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[47/48] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[48/48] Compiling NominalFunctionTypes _MainActorMarkers.swift
Fetching https://github.com/pointfreeco/swift-concurrency-extras.git from cache
Fetched https://github.com/pointfreeco/swift-concurrency-extras.git from cache (0.59s)
Computing version for https://github.com/pointfreeco/swift-concurrency-extras.git
Computed https://github.com/pointfreeco/swift-concurrency-extras.git at 1.3.2 (1.08s)
Creating working copy for https://github.com/pointfreeco/swift-concurrency-extras.git
Working copy of https://github.com/pointfreeco/swift-concurrency-extras.git resolved at 1.3.2
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64
[0/1] Planning build
Building for debugging...
[0/1] Write swift-version-2F0A5646E1D333AE.txt
[2/21] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[3/21] Compiling FunctionCompositionOperators Operators.swift
[4/21] Emitting module FunctionCompositionOperators
[5/21] Compiling Either Either.swift
[6/21] Emitting module Either
[7/21] Emitting module _Currying
[8/21] Compiling _Currying Curry.swift
[9/21] Compiling _Currying Flip.swift
[10/21] Compiling _Currying Uncurry.swift
[11/21] Compiling ConcurrencyExtras Result.swift
[12/21] Compiling ConcurrencyExtras UncheckedBox.swift
[13/21] Compiling ConcurrencyExtras MainSerialExecutor.swift
[14/21] Compiling ConcurrencyExtras LockIsolated.swift
[15/21] Compiling ConcurrencyExtras Locking.swift
[16/21] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[17/21] Compiling ConcurrencyExtras AsyncStream.swift
[18/21] Compiling ConcurrencyExtras Task.swift
[19/21] Compiling ConcurrencyExtras ActorIsolated.swift
[20/21] Compiling ConcurrencyExtras AnyHashableSendable.swift
[21/22] Emitting module ConcurrencyExtras
[22/22] Compiling ConcurrencyExtras UncheckedSendable.swift
[23/37] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
[24/37] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[25/37] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
[26/38] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
[27/38] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[28/38] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[29/38] Compiling NominalFunctionTypes AsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[30/38] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[31/38] Compiling NominalFunctionTypes Exports.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[32/38] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[33/38] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[34/38] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[35/38] Compiling NominalFunctionTypes SendableSyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[36/38] Compiling NominalFunctionTypes SyncFunc.swift
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
error: emit-module command failed with exit code 1 (use -v to see invocation)
[37/38] Emitting module NominalFunctionTypes
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[38/38] Compiling NominalFunctionTypes _MainActorMarkers.swift
BUILD FAILURE 6.1 macosSpm