Swift Package Index

Build Information

Failed to build DL4S, reference 0.4.1 (1f90f8), with Swift 6.0 for macOS (SPM) on 28 Nov 2024 08:01:40 UTC.

Build Command

env DEVELOPER_DIR=/Applications/Xcode-16.1.0.app xcrun swift build --arch arm64 -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures

Build Log

 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[60/81] Compiling DL4S PositionalEncoding.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[61/81] Compiling DL4S ScaledDotProductAttention.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[62/81] Compiling DL4S Transformer.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[63/81] Compiling DL4S TransformerDecoder.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[64/81] Compiling DL4S TransformerDecoderBlock.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[65/81] Compiling DL4S TransformerEncoder.swift
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/MultiHeadAttention.swift:56:82: error: no exact matches in call to initializer
 54 |     ].joined())}
 55 |
 56 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 57 |         [\.qDense, \.kDense, \.vDense, \.fc],
 58 |         norm.parameterPaths.map((\Self.norm).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<MultiHeadAttention<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/PointwiseFeedForward.swift:43:9: error: no exact matches in call to initializer
41 |
42 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {
43 |         Array([
   |         `- error: no exact matches in call to initializer
44 |             dense1.parameterPaths.map((\Self.dense1).appending(path:)),
45 |             dense2.parameterPaths.map((\Self.dense2).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<PointwiseFeedForward<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/Transformer.swift:51:82: error: no exact matches in call to initializer
 49 |     ].joined())}
 50 |
 51 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
    |                                                                                  `- error: no exact matches in call to initializer
 52 |         embedding.parameterPaths.map((\Self.embedding).appending(path:)),
 53 |         encoder.parameterPaths.map((\Self.encoder).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<Transformer<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         decoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.decoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerDecoderBlock.swift:38:82: error: no exact matches in call to initializer
36 |     ].joined())}
37 |
38 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
39 |         selfAttention.parameterPaths.map((\Self.selfAttention).appending(path:)),
40 |         encoderAttention.parameterPaths.map((\Self.encoderAttention).appending(path:)),
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerDecoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/Users/admin/builder/spi-builder-workspace/Sources/DL4S/NN/Models/Transformer/TransformerEncoder.swift:36:82: error: no exact matches in call to initializer
34 |     ].joined())}
35 |
36 |     public var parameterPaths: [WritableKeyPath<Self, Tensor<Element, Device>>] {Array([
   |                                                                                  `- error: no exact matches in call to initializer
37 |         encoderLayers.enumerated().flatMap { (idx, layer) in
38 |             layer.parameterPaths.map((\Self.encoderLayers[idx]).appending(path:))
Swift.Array:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @inlinable public init<S>(_ s: S) where Element == S.Element, S : Sequence
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @inlinable public init<S>(_ elements: S) where S : Sequence, Self.Element == S.Element
   |                       `- note: candidate requires that the types 'WritableKeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoder<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<TransformerEncoderBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<Self, Tensor<Self.Parameter, Self.Device>>' and 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<Self, Tensor<Self.Parameter, Self.Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
[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:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResidualBlock<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<AlexNet<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
/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:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 1 | extension Array : RangeReplaceableCollection {
 2 |     @inlinable public init()
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Element' == 'S.Element')
 4 |     @inlinable public init(repeating repeatedValue: Element, count: Int)
 5 |     @inlinable public mutating func reserveCapacity(_ minimumCapacity: Int)
Swift.RangeReplaceableCollection:3:23: note: candidate requires that the types 'WritableKeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' and 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 1 | extension RangeReplaceableCollection {
 2 |     @inlinable public init(repeating repeatedValue: Self.Element, count: Int)
 3 |     @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 'KeyPath<ResNet18<Element, Device>, Tensor<Element, Device>>' be equivalent (requirement specified as 'Self.Element' == 'S.Element')
 4 |     @inlinable public mutating func append(_ newElement: __owned Self.Element)
 5 |     @inlinable public mutating func append<S>(contentsOf newElements: __owned S) where S : Sequence, Self.Element == S.Element
BUILD FAILURE 6.0 macosSpm