Swift Package Index

Build Information

Failed to build NDArray, reference master (49c5f1), with Swift 6.3 for Wasm on 11 Apr 2026 02:29:21 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3-RELEASE_wasm 2>&1

Build Log

========================================
RunAll
========================================
Builder version: 4.70.0
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/cgarciae/ndarray.git
Reference: master
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/cgarciae/ndarray
 * branch            master     -> FETCH_HEAD
 * [new branch]      master     -> origin/master
HEAD is now at 49c5f1e update readme
Cloned https://github.com/cgarciae/ndarray.git
Revision (git rev-parse @):
49c5f1ec9958a73afde90842c57995d8de9f57b7
SUCCESS checkout https://github.com/cgarciae/ndarray.git at master
========================================
Build
========================================
Selected platform:         wasm
Swift version:             6.3
Building package at path:  $PWD
https://github.com/cgarciae/ndarray.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-4609320-3":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3-RELEASE_wasm 2>&1
wasm-6.3-latest: Pulling from swiftpackageindex/spi-images
Digest: sha256:d69f4e7582c319245442d62a08b2d7c7fd5a0c0c69f5d2ef11d1530cd8d3329b
Status: Image is up to date for registry.gitlab.com/swiftpackageindex/spi-images:wasm-6.3-latest
warning: 'spi-builder-workspace': The target named 'Debug' was identified as an executable target but a non-executable product with this name already exists.
Building for debugging...
[0/3] Write sources
[2/3] Write swift-version-24593BA9C3E375BF.txt
error: emit-module command failed with exit code 1 (use -v to see invocation)
[4/26] Emitting module NDArray
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:89:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
 87 |     public mutating func withScalarSetter(_ body: (@escaping NDArray<Scalar>.ScalarSetter) -> Void) {
 88 |         data.value.withUnsafeMutableBufferPointer { dataIn in
 89 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
 90 |             defer { dataIn = data }
 91 |
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:104:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
102 |     public mutating func withScalarGetterSetter(_ body: (@escaping NDArray<Scalar>.ScalarGetterSetter) -> Void) {
103 |         data.value.withUnsafeMutableBufferPointer { dataIn in
104 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
105 |             defer { dataIn = data }
106 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: type declared here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: type declared here
3 |     public init()
4 | }
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Divisible'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Divisible'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/div.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func / (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 8 |         elementwise(rhs) { lhs / $0 }
 9 |     }
10 |
11 |     public static func / (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
12 |         elementwise(lhs) { $0 / rhs }
13 |     }
Swift.Duration./:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration'
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func / <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration'
4 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Numeric'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Numeric'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/mul.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 5 |     }
 6 |
 7 |     public static func * (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 8 |         elementwise(rhs) { lhs * $0 }
 9 |     }
10 |
11 |     public static func * (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>' [with Magnitude = _]
12 |         elementwise(lhs) { $0 * rhs }
13 |     }
Swift.Duration.*:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func * <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.*:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
3 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/add.swift:7:24: note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func + (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 8 |         elementwise(lhs) { $0 + rhs }
 9 |     }
10 |
11 |     public static func + (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
12 |         elementwise(rhs) { lhs + $0 }
13 |     }
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self, rhs: Self.Stride) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
3 |
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self.Stride, rhs: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Other, rhs: Self) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : RangeReplaceableCollection, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (Self, String) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: Self, rhs: String) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (Self, String) -> Never'
4 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (String, Self) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: String, rhs: Self) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (String, Self) -> Never'
4 |
Swift.SIMD.+:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.+:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
4 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
FoundationEssentials.AttributedString.+:2:20: note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
1 | struct AttributedString {
2 | public static func + (lhs: AttributedString, rhs: some AttributedStringProtocol) -> AttributedString}
  |                    `- note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
 2 |
 3 | public protocol Divisible: Numeric {
 4 |     static func / (lhs: Self, rhs: Self) -> Self
   |                 `- note: protocol requires function '/' with type '(Float80, Float80) -> Float80'
 5 |     static func /= (lhs: inout Self, rhs: Self)
 6 | }
   :
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Numeric.Magnitude:2:16: note: protocol requires nested type 'Magnitude'
1 | protocol Numeric {
2 | associatedtype Magnitude : Comparable, Numeric}
  |                `- note: protocol requires nested type 'Magnitude'
3 |
Swift.Numeric.init:2:1: note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
1 | protocol Numeric {
2 | init?<T>(exactly source: T) where T : BinaryInteger}
  | `- note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
