Swift Package IndexBuild Information
Failed to build swift-function-composition, reference main (7ce362), with Swift 6.1 for Wasm on 4 Sep 2026 04:29:09 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-53886769-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1Build Log
========================================
RunAll
========================================
Builder version: 5.0.2
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/capturecontext/swift-function-composition.git
Reference: main
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/capturecontext/swift-function-composition
* branch main -> FETCH_HEAD
* [new branch] main -> origin/main
HEAD is now at 7ce3628 ci: update shared actions
Cloned https://github.com/capturecontext/swift-function-composition.git
Revision (git rev-parse @):
7ce3628c42a02b2bfe9fe04406dfc4e83b6ea790
SPI manifest file found: $PWD/.spi.yml
SUCCESS checkout https://github.com/capturecontext/swift-function-composition.git at main
========================================
Build
========================================
Selected platform: wasm
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
WARNING: environment variable SUPPRESS_SWIFT_6_FLAGS is not set
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-53886769-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1
wasm-6.1-latest: Pulling from saguaro1/spi-images
Digest: sha256:290f441d1f5b7bf0dbbe61e8b7514208804cdcb507d57b3c762463ad036298f7
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:wasm-6.1-latest
Fetching https://github.com/pointfreeco/swift-concurrency-extras.git
[1/1058] Fetching swift-concurrency-extras
Fetched https://github.com/pointfreeco/swift-concurrency-extras.git from cache (0.49s)
Computing version for https://github.com/pointfreeco/swift-concurrency-extras.git
Computed https://github.com/pointfreeco/swift-concurrency-extras.git at 1.4.1 (0.71s)
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.4.1
Building for debugging...
[0/12] Write sources
[11/12] Write swift-version-24593BA9C3E375BF.txt
[13/36] Emitting module Either
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[14/36] Compiling Either Either.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[15/37] Compiling _Currying Curry.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[16/37] Emitting module _Currying
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[17/37] Compiling _Currying Uncurry.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[18/37] Compiling ConcurrencyExtras ActorIsolated.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[19/37] Compiling ConcurrencyExtras AnyHashableSendable.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[20/37] Emitting module ConcurrencyExtras
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[22/38] Compiling ConcurrencyExtras MainSerialExecutor.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[23/38] Compiling _Currying Flip.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[24/39] Compiling ConcurrencyExtras UncheckedSendable.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[26/39] Compiling _Tuples Unpack.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[27/39] Compiling _Tuples Scope.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[28/39] Emitting module _Tuples
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[29/39] Compiling _Tuples Pack.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[31/40] Emitting module FunctionCompositionOperators
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[32/40] Compiling FunctionCompositionOperators PrecedenceGroups.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[33/40] Compiling FunctionCompositionOperators Operators.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[35/41] Compiling ConcurrencyExtras LockIsolated.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[36/41] Compiling ConcurrencyExtras Locking.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[37/41] Compiling ConcurrencyExtras UncheckedBox.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[38/41] Compiling ConcurrencyExtras Result.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[39/41] Compiling ConcurrencyExtras Task.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[40/41] Compiling ConcurrencyExtras AsyncStream.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[41/41] Compiling ConcurrencyExtras AsyncThrowingStream.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[43/57] Compiling NominalFunctionTypes SyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
[44/57] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
[45/58] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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/58] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
[47/58] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
[48/58] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
[49/58] Compiling NominalFunctionTypes SendableAsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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 | }
/host/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 | }
[50/58] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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 | }
/host/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 | }
[51/58] Compiling NominalFunctionTypes AsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
[52/58] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
[53/58] Compiling NominalFunctionTypes Exports.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
[54/58] Compiling NominalFunctionTypes MainActorSyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
[55/58] Compiling NominalFunctionTypes SendableSyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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 | }
[56/58] Compiling NominalFunctionTypes SyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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)
[57/58] Emitting module NominalFunctionTypes
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
[58/58] Compiling NominalFunctionTypes _MainActorMarkers.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-53886769-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.1-latest swift build --swift-sdk wasm32-unknown-wasi 2>&1
wasm-6.1-latest: Pulling from saguaro1/spi-images
Digest: sha256:290f441d1f5b7bf0dbbe61e8b7514208804cdcb507d57b3c762463ad036298f7
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:wasm-6.1-latest
[0/1] Planning build
Building for debugging...
[0/1] Write swift-version-24593BA9C3E375BF.txt
[2/25] Emitting module Either
[3/25] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[4/25] Compiling FunctionCompositionOperators Operators.swift
[5/25] Emitting module FunctionCompositionOperators
[6/26] Compiling Either Either.swift
[7/26] Emitting module _Currying
[8/27] Compiling _Currying Uncurry.swift
[10/27] Emitting module _Tuples
[11/27] Compiling _Tuples Pack.swift
[13/27] Compiling ConcurrencyExtras MainSerialExecutor.swift
[14/27] Compiling ConcurrencyExtras LockIsolated.swift
[15/28] Compiling ConcurrencyExtras Locking.swift
[16/28] Compiling ConcurrencyExtras UncheckedBox.swift
[17/28] Compiling _Tuples Unpack.swift
[18/28] Compiling _Currying Curry.swift
[19/28] Compiling _Currying Flip.swift
[20/29] Compiling ConcurrencyExtras Task.swift
[21/29] Compiling ConcurrencyExtras Result.swift
[22/29] Compiling ConcurrencyExtras AsyncStream.swift
[23/29] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[24/29] Compiling ConcurrencyExtras ActorIsolated.swift
[25/29] Compiling ConcurrencyExtras AnyHashableSendable.swift
[26/29] Emitting module ConcurrencyExtras
[28/29] Compiling ConcurrencyExtras UncheckedSendable.swift
[29/30] Compiling _Tuples Scope.swift
[32/46] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/host/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 | }
[33/46] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
/host/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 | }
[34/47] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/host/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 | }
/host/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 | }
/host/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/47] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/host/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 | }
/host/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 | }
/host/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 | }
[36/47] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
[37/47] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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/47] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
[39/47] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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/47] Compiling NominalFunctionTypes SendableSyncFunc.swift
/host/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 | }
/host/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 | }
[41/47] Compiling NominalFunctionTypes SyncFunc.swift
/host/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 | }
/host/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 | }
[42/47] Compiling NominalFunctionTypes Exports.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
[43/47] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
error: emit-module command failed with exit code 1 (use -v to see invocation)
[44/47] Emitting module NominalFunctionTypes
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 |
/host/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 | }
/host/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 | }
/host/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 | }
[45/47] Compiling NominalFunctionTypes AsyncFunc.swift
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
[46/47] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/host/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 | }
/host/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 | }
/host/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
/host/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 | }
/host/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 | }
/host/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 | }
/host/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 | }
[47/47] Compiling NominalFunctionTypes _MainActorMarkers.swift
BUILD FAILURE 6.1 wasm