DL4S – Build Information – Swift Package Index

Track the adoption of Swift 6 strict concurrency checks for data race safety. How many packages are Ready for Swift 6?

Build Information

Successful build of DL4S, reference 0.4.1 (1f90f8), with Swift 6.1 for macOS (SPM) on 26 Apr 2025 17:06:18 UTC.

Swift 6 data race errors: 9

Build Command

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

Build Log

     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[63/81] Compiling DL4S CPUFloat.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:38:16: warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 36 |     public typealias Device = CPU
 37 |
 38 |     static var traceAllocations: Bool = false {
    |                |- warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'traceAllocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'traceAllocations' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 39 |         didSet {
 40 |             allocations.removeAll()
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:43:24: warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 41 |         }
 42 |     }
 43 |     private static var allocations: [UnsafeMutableRawBufferPointer: [String]] = [:]
    |                        |- warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'allocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: add '@MainActor' to make static property 'allocations' part of global actor 'MainActor'
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 44 |     private static let sema = DispatchSemaphore(value: 1)
 45 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:85:44: warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 83 |             DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(5)) {
 84 |                 sema.wait()
 85 |                 if let trace = allocations[buffer] {
    |                                            `- warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 86 |                     print("[ALLOC TRACE]: buffer of size \(capacity) not freed after 3 seconds.")
 87 |                     print("[ALLOC TRACE] [begin callstack]")
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
  |                       `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 |     @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:110:13: warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
108 |         }
109 |         DispatchQueue.global().async {
110 |             buffer.memory.deallocate()
    |             `- warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
111 |         }
112 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/Buffer.swift:30:15: note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 28 |
 29 | /// A buffer that holds a region of memory with a given length
 30 | public struct Buffer<Element, Device: DeviceType>: Hashable {
    |               `- note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 31 |     let memory: Device.Memory.RawBuffer
 32 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[64/81] Compiling DL4S CPUGeneric.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:38:16: warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 36 |     public typealias Device = CPU
 37 |
 38 |     static var traceAllocations: Bool = false {
    |                |- warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'traceAllocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'traceAllocations' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 39 |         didSet {
 40 |             allocations.removeAll()
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:43:24: warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 41 |         }
 42 |     }
 43 |     private static var allocations: [UnsafeMutableRawBufferPointer: [String]] = [:]
    |                        |- warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'allocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: add '@MainActor' to make static property 'allocations' part of global actor 'MainActor'
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 44 |     private static let sema = DispatchSemaphore(value: 1)
 45 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:85:44: warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 83 |             DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(5)) {
 84 |                 sema.wait()
 85 |                 if let trace = allocations[buffer] {
    |                                            `- warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 86 |                     print("[ALLOC TRACE]: buffer of size \(capacity) not freed after 3 seconds.")
 87 |                     print("[ALLOC TRACE] [begin callstack]")
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
  |                       `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 |     @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:110:13: warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
108 |         }
109 |         DispatchQueue.global().async {
110 |             buffer.memory.deallocate()
    |             `- warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
111 |         }
112 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/Buffer.swift:30:15: note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 28 |
 29 | /// A buffer that holds a region of memory with a given length
 30 | public struct Buffer<Element, Device: DeviceType>: Hashable {
    |               `- note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 31 |     let memory: Device.Memory.RawBuffer
 32 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[65/81] Compiling DL4S CPUInt32.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:38:16: warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 36 |     public typealias Device = CPU
 37 |
 38 |     static var traceAllocations: Bool = false {
    |                |- warning: static property 'traceAllocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                |- note: convert 'traceAllocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                |- note: add '@MainActor' to make static property 'traceAllocations' part of global actor 'MainActor'
    |                `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 39 |         didSet {
 40 |             allocations.removeAll()
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:43:24: warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
 41 |         }
 42 |     }
 43 |     private static var allocations: [UnsafeMutableRawBufferPointer: [String]] = [:]
    |                        |- warning: static property 'allocations' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                        |- note: convert 'allocations' to a 'let' constant to make 'Sendable' shared state immutable
    |                        |- note: add '@MainActor' to make static property 'allocations' part of global actor 'MainActor'
    |                        `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
 44 |     private static let sema = DispatchSemaphore(value: 1)
 45 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:85:44: warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 83 |             DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(5)) {
 84 |                 sema.wait()
 85 |                 if let trace = allocations[buffer] {
    |                                            `- warning: capture of 'buffer' with non-sendable type 'UnsafeMutableRawBufferPointer' in a '@Sendable' closure
 86 |                     print("[ALLOC TRACE]: buffer of size \(capacity) not freed after 3 seconds.")
 87 |                     print("[ALLOC TRACE] [begin callstack]")
Swift.UnsafeMutableRawBufferPointer:1:23: note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct UnsafeMutableRawBufferPointer {
  |                       `- note: struct 'UnsafeMutableRawBufferPointer' does not conform to the 'Sendable' protocol
2 |     @inlinable public init(start: UnsafeMutableRawPointer?, count: Int)
3 | }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPU.swift:110:13: warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
108 |         }
109 |         DispatchQueue.global().async {
110 |             buffer.memory.deallocate()
    |             `- warning: capture of 'buffer' with non-sendable type 'Buffer<Element, CPU>' in a '@Sendable' closure
111 |         }
112 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/Buffer.swift:30:15: note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 28 |
 29 | /// A buffer that holds a region of memory with a given length
 30 | public struct Buffer<Element, Device: DeviceType>: Hashable {
    |               `- note: consider making generic struct 'Buffer' conform to the 'Sendable' protocol
 31 |     let memory: Device.Memory.RawBuffer
 32 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[66/81] Compiling DL4S TransformerEncoderBlock.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[67/81] Compiling DL4S TransformerUtil.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[68/81] Compiling DL4S VGG.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[69/81] Compiling DL4S VGG11.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[70/81] Compiling DL4S VGG13.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[71/81] Compiling DL4S VGG16.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[72/81] Compiling DL4S VGG19.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[73/81] Compiling DL4S Adadelta.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoderBlock.swift:37:82: error: no exact matches in call to initializer
35 |     ].joined())}
36 |
37 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
38 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
39 |         pointwiseFeedForward.parameterPaths.map((\Self.pointwiseFeedForward).appending(path:))
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/VGG/VGG.swift:59:9: error: no exact matches in call to initializer
 57 |
 58 |     var parameterPaths: [WritableKeyPath<Self, Tensor<Parameter, Device>>] {
 59 |         Array([
    |         `- error: no exact matches in call to initializer
 60 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 61 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'FlattenSequence<[[KeyPath<Self, Tensor<Self.Parameter, Self.Device>>]]>.Element' (aka 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[74/81] Compiling DL4S LayerNorm.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[75/81] Compiling DL4S Pooling.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[76/81] Compiling DL4S RNN.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[77/81] Compiling DL4S Residual.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[78/81] Compiling DL4S Sequential.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[79/81] Compiling DL4S ShapeLayer.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[80/81] Compiling DL4S AlexNet.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
[81/81] Compiling DL4S ResNet.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Residual.swift:31:16: error: no exact matches in call to initializer
 29 | public struct ResidualBlock<Element: RandomizableType, Device: DeviceType>: LayerType {
 30 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 31 |         return Array([
    |                `- error: no exact matches in call to initializer
 32 |             conv1.parameterPaths.map((\Self.conv1).appending(path:)),
 33 |             conv2.parameterPaths.map((\Self.conv2).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:74:27: error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
 72 |             (\Self.second).appending(path: $0)
 73 |         }
 74 |         return firstPaths + secondPaths
    |                           |- error: cannot convert return expression of type '[KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]' to return type '[WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>]'
    |                           `- note: arguments to generic parameter 'Element' ('KeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>' and 'WritableKeyPath<Sequential<First, Second>, Tensor<First.Parameter, First.Device>>') are expected to be equal
 75 |     }
 76 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/AlexNet.swift:35:9: error: no exact matches in call to initializer
 33 | public struct AlexNet<Element: RandomizableType, Device: DeviceType>: LayerType, Codable {
 34 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 35 |         Array([
    |         `- error: no exact matches in call to initializer
 36 |             featureNet.parameterPaths.map((\Self.featureNet).appending(path:)),
 37 |             avgPool.parameterPaths.map((\Self.avgPool).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/ResNet.swift:51:9: error: no exact matches in call to initializer
 49 |
 50 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
 51 |         Array([
    |         `- error: no exact matches in call to initializer
 52 |             start.parameterPaths.map((\Self.start).appending(path:)),
 53 |             l1.parameterPaths.map((\Self.l1).appending(path:)),
Swift.Array.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
1 | generic struct Array {
2 | @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Element' == 'S.Element')
3 |
Swift.RangeReplaceableCollection.init:2:19: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
1 | protocol RangeReplaceableCollection {
2 | @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element}
  |                   `- note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'FlattenSequence<[[KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>]]>.Element' (aka 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>') be equivalent (requirement specified as 'Self.Element' == 'S.Element')
3 |
Running build ...
env DEVELOPER_DIR=/Applications/Xcode-16.3.0.app xcrun swift build --arch arm64
[0/1] Planning build
Building for debugging...
[0/1] Write swift-version-2F0A5646E1D333AE.txt
[2/72] Emitting module DL4S
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[3/79] Compiling DL4S Binary.swift
[4/79] Compiling DL4S Conv.swift
[5/79] Compiling DL4S Loss.swift
[6/79] Compiling DL4S Matrix.swift
[7/79] Compiling DL4S Reduce.swift
[8/79] Compiling DL4S Scatter.swift
[9/79] Compiling DL4S Shape.swift
[10/79] Compiling DL4S CPUNumeric.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[11/79] Compiling DL4S Engine.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[12/79] Compiling DL4S GPU.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[13/79] Compiling DL4S Allocator.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[14/79] Compiling DL4S MemoryOps.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[15/79] Compiling DL4S Activation.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[16/79] Compiling DL4S BasicRNN.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[17/79] Compiling DL4S BatchNorm.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:28:1: warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 26 | import Foundation
 27 |
 28 | extension UnsafeMutableRawBufferPointer: Hashable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableRawBufferPointer' to imported protocols 'Hashable', '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 |     public static func == (lhs: UnsafeMutableRawBufferPointer, rhs: UnsafeMutableRawBufferPointer) -> Bool {
 30 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:91:1: warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 89 | }
 90 |
 91 | extension UnsafeMutableBufferPointer: Equatable {
    | |- warning: extension declares a conformance of imported type 'UnsafeMutableBufferPointer' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 92 |     public static func == (lhs: UnsafeMutableBufferPointer<Element>, rhs: UnsafeMutableBufferPointer<Element>) -> Bool {
 93 |         return lhs.baseAddress == rhs.baseAddress && lhs.count == rhs.count
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Memory Management/Allocator.swift:63:27: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 61 |         precondition(self.count >= count, "Out of bounds write")
 62 |         //memcpy(self.baseAddress!, ptr.baseAddress!, count * MemoryLayout<Element>.stride)
 63 |         self.baseAddress!.assign(from: ptr.baseAddress!, count: count)
    |                           |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
    |                           `- note: use 'update(from:count:)' instead
 64 |     }
 65 |
[18/79] Compiling DL4S Adagrad.swift
[19/79] Compiling DL4S Adam.swift
[20/79] Compiling DL4S LearningRate.swift
[21/79] Compiling DL4S Momentum.swift
[22/79] Compiling DL4S Optim.swift
[23/79] Compiling DL4S RMSProp.swift
[24/79] Compiling DL4S SGD.swift
[25/79] Compiling DL4S Double.swift
[26/79] Compiling DL4S MultiHeadAttention.swift
[27/79] Compiling DL4S PointwiseFeedForward.swift
[28/79] Compiling DL4S PositionalEncoding.swift
[29/79] Compiling DL4S ScaledDotProductAttention.swift
[30/79] Compiling DL4S Transformer.swift
[31/79] Compiling DL4S TransformerDecoder.swift
[32/79] Compiling DL4S TransformerDecoderBlock.swift
[33/79] Compiling DL4S TransformerEncoder.swift
[34/79] Compiling DL4S BidirectionalRNN.swift
[35/79] Compiling DL4S Convolution.swift
[36/79] Compiling DL4S Dense.swift
[37/79] Compiling DL4S Dropout.swift
[38/79] Compiling DL4S Embedding.swift
[39/79] Compiling DL4S GRU.swift
[40/79] Compiling DL4S LSTM.swift
[41/79] Compiling DL4S Layer.swift
[42/79] Compiling DL4S Float.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[43/79] Compiling DL4S Int32.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[44/79] Compiling DL4S NumericType.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[45/79] Compiling DL4S Random.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[46/79] Compiling DL4S SummaryWriter.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[47/79] Compiling DL4S Context.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[48/79] Compiling DL4S Graph.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Numerics/Int32.swift:29:1: warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 27 |
 28 |
 29 | extension Int32: NumericType {
    | |- warning: extension declares a conformance of imported type 'Int32' to imported protocol 'ExpressibleByFloatLiteral'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 30 |     public func format(maxDecimals: Int) -> String {
 31 |         return "\(self)"
[49/79] Compiling DL4S LayerNorm.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[50/79] Compiling DL4S Pooling.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[51/79] Compiling DL4S RNN.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[52/79] Compiling DL4S Residual.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[53/79] Compiling DL4S Sequential.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[54/79] Compiling DL4S ShapeLayer.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[55/79] Compiling DL4S AlexNet.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[56/79] Compiling DL4S ResNet.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Layer/Sequential.swift:91:2: warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 89 |
 90 | /// A layer builder can be used to create sequences of layers
 91 | @_functionBuilder
    |  `- warning: '@_functionBuilder' has been renamed to '@resultBuilder'
 92 | public enum LayerBuilder {}
 93 |
[57/79] Compiling DL4S TransformerEncoderBlock.swift
[58/79] Compiling DL4S TransformerUtil.swift
[59/79] Compiling DL4S VGG.swift
[60/79] Compiling DL4S VGG11.swift
[61/79] Compiling DL4S VGG13.swift
[62/79] Compiling DL4S VGG16.swift
[63/79] Compiling DL4S VGG19.swift
[64/79] Compiling DL4S Adadelta.swift
[65/79] Compiling DL4S Stack.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[66/79] Compiling DL4S Subscript.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[67/79] Compiling DL4S Unary.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[68/79] Compiling DL4S UtilOps.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[69/79] Compiling DL4S Tensor.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[70/79] Compiling DL4S TensorExt.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[71/79] Compiling DL4S Util.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:93:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 91 | }
 92 |
 93 | extension Slice: Equatable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Equatable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
 94 |     public static func == (lhs: Slice<Base>, rhs: Slice<Base>) -> Bool {
 95 |         return lhs.count == rhs.count && !zip(lhs, rhs).map(==).contains(false)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:99:1: warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
 97 | }
 98 |
 99 | extension Slice: Hashable where Element: Hashable {
    | |- warning: extension declares a conformance of imported type 'Slice' to imported protocol 'Hashable'; this will not behave correctly if the owners of 'Swift' introduce this conformance in the future
    | `- note: add '@retroactive' to silence this warning
100 |     public func hash(into hasher: inout Hasher) {
101 |         for element in self {
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Util.swift:251:37: warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
248 |
249 |
250 | public struct Progress<Element>: Sequence {
    |                        `- note: 'Element' previously declared here
251 |     private struct ProgressIterator<Element>: IteratorProtocol {
    |                                     `- warning: generic parameter 'Element' shadows generic parameter from outer scope with the same name; this is an error in the Swift 6 language mode
252 |         var baseIterator: AnyIterator<Element>
253 |         let totalUnitCount: Int
[72/79] Compiling DL4S Assertions.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[73/79] Compiling DL4S Buffer.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[74/79] Compiling DL4S CPU.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[75/79] Compiling DL4S CPUEngine.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[76/79] Compiling DL4S CPUDouble.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[77/79] Compiling DL4S CPUFloat.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[78/79] Compiling DL4S CPUGeneric.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
[79/79] Compiling DL4S CPUInt32.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Assertions.swift:29:1: warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
27 |
28 |
29 | extension FileHandle: TextOutputStream {
   | |- warning: extension declares a conformance of imported type 'FileHandle' to imported protocol 'TextOutputStream'; this will not behave correctly if the owners of 'Foundation' introduce this conformance in the future
   | `- note: add '@retroactive' to silence this warning
30 |     public func write(_ string: String) {
31 |         self.write(string.data(using: .utf8)!)
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:933:41: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
 931 |             }
 932 |
 933 |             dstMem.advanced(by: dstIdx).assign(from: sourceMem.advanced(by: srcIdx), count: copyCount)
     |                                         |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                         `- note: use 'update(from:count:)' instead
 934 |         }
 935 |     }
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1018:42: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1016 |                 }
1017 |
1018 |                 dst.advanced(by: dstIdx).assign(from: src.advanced(by: srcIdx), count: copyCount)
     |                                          |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                          `- note: use 'update(from:count:)' instead
1019 |             }
1020 |
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/Engine/CPU/CPUEngine.swift:1098:50: warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
1096 |             let dstIdx = count - srcIdx - 1
1097 |
1098 |             dstPtr.advanced(by: dstIdx * stride).assign(from: srcPtr.advanced(by: srcIdx * stride), count: stride)
     |                                                  |- warning: 'assign(from:count:)' is deprecated: renamed to 'update(from:count:)'
     |                                                  `- note: use 'update(from:count:)' instead
1099 |         }
1100 |     }
Build complete! (3.80s)
Build complete.
{
  "dependencies" : [
  ],
  "manifest_display_name" : "DL4S",
  "name" : "DL4S",
  "path" : "/Users/admin/builder/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "macos",
      "version" : "10.15"
    },
    {
      "name" : "ios",
      "version" : "13.0"
    },
    {
      "name" : "tvos",
      "version" : "13.0"
    },
    {
      "name" : "watchos",
      "version" : "6.0"
    }
  ],
  "products" : [
    {
      "name" : "DL4S",
      "targets" : [
        "DL4S",
        "MKL"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "MKL",
      "module_type" : "ClangTarget",
      "name" : "MKL",
      "path" : "Sources/MKL",
      "product_memberships" : [
        "DL4S"
      ],
      "sources" : [
        "placeholder.c"
      ],
      "type" : "library"
    },
    {
      "c99name" : "DL4STests",
      "module_type" : "SwiftTarget",
      "name" : "DL4STests",
      "path" : "Tests/DL4STests",
      "sources" : [
        "ConvTests.swift",
        "EngineV2Tests.swift",
        "GradientTests.swift",
        "MNISTTests.swift",
        "MemTests.swift",
        "ModelTests.swift",
        "TransformerTests.swift",
        "UtilTests.swift",
        "VecTests.swift",
        "VectorXORTest.swift",
        "XCTestManifests.swift"
      ],
      "target_dependencies" : [
        "DL4S"
      ],
      "type" : "test"
    },
    {
      "c99name" : "DL4S",
      "module_type" : "SwiftTarget",
      "name" : "DL4S",
      "path" : "Sources/DL4S",
      "product_memberships" : [
        "DL4S"
      ],
      "sources" : [
        "Assertions.swift",
        "Engine/Buffer.swift",
        "Engine/CPU/CPU.swift",
        "Engine/CPU/CPUEngine.swift",
        "Engine/CPU/Numeric/CPUDouble.swift",
        "Engine/CPU/Numeric/CPUFloat.swift",
        "Engine/CPU/Numeric/CPUGeneric.swift",
        "Engine/CPU/Numeric/CPUInt32.swift",
        "Engine/CPU/Numeric/CPUNumeric.swift",
        "Engine/Engine.swift",
        "Engine/GPU/GPU.swift",
        "Memory Management/Allocator.swift",
        "Memory Management/MemoryOps.swift",
        "NN/Layer/Activation.swift",
        "NN/Layer/BasicRNN.swift",
        "NN/Layer/BatchNorm.swift",
        "NN/Layer/BidirectionalRNN.swift",
        "NN/Layer/Convolution.swift",
        "NN/Layer/Dense.swift",
        "NN/Layer/Dropout.swift",
        "NN/Layer/Embedding.swift",
        "NN/Layer/GRU.swift",
        "NN/Layer/LSTM.swift",
        "NN/Layer/Layer.swift",
        "NN/Layer/LayerNorm.swift",
        "NN/Layer/Pooling.swift",
        "NN/Layer/RNN.swift",
        "NN/Layer/Residual.swift",
        "NN/Layer/Sequential.swift",
        "NN/Layer/ShapeLayer.swift",
        "NN/Models/AlexNet.swift",
        "NN/Models/ResNet.swift",
        "NN/Models/Transformer/MultiHeadAttention.swift",
        "NN/Models/Transformer/PointwiseFeedForward.swift",
        "NN/Models/Transformer/PositionalEncoding.swift",
        "NN/Models/Transformer/ScaledDotProductAttention.swift",
        "NN/Models/Transformer/Transformer.swift",
        "NN/Models/Transformer/TransformerDecoder.swift",
        "NN/Models/Transformer/TransformerDecoderBlock.swift",
        "NN/Models/Transformer/TransformerEncoder.swift",
        "NN/Models/Transformer/TransformerEncoderBlock.swift",
        "NN/Models/Transformer/TransformerUtil.swift",
        "NN/Models/VGG/VGG.swift",
        "NN/Models/VGG/VGG11.swift",
        "NN/Models/VGG/VGG13.swift",
        "NN/Models/VGG/VGG16.swift",
        "NN/Models/VGG/VGG19.swift",
        "NN/Optimizer/Adadelta.swift",
        "NN/Optimizer/Adagrad.swift",
        "NN/Optimizer/Adam.swift",
        "NN/Optimizer/LearningRate.swift",
        "NN/Optimizer/Momentum.swift",
        "NN/Optimizer/Optim.swift",
        "NN/Optimizer/RMSProp.swift",
        "NN/Optimizer/SGD.swift",
        "Numerics/Double.swift",
        "Numerics/Float.swift",
        "Numerics/Int32.swift",
        "Numerics/NumericType.swift",
        "Random.swift",
        "SummaryWriter.swift",
        "Tensor/Context.swift",
        "Tensor/Graph.swift",
        "Tensor/Operators/Binary.swift",
        "Tensor/Operators/Conv.swift",
        "Tensor/Operators/Loss.swift",
        "Tensor/Operators/Matrix.swift",
        "Tensor/Operators/Reduce.swift",
        "Tensor/Operators/Scatter.swift",
        "Tensor/Operators/Shape.swift",
        "Tensor/Operators/Stack.swift",
        "Tensor/Operators/Subscript.swift",
        "Tensor/Operators/Unary.swift",
        "Tensor/Operators/UtilOps.swift",
        "Tensor/Tensor.swift",
        "Tensor/TensorExt.swift",
        "Util.swift"
      ],
      "target_dependencies" : [
        "MKL"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "5.2"
}
Done.