3 |
Swift.Numeric.*:2:13: note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
1 | protocol Numeric {
2 | static func * (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
3 |
Swift.AdditiveArithmetic.+:2:13: note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
1 | protocol AdditiveArithmetic {
2 | static func + (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
3 |
Swift.ExpressibleByIntegerLiteral.IntegerLiteralType:2:16: note: protocol requires nested type 'IntegerLiteralType'
1 | protocol ExpressibleByIntegerLiteral {
2 | associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral}
  |                `- note: protocol requires nested type 'IntegerLiteralType'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:11: error: 'Float80' is unavailable: Float80 is not available on target platform.
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   |           `- error: 'Float80' is unavailable: Float80 is not available on target platform.
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: 'Float80' has been explicitly marked unavailable here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: 'Float80' has been explicitly marked unavailable here
3 |     public init()
4 | }
/host/spi-builder-workspace/Sources/NDArray/utils.swift:136:17: error: cannot find 'DispatchGroup' in scope
134 |     body: @escaping (E) -> Void
135 | ) where S.Element == E {
136 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
137 |     let nElements = range.count
138 |
[5/29] Compiling NDArray Expressible.swift
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:89:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
 87 |     public mutating func withScalarSetter(_ body: (@escaping NDArray<Scalar>.ScalarSetter) -> Void) {
 88 |         data.value.withUnsafeMutableBufferPointer { dataIn in
 89 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
 90 |             defer { dataIn = data }
 91 |
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:104:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
102 |     public mutating func withScalarGetterSetter(_ body: (@escaping NDArray<Scalar>.ScalarGetterSetter) -> Void) {
103 |         data.value.withUnsafeMutableBufferPointer { dataIn in
104 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
105 |             defer { dataIn = data }
106 |
[6/29] Compiling NDArray NDArray.swift
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:89:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
 87 |     public mutating func withScalarSetter(_ body: (@escaping NDArray<Scalar>.ScalarSetter) -> Void) {
 88 |         data.value.withUnsafeMutableBufferPointer { dataIn in
 89 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
 90 |             defer { dataIn = data }
 91 |
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:104:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
102 |     public mutating func withScalarGetterSetter(_ body: (@escaping NDArray<Scalar>.ScalarGetterSetter) -> Void) {
103 |         data.value.withUnsafeMutableBufferPointer { dataIn in
104 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
105 |             defer { dataIn = data }
106 |
[7/29] Compiling NDArray ArrayShape.swift
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:89:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
 87 |     public mutating func withScalarSetter(_ body: (@escaping NDArray<Scalar>.ScalarSetter) -> Void) {
 88 |         data.value.withUnsafeMutableBufferPointer { dataIn in
 89 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
 90 |             defer { dataIn = data }
 91 |
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:104:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
102 |     public mutating func withScalarGetterSetter(_ body: (@escaping NDArray<Scalar>.ScalarGetterSetter) -> Void) {
103 |         data.value.withUnsafeMutableBufferPointer { dataIn in
104 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
105 |             defer { dataIn = data }
106 |
[8/29] Compiling NDArray BaseNDArray.swift
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:89:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
 87 |     public mutating func withScalarSetter(_ body: (@escaping NDArray<Scalar>.ScalarSetter) -> Void) {
 88 |         data.value.withUnsafeMutableBufferPointer { dataIn in
 89 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
 90 |             defer { dataIn = data }
 91 |
/host/spi-builder-workspace/Sources/NDArray/NDArrayTypes/BaseNDArray/BaseNDArray.swift:104:17: warning: variable 'data' was never mutated; consider changing to 'let' constant
102 |     public mutating func withScalarGetterSetter(_ body: (@escaping NDArray<Scalar>.ScalarGetterSetter) -> Void) {
103 |         data.value.withUnsafeMutableBufferPointer { dataIn in
104 |             var data = dataIn
    |                 `- warning: variable 'data' was never mutated; consider changing to 'let' constant
105 |             defer { dataIn = data }
106 |
[9/29] Compiling NDArray broadcast.swift
[10/29] Compiling NDArray description.swift
[11/29] Compiling NDArray div.swift
[12/29] Compiling NDArray mean.swift
[13/29] Compiling NDArray min.swift
[14/29] Compiling NDArray mul.swift
[15/29] Compiling NDArray NDArrayProtocol.swift
/host/spi-builder-workspace/Sources/NDArray/utils.swift:136:17: error: cannot find 'DispatchGroup' in scope
134 |     body: @escaping (E) -> Void
135 | ) where S.Element == E {
136 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
137 |     let nElements = range.count
138 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[16/29] Compiling NDArray Ref.swift
/host/spi-builder-workspace/Sources/NDArray/utils.swift:136:17: error: cannot find 'DispatchGroup' in scope
134 |     body: @escaping (E) -> Void
135 | ) where S.Element == E {
136 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
137 |     let nElements = range.count
138 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[17/29] Compiling NDArray utils.swift
/host/spi-builder-workspace/Sources/NDArray/utils.swift:136:17: error: cannot find 'DispatchGroup' in scope
134 |     body: @escaping (E) -> Void
135 | ) where S.Element == E {
136 |     let group = DispatchGroup()
    |                 `- error: cannot find 'DispatchGroup' in scope
137 |     let nElements = range.count
138 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[18/29] Compiling NDArray Dimension.swift
[19/29] Compiling NDArray ScalarNDArray.swift
[20/29] Compiling NDArray add.swift
[21/29] Compiling NDArray sum.swift
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: type declared here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: type declared here
3 |     public init()
4 | }
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Divisible'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Divisible'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/div.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func / (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 8 |         elementwise(rhs) { lhs / $0 }
 9 |     }
10 |
11 |     public static func / (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
12 |         elementwise(lhs) { $0 / rhs }
13 |     }
Swift.Duration./:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration'
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func / <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration'
4 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Numeric'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Numeric'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/mul.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 5 |     }
 6 |
 7 |     public static func * (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 8 |         elementwise(rhs) { lhs * $0 }
 9 |     }
10 |
11 |     public static func * (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>' [with Magnitude = _]
12 |         elementwise(lhs) { $0 * rhs }
13 |     }
Swift.Duration.*:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func * <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.*:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
3 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/add.swift:7:24: note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func + (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 8 |         elementwise(lhs) { $0 + rhs }
 9 |     }
10 |
11 |     public static func + (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
12 |         elementwise(rhs) { lhs + $0 }
13 |     }
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self, rhs: Self.Stride) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
3 |
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self.Stride, rhs: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Other, rhs: Self) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : RangeReplaceableCollection, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (Self, String) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: Self, rhs: String) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (Self, String) -> Never'
4 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (String, Self) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: String, rhs: Self) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (String, Self) -> Never'
4 |
Swift.SIMD.+:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.+:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
4 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
FoundationEssentials.AttributedString.+:2:20: note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
1 | struct AttributedString {
2 | public static func + (lhs: AttributedString, rhs: some AttributedStringProtocol) -> AttributedString}
  |                    `- note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
 2 |
 3 | public protocol Divisible: Numeric {
 4 |     static func / (lhs: Self, rhs: Self) -> Self
   |                 `- note: protocol requires function '/' with type '(Float80, Float80) -> Float80'
 5 |     static func /= (lhs: inout Self, rhs: Self)
 6 | }
   :
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Numeric.Magnitude:2:16: note: protocol requires nested type 'Magnitude'
1 | protocol Numeric {
2 | associatedtype Magnitude : Comparable, Numeric}
  |                `- note: protocol requires nested type 'Magnitude'
3 |
Swift.Numeric.init:2:1: note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
1 | protocol Numeric {
2 | init?<T>(exactly source: T) where T : BinaryInteger}
  | `- note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
3 |
Swift.Numeric.*:2:13: note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
1 | protocol Numeric {
2 | static func * (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
3 |
Swift.AdditiveArithmetic.+:2:13: note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
1 | protocol AdditiveArithmetic {
2 | static func + (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
3 |
Swift.ExpressibleByIntegerLiteral.IntegerLiteralType:2:16: note: protocol requires nested type 'IntegerLiteralType'
1 | protocol ExpressibleByIntegerLiteral {
2 | associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral}
  |                `- note: protocol requires nested type 'IntegerLiteralType'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:11: error: 'Float80' is unavailable: Float80 is not available on target platform.
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   |           `- error: 'Float80' is unavailable: Float80 is not available on target platform.
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: 'Float80' has been explicitly marked unavailable here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: 'Float80' has been explicitly marked unavailable here
3 |     public init()
4 | }
[22/29] Compiling NDArray Divisible.swift
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: type declared here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: type declared here
3 |     public init()
4 | }
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Divisible'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Divisible'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/div.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func / (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 8 |         elementwise(rhs) { lhs / $0 }
 9 |     }
10 |
11 |     public static func / (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
12 |         elementwise(lhs) { $0 / rhs }
13 |     }
Swift.Duration./:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration'
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func / <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration'
4 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Numeric'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Numeric'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/mul.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 5 |     }
 6 |
 7 |     public static func * (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 8 |         elementwise(rhs) { lhs * $0 }
 9 |     }
10 |
11 |     public static func * (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>' [with Magnitude = _]
12 |         elementwise(lhs) { $0 * rhs }
13 |     }
Swift.Duration.*:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func * <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.*:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
3 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/add.swift:7:24: note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func + (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 8 |         elementwise(lhs) { $0 + rhs }
 9 |     }
10 |
11 |     public static func + (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
12 |         elementwise(rhs) { lhs + $0 }
13 |     }
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self, rhs: Self.Stride) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
3 |
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self.Stride, rhs: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Other, rhs: Self) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : RangeReplaceableCollection, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (Self, String) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: Self, rhs: String) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (Self, String) -> Never'
4 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (String, Self) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: String, rhs: Self) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (String, Self) -> Never'
4 |
Swift.SIMD.+:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.+:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
4 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
FoundationEssentials.AttributedString.+:2:20: note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
1 | struct AttributedString {
2 | public static func + (lhs: AttributedString, rhs: some AttributedStringProtocol) -> AttributedString}
  |                    `- note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
 2 |
 3 | public protocol Divisible: Numeric {
 4 |     static func / (lhs: Self, rhs: Self) -> Self
   |                 `- note: protocol requires function '/' with type '(Float80, Float80) -> Float80'
 5 |     static func /= (lhs: inout Self, rhs: Self)
 6 | }
   :
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Numeric.Magnitude:2:16: note: protocol requires nested type 'Magnitude'
1 | protocol Numeric {
2 | associatedtype Magnitude : Comparable, Numeric}
  |                `- note: protocol requires nested type 'Magnitude'
3 |
Swift.Numeric.init:2:1: note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
1 | protocol Numeric {
2 | init?<T>(exactly source: T) where T : BinaryInteger}
  | `- note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
3 |
Swift.Numeric.*:2:13: note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
1 | protocol Numeric {
2 | static func * (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
3 |
Swift.AdditiveArithmetic.+:2:13: note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
1 | protocol AdditiveArithmetic {
2 | static func + (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
3 |
Swift.ExpressibleByIntegerLiteral.IntegerLiteralType:2:16: note: protocol requires nested type 'IntegerLiteralType'
1 | protocol ExpressibleByIntegerLiteral {
2 | associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral}
  |                `- note: protocol requires nested type 'IntegerLiteralType'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:11: error: 'Float80' is unavailable: Float80 is not available on target platform.
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   |           `- error: 'Float80' is unavailable: Float80 is not available on target platform.
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: 'Float80' has been explicitly marked unavailable here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: 'Float80' has been explicitly marked unavailable here
3 |     public init()
4 | }
[23/29] Compiling NDArray NDArrayFloatingPoint.swift
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- warning: extension declares a conformance of imported type 'Float80' to imported protocols 'Numeric', 'AdditiveArithmetic', 'ExpressibleByIntegerLiteral', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: extension outside of file declaring struct 'Float80' prevents automatic synthesis of '==' for protocol 'Equatable'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: type declared here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: type declared here
3 |     public init()
4 | }
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Divisible'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Divisible'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/div.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func / (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
 8 |         elementwise(rhs) { lhs / $0 }
 9 |     }
10 |
11 |     public static func / (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
12 |         elementwise(lhs) { $0 / rhs }
13 |     }
Swift.Duration./:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration'
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func / <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration'
4 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD./:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func / (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'Numeric'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'Numeric'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/mul.swift:7:24: note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 5 |     }
 6 |
 7 |     public static func * (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>' [with Magnitude = _]
 8 |         elementwise(rhs) { lhs * $0 }
 9 |     }
10 |
11 |     public static func * (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>' [with Magnitude = _]
12 |         elementwise(lhs) { $0 * rhs }
13 |     }
Swift.Duration.*:3:22: note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
1 | struct Duration {
2 | @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
3 |   public static func * <T>(lhs: Duration, rhs: T) -> Duration where T : BinaryInteger}
  |                      `- note: candidate has non-matching type '<T> (Duration, T) -> Duration' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.*:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&*' instead")
3 |   public static func * (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
4 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self' [with Magnitude = _]
3 |
Swift.SIMD.*:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
1 | protocol SIMD {
2 | public static func * (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self' [with Magnitude = _]
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | `- error: type 'Float80' does not conform to protocol 'AdditiveArithmetic'
29 | extension CGFloat: Divisible {}
/host/spi-builder-workspace/Sources/NDArray/Ops/add.swift:7:24: note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 5 |     }
 6 |
 7 |     public static func + (lhs: NDArray<Scalar>, rhs: Scalar) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (NDArray<Scalar>, Scalar) -> NDArray<Scalar>'
 8 |         elementwise(lhs) { $0 + rhs }
 9 |     }
10 |
11 |     public static func + (lhs: Scalar, rhs: NDArray<Scalar>) -> NDArray<Scalar> {
   |                        `- note: candidate has non-matching type '<Scalar> (Scalar, NDArray<Scalar>) -> NDArray<Scalar>'
12 |         elementwise(rhs) { lhs + $0 }
13 |     }
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self, rhs: Self.Stride) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Stride) -> Self'
3 |
Swift.Strideable.+:2:20: note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
1 | protocol Strideable {
2 | public static func + (lhs: Self.Stride, rhs: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Stride, Self) -> Self'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Other, rhs: Self) -> Self where Other : Sequence, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.RangeReplaceableCollection.+:2:31: note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
1 | protocol RangeReplaceableCollection {
2 | @inlinable public static func + <Other>(lhs: Self, rhs: Other) -> Self where Other : RangeReplaceableCollection, Self.Element == Other.Element}
  |                               `- note: candidate would match if 'Float80' conformed to 'RangeReplaceableCollection'
3 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (Self, String) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: Self, rhs: String) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (Self, String) -> Never'
4 |
Swift.Sequence.+:3:22: note: candidate has non-matching type '<Self> (String, Self) -> Never'
1 | protocol Sequence {
2 | @available(*, unavailable, message: "Operator '+' cannot be used to append a String to a sequence of strings")
3 |   public static func + (lhs: String, rhs: Self) -> Never}
  |                      `- note: candidate has non-matching type '<Self> (String, Self) -> Never'
4 |
Swift.SIMD.+:2:20: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self) -> Self}
  |                    `- note: candidate would match if 'Float80' conformed to 'SIMD'
3 |
Swift.SIMD.+:3:22: note: candidate would match if 'Float80' conformed to 'SIMD'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self) -> Self}
  |                      `- note: candidate would match if 'Float80' conformed to 'SIMD'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self, b: Self.Scalar) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
4 |
Swift.SIMD.+:3:22: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | @available(*, unavailable, message: "integer vector types do not support checked arithmetic; use the wrapping operator '&+' instead")
3 |   public static func + (a: Self.Scalar, b: Self) -> Self}
  |                      `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
4 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self.Scalar, b: Self) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self.Scalar, Self) -> Self'
3 |
Swift.SIMD.+:2:20: note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
1 | protocol SIMD {
2 | public static func + (a: Self, b: Self.Scalar) -> Self}
  |                    `- note: candidate has non-matching type '<Self> (Self, Self.Scalar) -> Self'
3 |
FoundationEssentials.AttributedString.+:2:20: note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
1 | struct AttributedString {
2 | public static func + (lhs: AttributedString, rhs: some AttributedStringProtocol) -> AttributedString}
  |                    `- note: candidate has non-matching type ' (AttributedString, some AttributedStringProtocol) -> AttributedString'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:1: error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
 2 |
 3 | public protocol Divisible: Numeric {
 4 |     static func / (lhs: Self, rhs: Self) -> Self
   |                 `- note: protocol requires function '/' with type '(Float80, Float80) -> Float80'
 5 |     static func /= (lhs: inout Self, rhs: Self)
 6 | }
   :
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   | |- error: type 'Float80' does not conform to protocol 'ExpressibleByIntegerLiteral'
   | `- note: add stubs for conformance
29 | extension CGFloat: Divisible {}
Swift.Numeric.Magnitude:2:16: note: protocol requires nested type 'Magnitude'
1 | protocol Numeric {
2 | associatedtype Magnitude : Comparable, Numeric}
  |                `- note: protocol requires nested type 'Magnitude'
3 |
Swift.Numeric.init:2:1: note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
1 | protocol Numeric {
2 | init?<T>(exactly source: T) where T : BinaryInteger}
  | `- note: protocol requires initializer 'init(exactly:)' with type '(exactly: T)'
3 |
Swift.Numeric.*:2:13: note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
1 | protocol Numeric {
2 | static func * (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '*' with type '(Float80, Float80) -> Float80'
3 |
Swift.AdditiveArithmetic.+:2:13: note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
1 | protocol AdditiveArithmetic {
2 | static func + (lhs: Self, rhs: Self) -> Self}
  |             `- note: protocol requires function '+' with type '(Float80, Float80) -> Float80'
3 |
Swift.ExpressibleByIntegerLiteral.IntegerLiteralType:2:16: note: protocol requires nested type 'IntegerLiteralType'
1 | protocol ExpressibleByIntegerLiteral {
2 | associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral}
  |                `- note: protocol requires nested type 'IntegerLiteralType'
3 |
/host/spi-builder-workspace/Sources/NDArray/Protocols/Divisible.swift:28:11: error: 'Float80' is unavailable: Float80 is not available on target platform.
26 | extension Double: Divisible {}
27 | extension Float: Divisible {}
28 | extension Float80: Divisible {}
   |           `- error: 'Float80' is unavailable: Float80 is not available on target platform.
29 | extension CGFloat: Divisible {}
Swift.Float80:2:23: note: 'Float80' has been explicitly marked unavailable here
1 | @available(*, unavailable, message: "Float80 is not available on target platform.")
2 | @frozen public struct Float80 {
  |                       `- note: 'Float80' has been explicitly marked unavailable here
3 |     public init()
4 | }
[24/29] Compiling NDArray dot.swift
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[25/29] Compiling NDArray elementWise.swift
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[26/29] Compiling NDArray max.swift
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:23: error: cannot find 'DispatchQueue' in scope
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                       `- error: cannot find 'DispatchQueue' in scope
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
/host/spi-builder-workspace/Sources/NDArray/Ops/elementWise.swift:4:68: error: cannot infer contextual base in reference to member 'concurrent'
  2 | import Foundation
  3 |
  4 | public let DISPATCH = DispatchQueue(label: "NDArray", attributes: .concurrent)
    |                                                                    `- error: cannot infer contextual base in reference to member 'concurrent'
  5 | public let CPU_COUNT = ProcessInfo.processInfo.activeProcessorCount
  6 |
[27/29] Compiling NDArray reduce.swift
[28/29] Compiling NDArray sub.swift
[29/29] Compiling NDArray subscript.swift
BUILD FAILURE 6.3 wasm