Swift Package IndexBuild Information
Failed to build swift-function-composition, reference main (a93ac2), with Swift 6.0 for Linux on 18 Apr 2026 02:16:16 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
========================================
RunAll
========================================
Builder version: 4.70.0
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 a93ac22 feat: Remove redundant export
Cloned https://github.com/capturecontext/swift-function-composition.git
Revision (git rev-parse @):
a93ac227e47764198dbdf085629c33188b0d80de
SPI manifest file found: $PWD/.spi.yml
SUCCESS checkout https://github.com/capturecontext/swift-function-composition.git at main
========================================
Build
========================================
Selected platform: linux
Swift version: 6.0
Building package at path: $PWD
https://github.com/capturecontext/swift-function-composition.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.0-latest: Pulling from swiftpackageindex/spi-images
Digest: sha256:6ccbc5e7995f6c524368c1828f9c677d1727c16390a603fc668217aec5f5123a
Status: Image is up to date for registry.gitlab.com/swiftpackageindex/spi-images:basic-6.0-latest
Fetching https://github.com/pointfreeco/swift-concurrency-extras.git
[1/956] Fetching swift-concurrency-extras
Fetched https://github.com/pointfreeco/swift-concurrency-extras.git from cache (0.44s)
Computing version for https://github.com/pointfreeco/swift-concurrency-extras.git
Computed https://github.com/pointfreeco/swift-concurrency-extras.git at 1.3.2 (1.14s)
Creating working copy for https://github.com/pointfreeco/swift-concurrency-extras.git
Working copy of https://github.com/pointfreeco/swift-concurrency-extras.git resolved at 1.3.2
Building for debugging...
[0/9] Write sources
[8/9] Write swift-version-24593BA9C3E375BF.txt
[10/29] Emitting module _Currying
[11/29] Compiling _Currying Curry.swift
[12/29] Compiling FunctionCompositionOperators Operators.swift
[13/29] Emitting module FunctionCompositionOperators
[14/29] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[15/30] Compiling _Currying Uncurry.swift
[16/30] Compiling Either Either.swift
[17/30] Emitting module Either
[18/30] Compiling _Currying Flip.swift
[22/32] Compiling ConcurrencyExtras ActorIsolated.swift
[23/32] Compiling ConcurrencyExtras AnyHashableSendable.swift
[24/33] Emitting module ConcurrencyExtras
[25/33] Compiling ConcurrencyExtras AsyncStream.swift
[26/33] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[27/33] Compiling ConcurrencyExtras MainSerialExecutor.swift
[28/33] Compiling ConcurrencyExtras Locking.swift
[29/33] Compiling ConcurrencyExtras UncheckedBox.swift
[30/33] Compiling ConcurrencyExtras LockIsolated.swift
[31/33] Compiling ConcurrencyExtras UncheckedSendable.swift
[32/33] Compiling ConcurrencyExtras Task.swift
[33/33] Compiling ConcurrencyExtras Result.swift
[35/49] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 | }
[36/49] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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/50] Compiling NominalFunctionTypes SendableSyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 | }
[38/50] Compiling NominalFunctionTypes SyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 | }
[39/50] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 | }
[40/50] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 | }
[41/50] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 | }
[42/50] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 | }
[43/50] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 | }
[44/50] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 | }
[45/50] Compiling NominalFunctionTypes Exports.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
28 | return call(input)
29 | }
[46/50] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
28 | return call(input)
29 | }
error: emit-module command failed with exit code 1 (use -v to see invocation)
[47/50] Emitting module NominalFunctionTypes
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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 protocol requirement
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 protocol requirement
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
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/50] Compiling NominalFunctionTypes AsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | await call(input)
30 | }
[49/50] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
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' returned by main actor-isolated instance method 'run(with:)' satisfying protocol requirement cannot cross actor boundary
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Self.Input' in parameter of the protocol requirement satisfied by main actor-isolated instance method 'run(with:)' cannot cross actor boundary
29 | await call(input)
30 | }
[50/50] Compiling NominalFunctionTypes _MainActorMarkers.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:1: error: expected an identifier to name generic parameter
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: expected an identifier to name generic parameter
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
BUILD FAILURE 6.0 linux