DL4S – Build Information – Swift Package Index

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

Build Information

Failed to build DL4S, reference 0.4.1 (1f90f8), with Swift 6.0 for Linux on 28 Nov 2024 07:54:27 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/host -w "$PWD" registry.gitlab.com/finestructure/spi-images:basic-6.0-latest swift build --triple x86_64-unknown-linux-gnu -Xswiftc -Xfrontend -Xswiftc -stats-output-dir -Xswiftc -Xfrontend -Xswiftc .stats -Xswiftc -strict-concurrency=complete -Xswiftc -enable-upcoming-feature -Xswiftc StrictConcurrency -Xswiftc -enable-upcoming-feature -Xswiftc DisableOutwardActorInference -Xswiftc -enable-upcoming-feature -Xswiftc GlobalActorIsolatedTypesUsability -Xswiftc -enable-upcoming-feature -Xswiftc InferSendableFromCaptures 2>&1

Build Log

 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
/host/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 |
[72/81] Compiling DL4S AlexNet.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[73/81] Compiling DL4S ResNet.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[74/81] Compiling DL4S MultiHeadAttention.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[75/81] Compiling DL4S PointwiseFeedForward.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[76/81] Compiling DL4S PositionalEncoding.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[77/81] Compiling DL4S ScaledDotProductAttention.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[78/81] Compiling DL4S Transformer.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[79/81] Compiling DL4S TransformerDecoder.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[80/81] Compiling DL4S TransformerDecoderBlock.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
[81/81] Compiling DL4S TransformerEncoder.swift
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
/host/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
BUILD FAILURE 6.0 linux