Swift Package IndexBuild Information
Failed to build swift-function-composition, reference main (a93ac2), with Swift 6.1 for Linux on 18 Apr 2026 01:29:17 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/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.1-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.1
Building package at path: $PWD
https://github.com/capturecontext/swift-function-composition.git
https://github.com/capturecontext/swift-function-composition.git
WARNING: environment variable SUPPRESS_SWIFT_6_FLAGS is not set
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/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.1-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1
basic-6.1-latest: Pulling from swiftpackageindex/spi-images
Digest: sha256:a7bfd71e9384436264431030299dc8a2d42d0664a168cfa1a5dd84c9bc592ccf
Status: Image is up to date for registry.gitlab.com/swiftpackageindex/spi-images:basic-6.1-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.52s)
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.54s)
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/11] Write sources
[10/11] Write swift-version-24593BA9C3E375BF.txt
[12/31] Emitting module _Currying
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[13/31] Emitting module Either
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[14/31] Compiling Either Either.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[16/32] Compiling FunctionCompositionOperators PrecedenceGroups.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[17/32] Compiling FunctionCompositionOperators Operators.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[18/32] Emitting module FunctionCompositionOperators
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[19/32] Compiling _Currying Flip.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[20/32] Compiling _Currying Curry.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[21/33] Compiling _Currying Uncurry.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[24/34] Compiling ConcurrencyExtras LockIsolated.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[25/35] Compiling ConcurrencyExtras Locking.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[26/35] Compiling ConcurrencyExtras UncheckedBox.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[27/35] Emitting module ConcurrencyExtras
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[28/35] Compiling ConcurrencyExtras ActorIsolated.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[29/35] Compiling ConcurrencyExtras AnyHashableSendable.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[30/35] Compiling ConcurrencyExtras AsyncStream.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[31/35] Compiling ConcurrencyExtras AsyncThrowingStream.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[32/35] Compiling ConcurrencyExtras Result.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[33/35] Compiling ConcurrencyExtras MainSerialExecutor.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[34/35] Compiling ConcurrencyExtras Task.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
[35/35] Compiling ConcurrencyExtras UncheckedSendable.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
error: emit-module command failed with exit code 1 (use -v to see invocation)
[37/51] Emitting module NominalFunctionTypes
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[38/51] Compiling NominalFunctionTypes SyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[39/51] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[40/51] Compiling NominalFunctionTypes AsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[41/51] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[42/51] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[43/51] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[44/51] Compiling NominalFunctionTypes SendableAsyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[45/51] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[46/52] Compiling NominalFunctionTypes Exports.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[47/52] Compiling NominalFunctionTypes MainActorSyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[48/52] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[49/52] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[50/52] Compiling NominalFunctionTypes SendableSyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[51/52] Compiling NominalFunctionTypes SyncFunc.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[52/52] Compiling NominalFunctionTypes _MainActorMarkers.swift
<unknown>:0: warning: upcoming feature 'InferSendableFromCaptures' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'GlobalActorIsolatedTypesUsability' is already enabled as of Swift version 6
<unknown>:0: warning: upcoming feature 'DisableOutwardActorInference' is already enabled as of Swift version 6
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/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.1-latest swift build --triple x86_64-unknown-linux-gnu 2>&1
basic-6.1-latest: Pulling from swiftpackageindex/spi-images
Digest: sha256:a7bfd71e9384436264431030299dc8a2d42d0664a168cfa1a5dd84c9bc592ccf
Status: Image is up to date for registry.gitlab.com/swiftpackageindex/spi-images:basic-6.1-latest
[0/1] Planning build
Building for debugging...
[0/1] Write swift-version-24593BA9C3E375BF.txt
[2/21] Compiling _Currying Uncurry.swift
[3/21] Compiling Either Either.swift
[4/21] Emitting module Either
[5/22] Compiling FunctionCompositionOperators Operators.swift
[6/22] Compiling FunctionCompositionOperators PrecedenceGroups.swift
[7/22] Emitting module FunctionCompositionOperators
[10/23] Compiling ConcurrencyExtras Result.swift
[11/24] Compiling ConcurrencyExtras Locking.swift
[12/24] Compiling ConcurrencyExtras UncheckedBox.swift
[13/24] Compiling ConcurrencyExtras LockIsolated.swift
[14/24] Compiling ConcurrencyExtras AsyncStream.swift
[15/24] Compiling ConcurrencyExtras AsyncThrowingStream.swift
[16/24] Compiling ConcurrencyExtras MainSerialExecutor.swift
[17/24] Compiling ConcurrencyExtras Task.swift
[18/24] Compiling ConcurrencyExtras ActorIsolated.swift
[19/24] Compiling ConcurrencyExtras AnyHashableSendable.swift
[20/24] Emitting module ConcurrencyExtras
[21/24] Compiling _Currying Curry.swift
[22/24] Emitting module _Currying
[23/24] Compiling _Currying Flip.swift
[25/25] Compiling ConcurrencyExtras UncheckedSendable.swift
[27/41] Compiling NominalFunctionTypes SyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[28/41] Compiling NominalFunctionTypes _AnyNominalFunctionType.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[29/42] Compiling NominalFunctionTypes MainActorAsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[30/42] Compiling NominalFunctionTypes SendableAsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
error: emit-module command failed with exit code 1 (use -v to see invocation)
[31/42] Emitting module NominalFunctionTypes
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:25:23: error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
23 |
24 | @inlinable
25 | public init(_ f: any _MainActorAsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
26 | self.init(f.run)
27 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:16:37: error: unknown attribute 'MainActor'
14 | Output,
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
17 | @usableFromInline
18 | internal var call: @MainActor (Input) async throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
12 | public struct MainActorAsyncThrowingFunc<
13 | Input,
14 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
15 | Failure: Error
16 | >: _MainActorAsyncThrowingFunction, @MainActor AsyncThrowingFunction, Sendable {
:
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/MainActorAsyncThrowingFunc.swift:31:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | @MainActor
30 | @inlinable
31 | public func run(with input: Input) async throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
32 | return try await call(input)
33 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[32/42] Compiling NominalFunctionTypes AsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[33/42] Compiling NominalFunctionTypes MainActorAsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:13:29: error: unknown attribute 'MainActor'
11 | Input,
12 | Output,
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
14 | @usableFromInline
15 | internal var call: @MainActor (Input) async -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorAsyncFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | >: _MainActorAsyncFunction, @MainActor AsyncFunction, Sendable {
14 | @usableFromInline
:
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
29 | await call(input)
30 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:28:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
26 | @MainActor
27 | @inlinable
28 | public func run(with input: Input) async -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
29 | await call(input)
30 | }
[34/42] Compiling NominalFunctionTypes SendableAsyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[35/42] Compiling NominalFunctionTypes AsyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/SendableAsyncFunc.swift:13:23: error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any AsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Async/MainActorAsyncFunc.swift:22:23: error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
20 |
21 | @inlinable
22 | public init(_ f: any _MainActorAsyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorAsyncFunction<Input, Output>' cannot be used within a protocol-constrained type
23 | self.init(f.run)
24 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/AsyncThrowing/SendableAsyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any AsyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'AsyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[36/42] Compiling NominalFunctionTypes Exports.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[37/42] Compiling NominalFunctionTypes MainActorSyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:12:28: error: unknown attribute 'MainActor'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- error: unknown attribute 'MainActor'
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
10 | Input,
11 | Output
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncFunction' conformance to defer isolation checking to run time
13 | @usableFromInline
14 | internal var call: @MainActor (Input) -> Output
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SyncFunc.swift:7:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
5 | Output
6 | >: AsyncFunction, SyncThrowingFunction where Failure == Never {
7 | func run(with input: Input) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
8 | }
9 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
9 | public struct MainActorSyncFunc<
10 | Input,
11 | Output
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
12 | >: _MainActorSyncFunction, @MainActor SyncFunction, Sendable {
13 | @usableFromInline
:
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
28 | return call(input)
29 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:27:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
25 | @MainActor
26 | @inlinable
27 | public func run(with input: Input) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
28 | return call(input)
29 | }
[38/42] Compiling NominalFunctionTypes SendableSyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[39/42] Compiling NominalFunctionTypes SyncFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/SendableSyncFunc.swift:13:23: error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
11 |
12 | @inlinable
13 | public init(_ f: any SyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type 'SyncFunction<Input, Output>' cannot be used within a protocol-constrained type
14 | self.init(f.run)
15 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/Sync/MainActorSyncFunc.swift:21:23: error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
19 |
20 | @inlinable
21 | public init(_ f: any _MainActorSyncFunction<Input, Output> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncFunction<Input, Output>' cannot be used within a protocol-constrained type
22 | self.init(f.run)
23 | }
[40/42] Compiling NominalFunctionTypes MainActorSyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[41/42] Compiling NominalFunctionTypes SendableSyncThrowingFunc.swift
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:23:23: error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
21 |
22 | @inlinable
23 | public init(_ f: any _MainActorSyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type '_MainActorSyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
24 | self.init(f.run)
25 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:14:36: error: unknown attribute 'MainActor'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- error: unknown attribute 'MainActor'
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
12 | Output,
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
| `- note: add '@preconcurrency' to the 'SyncThrowingFunction' conformance to defer isolation checking to run time
15 | @usableFromInline
16 | internal var call: @MainActor (Input) throws(Failure) -> Output
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: main actor-isolated instance method 'run(with:)' cannot be used to satisfy nonisolated requirement from protocol 'SyncThrowingFunction'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SyncThrowingFunc.swift:8:7: note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
6 | Failure
7 | >: AsyncThrowingFunction {
8 | func run(with input: Input) throws(Failure) -> Output
| `- note: mark the protocol requirement 'run(with:)' 'async' to allow actor-isolated conformances
9 | }
10 |
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
10 | public struct MainActorSyncThrowingFunc<
11 | Input,
12 | Output,
| `- note: consider making generic parameter 'Output' conform to the 'Sendable' protocol
13 | Failure: Error
14 | >: _MainActorSyncThrowingFunction, @MainActor SyncThrowingFunction, Sendable {
:
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable type 'Output' cannot be returned from main actor-isolated implementation to caller of protocol requirement 'run(with:)'
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/MainActorSyncThrowingFunc.swift:29:14: error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
27 | @MainActor
28 | @inlinable
29 | public func run(with input: Input) throws(Failure) -> Output {
| `- error: non-sendable parameter type 'Self.Input' cannot be sent from caller of protocol requirement 'run(with:)' into main actor-isolated implementation
30 | return try call(input)
31 | }
/host/spi-builder-workspace/Sources/NominalFunctionTypes/SyncThrowing/SendableSyncThrowingFunc.swift:14:23: error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
12 |
13 | @inlinable
14 | public init(_ f: any SyncThrowingFunction<Input, Output, Failure> & Sendable) {
| `- error: non-protocol, non-class type 'SyncThrowingFunction<Input, Output, Failure>' cannot be used within a protocol-constrained type
15 | self.init(f.run)
16 | }
[42/42] Compiling NominalFunctionTypes _MainActorMarkers.swift
BUILD FAILURE 6.1 linux