Swift Package Index

Build Information

Failed to build swift-function-composition, reference 0.0.1 (34eb8a), with Swift 6.0 for macOS (SPM) on 3 Apr 2026 13:54:48 UTC.

Build Command

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

Build Log

========================================
RunAll
========================================
Builder version: 4.69.2
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/capturecontext/swift-function-composition.git
Reference: 0.0.1
Initialized empty Git repository in /Users/admin/builder/spi-builder-workspace/.git/
From https://github.com/capturecontext/swift-function-composition
 * tag               0.0.1      -> FETCH_HEAD
HEAD is now at 34eb8af feat(CI): Enable all traits
Cloned https://github.com/capturecontext/swift-function-composition.git
Revision (git rev-parse @):
34eb8af7150a9bfb2967da255bacd30547b723a0
SPI manifest file found: $PWD/.spi.yml
SUCCESS checkout https://github.com/capturecontext/swift-function-composition.git at 0.0.1
========================================
Build
========================================
Selected platform:         macosSpm
Swift version:             6.0
Building package at path:  $PWD
https://github.com/capturecontext/swift-function-composition.git
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-16.2.0.app xcrun swift build --arch arm64
Building for debugging...
[0/9] Write sources
[8/9] Write swift-version-5BDAB9E9C0126B9D.txt
[10/29] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[11/29] Compiling FunctionCompositionOperators Operators.swift
[12/29] Emitting module FunctionCompositionOperators
[13/29] Compiling Either Either.swift
[14/29] Emitting module Either
[15/29] Compiling _Currying Uncurry.swift
[16/29] Compiling _Currying Curry.swift
[17/29] Emitting module _Currying
[18/29] Compiling _Currying Flip.swift
[19/29] Emitting module ConcurrencyExtras
[20/30] Compiling ConcurrencyExtras Result.swift
[21/30] Compiling ConcurrencyExtras MainSerialExecutor.swift
[22/30] Compiling ConcurrencyExtras Locking.swift
[23/30] Compiling ConcurrencyExtras UncheckedBox.swift
[24/30] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[25/30] Compiling ConcurrencyExtras AsyncStream.swift
[26/30] Compiling ConcurrencyExtras ActorIsolated.swift
[27/30] Compiling ConcurrencyExtras AnyHashableSendable.swift
[28/30] Compiling ConcurrencyExtras LockIsolated.swift
[29/30] Compiling ConcurrencyExtras Task.swift
[30/30] Compiling ConcurrencyExtras UncheckedSendable.swift
[31/45] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | 	@inlinable
23 | 	public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | 		self.init(f.run)
25 | 	}
[32/45] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | 	@inlinable
22 | 	public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | 		self.init(f.run)
24 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[33/45] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | 	@inlinable
22 | 	public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | 		self.init(f.run)
24 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[34/45] Compiling NominalFunctionTypes SendableSyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any SyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | 	@inlinable
21 | 	public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | 		self.init(f.run)
23 | 	}
[35/45] Compiling NominalFunctionTypes SyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any SyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | 	@inlinable
21 | 	public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | 		self.init(f.run)
23 | 	}
error: emit-module command failed with exit code 1 (use -v to see invocation)
[36/46] Emitting module NominalFunctionTypes
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | 	@inlinable
22 | 	public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | 		self.init(f.run)
24 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | 	Input,
12 | 	Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
   |                             `- error: unknown attribute 'MainActor'
14 | 	@usableFromInline
15 | 	internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | 	@inlinable
25 | 	public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | 		self.init(f.run)
27 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | 	Output,
15 | 	Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
   |                                     `- error: unknown attribute 'MainActor'
17 | 	@usableFromInline
18 | 	internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | 	@inlinable
21 | 	public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | 		self.init(f.run)
23 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | 	Input,
11 | 	Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
   |                            `- error: unknown attribute 'MainActor'
13 | 	@usableFromInline
14 | 	internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 5 | 	Output
 6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
 7 | 	func run(with input: Input) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 8 | }
 9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 6 | 	Failure
 7 | >: AsyncThrowingFunction {
 8 | 	func run(with input: Input) throws(Failure) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any SyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | 	@inlinable
23 | 	public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | 		self.init(f.run)
25 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | 	Output,
13 | 	Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
   |                                    `- error: unknown attribute 'MainActor'
15 | 	@usableFromInline
16 | 	internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 6 | 	Failure
 7 | >: AsyncThrowingFunction {
 8 | 	func run(with input: Input) throws(Failure) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[37/46] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | 	@inlinable
25 | 	public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | 		self.init(f.run)
27 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | 	Output,
15 | 	Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
   |                                     `- error: unknown attribute 'MainActor'
17 | 	@usableFromInline
18 | 	internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[38/46] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | 	@inlinable
25 | 	public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | 		self.init(f.run)
27 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | 	Output,
15 | 	Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
   |                                     `- error: unknown attribute 'MainActor'
17 | 	@usableFromInline
18 | 	internal var call: @MainActor (Input) async throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[39/46] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | 	@inlinable
23 | 	public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | 		self.init(f.run)
25 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | 	Output,
13 | 	Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
   |                                    `- error: unknown attribute 'MainActor'
15 | 	@usableFromInline
16 | 	internal var call: @MainActor (Input) throws(Failure) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 6 | 	Failure
 7 | >: AsyncThrowingFunction {
 8 | 	func run(with input: Input) throws(Failure) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
[40/46] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
/Users/admin/builder/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
[41/46] Compiling NominalFunctionTypes AsyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | 	@inlinable
22 | 	public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | 		self.init(f.run)
24 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | 	Input,
12 | 	Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
   |                             `- error: unknown attribute 'MainActor'
14 | 	@usableFromInline
15 | 	internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
[42/46] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | 	@inlinable
13 | 	public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | 		self.init(f.run)
15 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | 	@inlinable
22 | 	public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | 		self.init(f.run)
24 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | 	Input,
12 | 	Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
   |                             `- error: unknown attribute 'MainActor'
14 | 	@usableFromInline
15 | 	internal var call: @MainActor (Input) async -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/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 | 	}
[43/46] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | 	@inlinable
14 | 	public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
   |                       `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | 		self.init(f.run)
16 | 	}
[44/46] Compiling NominalFunctionTypes Exports.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | 	@inlinable
21 | 	public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | 		self.init(f.run)
23 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | 	Input,
11 | 	Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
   |                            `- error: unknown attribute 'MainActor'
13 | 	@usableFromInline
14 | 	internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 5 | 	Output
 6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
 7 | 	func run(with input: Input) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 8 | }
 9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 6 | 	Failure
 7 | >: AsyncThrowingFunction {
 8 | 	func run(with input: Input) throws(Failure) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
[45/46] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/Users/admin/builder/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
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | 	@inlinable
21 | 	public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
   |                       `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | 		self.init(f.run)
23 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | 	Input,
11 | 	Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
   |                            `- error: unknown attribute 'MainActor'
13 | 	@usableFromInline
14 | 	internal var call: @MainActor (Input) -> Output
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 5 | 	Output
 6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
 7 | 	func run(with input: Input) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 8 | }
 9 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated 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 | 	}
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 6 | 	Failure
 7 | >: AsyncThrowingFunction {
 8 | 	func run(with input: Input) throws(Failure) -> Output
   |       `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
 9 | }
10 |
/Users/admin/builder/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' 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 | 	}
/Users/admin/builder/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/46] Compiling NominalFunctionTypes _MainActorMarkers.swift
/Users/admin/builder/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
Fetching https://github.com/pointfreeco/swift-concurrency-extras.git
[1/894] Fetching swift-concurrency-extras
Fetched https://github.com/pointfreeco/swift-concurrency-extras.git from cache (0.99s)
Computing version for https://github.com/pointfreeco/swift-concurrency-extras.git
Computed https://github.com/pointfreeco/swift-concurrency-extras.git at 1.3.2 (0.44s)
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
BUILD FAILURE 6.0 macosSpm