composable-core-motion – Build Information

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 composable-core-motion, reference main (e06c2f), with Swift 6.0 for macOS (SPM) on 28 Nov 2024 05:22:07 UTC.

Build Command

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

Build Log

    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:361:10: error: @escaping attribute only applies to function types
359 |     isMagnetometerAvailable: @escaping (AnyHashable) -> Bool,
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
    |          `- error: @escaping attribute only applies to function types
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
363 |       AccelerometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:75: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:32: error: @escaping attribute only applies to function types
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                `- error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:366:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
    |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:365:31: error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
    |                               `- error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:23: error: @escaping attribute only applies to function types
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                       `- error: @escaping attribute only applies to function types
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:74: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:31: error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                               `- error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:31: error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                               `- error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:30: error: @escaping attribute only applies to function types
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                              `- error: @escaping attribute only applies to function types
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:22: error: @escaping attribute only applies to function types
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                      `- error: @escaping attribute only applies to function types
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:30: error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                              `- error: @escaping attribute only applies to function types
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:429:32: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
427 |   /// Returns a bitmask specifying the available attitude reference frames on the device.
428 |   var availableAttitudeReferenceFrames: () -> CMAttitudeReferenceFrame
429 |   var create: (AnyHashable) -> Effect<Never, Never>
    |                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
430 |   var destroy: (AnyHashable) -> Effect<Never, Never>
431 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:430:33: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
428 |   var availableAttitudeReferenceFrames: () -> CMAttitudeReferenceFrame
429 |   var create: (AnyHashable) -> Effect<Never, Never>
430 |   var destroy: (AnyHashable) -> Effect<Never, Never>
    |                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
431 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
432 |   var gyroData: (AnyHashable) -> GyroData?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:442:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
440 |   var isMagnetometerAvailable: (AnyHashable) -> Bool
441 |   var magnetometerData: (AnyHashable) -> MagnetometerData?
442 |   var set: (AnyHashable, Properties) -> Effect<Never, Never>
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
444 |   var startDeviceMotionUpdates:
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:443:67: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
441 |   var magnetometerData: (AnyHashable) -> MagnetometerData?
442 |   var set: (AnyHashable, Properties) -> Effect<Never, Never>
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
    |                                                                   `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:445:64: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
    |                                                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:446:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:447:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:448:50: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:449:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:450:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
452 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:451:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
452 | }
453 |
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:11:21: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
  9 | @available(watchOS 2, *)
 10 | extension MotionManager {
 11 |   public static let live = MotionManager(
    |                     `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 12 |     accelerometerData: { id in
 13 |       requireMotionManager(id: id)?.accelerometerData.map(AccelerometerData.init)
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:235:22: warning: static property 'managers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
233 |     })
234 |
235 |   private static var managers: [AnyHashable: CMMotionManager] = [:]
    |                      |- warning: static property 'managers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                      |- note: convert 'managers' to a 'let' constant to make 'Sendable' shared state immutable
    |                      |- note: annotate 'managers' with '@MainActor' if property should only be accessed from the main actor
    |                      `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
236 |
237 |   private static func requireMotionManager(id: AnyHashable) -> CMMotionManager? {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:246:17: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
244 |
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
    |                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:245:13: warning: var 'accelerometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
243 | }
244 |
245 | private var accelerometerUpdatesSubscribers:
    |             |- warning: var 'accelerometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'accelerometerUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'accelerometerUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:247:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
    |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:247:13: warning: var 'deviceMotionUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
    |             |- warning: var 'deviceMotionUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceMotionUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceMotionUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:249:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:249:13: warning: var 'deviceGyroUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
    |             |- warning: var 'deviceGyroUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceGyroUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceGyroUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:251:17: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
    |                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
252 |
253 | private func couldNotFindMotionManager(id: Any) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:250:13: warning: var 'deviceMagnetometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
250 | private var deviceMagnetometerUpdatesSubscribers:
    |             |- warning: var 'deviceMagnetometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceMagnetometerUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceMagnetometerUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
252 |
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:19:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 17 |       _unimplemented("availableAttitudeReferenceFrames")
 18 |     },
 19 |     create: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("create") },
    |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 20 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
 21 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:19:13: error: @escaping attribute only applies to function types
 17 |       _unimplemented("availableAttitudeReferenceFrames")
 18 |     },
 19 |     create: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("create") },
    |             `- error: @escaping attribute only applies to function types
 20 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
 21 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:20:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 18 |     },
 19 |     create: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("create") },
 20 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 21 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
 22 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:20:14: error: @escaping attribute only applies to function types
 18 |     },
 19 |     create: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("create") },
 20 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
    |              `- error: @escaping attribute only applies to function types
 21 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
 22 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:47:63: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 45 |       _unimplemented("magnetometerData")
 46 |     },
 47 |     set: @escaping (AnyHashable, MotionManager.Properties) -> Effect<Never, Never> = { _, _ in
    |                                                               `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 48 |       _unimplemented("set")
 49 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:47:10: error: @escaping attribute only applies to function types
 45 |       _unimplemented("magnetometerData")
 46 |     },
 47 |     set: @escaping (AnyHashable, MotionManager.Properties) -> Effect<Never, Never> = { _, _ in
    |          `- error: @escaping attribute only applies to function types
 48 |       _unimplemented("set")
 49 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:50:75: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 48 |       _unimplemented("set")
 49 |     },
 50 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 51 |       AccelerometerData, Error
 52 |     > = { _, _ in _unimplemented("startAccelerometerUpdates") },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:50:32: error: @escaping attribute only applies to function types
 48 |       _unimplemented("set")
 49 |     },
 50 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                `- error: @escaping attribute only applies to function types
 51 |       AccelerometerData, Error
 52 |     > = { _, _ in _unimplemented("startAccelerometerUpdates") },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:54:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 52 |     > = { _, _ in _unimplemented("startAccelerometerUpdates") },
 53 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
 54 |       Effect<DeviceMotion, Error> = { _, _, _ in _unimplemented("startDeviceMotionUpdates") },
    |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 55 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error> = {
 56 |       _, _ in
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:53:31: error: @escaping attribute only applies to function types
 51 |       AccelerometerData, Error
 52 |     > = { _, _ in _unimplemented("startAccelerometerUpdates") },
 53 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
    |                               `- error: @escaping attribute only applies to function types
 54 |       Effect<DeviceMotion, Error> = { _, _, _ in _unimplemented("startDeviceMotionUpdates") },
 55 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error> = {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:55:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 53 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
 54 |       Effect<DeviceMotion, Error> = { _, _, _ in _unimplemented("startDeviceMotionUpdates") },
 55 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error> = {
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 56 |       _, _ in
 57 |       _unimplemented("startGyroUpdates")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:55:23: error: @escaping attribute only applies to function types
 53 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
 54 |       Effect<DeviceMotion, Error> = { _, _, _ in _unimplemented("startDeviceMotionUpdates") },
 55 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error> = {
    |                       `- error: @escaping attribute only applies to function types
 56 |       _, _ in
 57 |       _unimplemented("startGyroUpdates")
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:59:74: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 57 |       _unimplemented("startGyroUpdates")
 58 |     },
 59 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 60 |       MagnetometerData, Error
 61 |     > = { _, _ in _unimplemented("startMagnetometerUpdates") },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:59:31: error: @escaping attribute only applies to function types
 57 |       _unimplemented("startGyroUpdates")
 58 |     },
 59 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                               `- error: @escaping attribute only applies to function types
 60 |       MagnetometerData, Error
 61 |     > = { _, _ in _unimplemented("startMagnetometerUpdates") },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:62:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 60 |       MagnetometerData, Error
 61 |     > = { _, _ in _unimplemented("startMagnetometerUpdates") },
 62 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 63 |       _unimplemented("stopAccelerometerUpdates")
 64 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:62:31: error: @escaping attribute only applies to function types
 60 |       MagnetometerData, Error
 61 |     > = { _, _ in _unimplemented("startMagnetometerUpdates") },
 62 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                               `- error: @escaping attribute only applies to function types
 63 |       _unimplemented("stopAccelerometerUpdates")
 64 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:65:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 63 |       _unimplemented("stopAccelerometerUpdates")
 64 |     },
 65 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 66 |       _unimplemented("stopDeviceMotionUpdates")
 67 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:65:30: error: @escaping attribute only applies to function types
 63 |       _unimplemented("stopAccelerometerUpdates")
 64 |     },
 65 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                              `- error: @escaping attribute only applies to function types
 66 |       _unimplemented("stopDeviceMotionUpdates")
 67 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:68:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 66 |       _unimplemented("stopDeviceMotionUpdates")
 67 |     },
 68 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 69 |       _unimplemented("stopGyroUpdates")
 70 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:68:22: error: @escaping attribute only applies to function types
 66 |       _unimplemented("stopDeviceMotionUpdates")
 67 |     },
 68 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                      `- error: @escaping attribute only applies to function types
 69 |       _unimplemented("stopGyroUpdates")
 70 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:71:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 69 |       _unimplemented("stopGyroUpdates")
 70 |     },
 71 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 72 |       _unimplemented("stopMagnetometerUpdates")
 73 |     }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerMock.swift:71:30: error: @escaping attribute only applies to function types
 69 |       _unimplemented("stopGyroUpdates")
 70 |     },
 71 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
    |                              `- error: @escaping attribute only applies to function types
 72 |       _unimplemented("stopMagnetometerUpdates")
 73 |     }
[304/309] Compiling ComposableCoreMotion MotionManagerLive.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:348:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
346 |     attitudeReferenceFrame: @escaping (AnyHashable) -> CMAttitudeReferenceFrame,
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:348:13: error: @escaping attribute only applies to function types
346 |     attitudeReferenceFrame: @escaping (AnyHashable) -> CMAttitudeReferenceFrame,
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
    |             `- error: @escaping attribute only applies to function types
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:349:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
351 |     gyroData: @escaping (AnyHashable) -> GyroData?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:349:14: error: @escaping attribute only applies to function types
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
    |              `- error: @escaping attribute only applies to function types
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
351 |     gyroData: @escaping (AnyHashable) -> GyroData?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:361:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
359 |     isMagnetometerAvailable: @escaping (AnyHashable) -> Bool,
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
363 |       AccelerometerData, Error
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:361:10: error: @escaping attribute only applies to function types
359 |     isMagnetometerAvailable: @escaping (AnyHashable) -> Bool,
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
    |          `- error: @escaping attribute only applies to function types
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
363 |       AccelerometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:75: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:32: error: @escaping attribute only applies to function types
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                `- error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:366:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
    |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:365:31: error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
    |                               `- error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:23: error: @escaping attribute only applies to function types
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                       `- error: @escaping attribute only applies to function types
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:74: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:31: error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                               `- error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:31: error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                               `- error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:30: error: @escaping attribute only applies to function types
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                              `- error: @escaping attribute only applies to function types
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:22: error: @escaping attribute only applies to function types
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                      `- error: @escaping attribute only applies to function types
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:30: error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                              `- error: @escaping attribute only applies to function types
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:11:21: error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
  9 | @available(watchOS 2, *)
 10 | extension MotionManager {
 11 |   public static let live = MotionManager(
    |                     `- error: the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions
 12 |     accelerometerData: { id in
 13 |       requireMotionManager(id: id)?.accelerometerData.map(AccelerometerData.init)
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:235:22: warning: static property 'managers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
233 |     })
234 |
235 |   private static var managers: [AnyHashable: CMMotionManager] = [:]
    |                      |- warning: static property 'managers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |                      |- note: convert 'managers' to a 'let' constant to make 'Sendable' shared state immutable
    |                      |- note: annotate 'managers' with '@MainActor' if property should only be accessed from the main actor
    |                      `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
236 |
237 |   private static func requireMotionManager(id: AnyHashable) -> CMMotionManager? {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:246:17: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
244 |
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
    |                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:245:13: warning: var 'accelerometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
243 | }
244 |
245 | private var accelerometerUpdatesSubscribers:
    |             |- warning: var 'accelerometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'accelerometerUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'accelerometerUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:247:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
    |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:247:13: warning: var 'deviceMotionUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
245 | private var accelerometerUpdatesSubscribers:
246 |   [AnyHashable: Effect<AccelerometerData, Error>.Subscriber] = [:]
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
    |             |- warning: var 'deviceMotionUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceMotionUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceMotionUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:249:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:249:13: warning: var 'deviceGyroUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
247 | private var deviceMotionUpdatesSubscribers: [AnyHashable: Effect<DeviceMotion, Error>.Subscriber] =
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
    |             |- warning: var 'deviceGyroUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceGyroUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceGyroUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:251:17: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
250 | private var deviceMagnetometerUpdatesSubscribers:
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
    |                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
252 |
253 | private func couldNotFindMotionManager(id: Any) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerLive.swift:250:13: warning: var 'deviceMagnetometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
248 |   [:]
249 | private var deviceGyroUpdatesSubscribers: [AnyHashable: Effect<GyroData, Error>.Subscriber] = [:]
250 | private var deviceMagnetometerUpdatesSubscribers:
    |             |- warning: var 'deviceMagnetometerUpdatesSubscribers' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode
    |             |- note: convert 'deviceMagnetometerUpdatesSubscribers' to a 'let' constant to make 'Sendable' shared state immutable
    |             |- note: annotate 'deviceMagnetometerUpdatesSubscribers' with '@MainActor' if property should only be accessed from the main actor
    |             `- note: disable concurrency-safety checks if accesses are protected by an external synchronization mechanism
251 |   [AnyHashable: Effect<MagnetometerData, Error>.Subscriber] = [:]
252 |
[305/309] Compiling ComposableCoreMotion MotionManagerInterface.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:190:42: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
188 |   /// A motion manager must be first created before you can use its functionality, such as starting
189 |   /// device motion updates or accessing data directly from the manager.
190 |   public func create(id: AnyHashable) -> Effect<Never, Never> {
    |                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
191 |     self.create(id)
192 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:198:43: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
196 |   /// In is good practice to destroy a motion manager once you are done with it, such as when you
197 |   /// leave a screen or no longer need motion data.
198 |   public func destroy(id: AnyHashable) -> Effect<Never, Never> {
    |                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
199 |     self.destroy(id)
200 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:266:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
264 |     magnetometerUpdateInterval: TimeInterval? = nil,
265 |     showsDeviceMovementDisplay: Bool? = nil
266 |   ) -> Effect<Never, Never> {
    |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
267 |     self.set(
268 |       id,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:286:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
284 |     id: AnyHashable,
285 |     to queue: OperationQueue = .main
286 |   ) -> Effect<AccelerometerData, Error> {
    |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
287 |     self.startAccelerometerUpdates(id, queue)
288 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:298:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
296 |     using referenceFrame: CMAttitudeReferenceFrame,
297 |     to queue: OperationQueue = .main
298 |   ) -> Effect<DeviceMotion, Error> {
    |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
299 |     self.startDeviceMotionUpdates(id, referenceFrame, queue)
300 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:309:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
307 |     id: AnyHashable,
308 |     to queue: OperationQueue = .main
309 |   ) -> Effect<GyroData, Error> {
    |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
310 |     self.startGyroUpdates(id, queue)
311 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:320:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
318 |     id: AnyHashable,
319 |     to queue: OperationQueue = .main
320 |   ) -> Effect<MagnetometerData, Error> {
    |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
321 |     self.startMagnetometerUpdates(id, queue)
322 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:325:60: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
323 |
324 |   /// Stops accelerometer updates.
325 |   public func stopAccelerometerUpdates(id: AnyHashable) -> Effect<Never, Never> {
    |                                                            `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
326 |     self.stopAccelerometerUpdates(id)
327 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:330:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
328 |
329 |   /// Stops device-motion updates.
330 |   public func stopDeviceMotionUpdates(id: AnyHashable) -> Effect<Never, Never> {
    |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
331 |     self.stopDeviceMotionUpdates(id)
332 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:335:51: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
333 |
334 |   /// Stops gyroscope updates.
335 |   public func stopGyroUpdates(id: AnyHashable) -> Effect<Never, Never> {
    |                                                   `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
336 |     self.stopGyroUpdates(id)
337 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:340:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
338 |
339 |   /// Stops magnetometer updates.
340 |   public func stopMagnetometerUpdates(id: AnyHashable) -> Effect<Never, Never> {
    |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
341 |     self.stopMagnetometerUpdates(id)
342 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:348:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
346 |     attitudeReferenceFrame: @escaping (AnyHashable) -> CMAttitudeReferenceFrame,
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:348:13: error: @escaping attribute only applies to function types
346 |     attitudeReferenceFrame: @escaping (AnyHashable) -> CMAttitudeReferenceFrame,
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
    |             `- error: @escaping attribute only applies to function types
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:349:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
351 |     gyroData: @escaping (AnyHashable) -> GyroData?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:349:14: error: @escaping attribute only applies to function types
347 |     availableAttitudeReferenceFrames: @escaping () -> CMAttitudeReferenceFrame,
348 |     create: @escaping (AnyHashable) -> Effect<Never, Never>,
349 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
    |              `- error: @escaping attribute only applies to function types
350 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
351 |     gyroData: @escaping (AnyHashable) -> GyroData?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:361:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
359 |     isMagnetometerAvailable: @escaping (AnyHashable) -> Bool,
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
363 |       AccelerometerData, Error
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:361:10: error: @escaping attribute only applies to function types
359 |     isMagnetometerAvailable: @escaping (AnyHashable) -> Bool,
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
    |          `- error: @escaping attribute only applies to function types
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
363 |       AccelerometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:75: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:362:32: error: @escaping attribute only applies to function types
360 |     magnetometerData: @escaping (AnyHashable) -> MagnetometerData?,
361 |     set: @escaping (AnyHashable, Properties) -> Effect<Never, Never>,
362 |     startAccelerometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                `- error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:366:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
    |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:365:31: error: @escaping attribute only applies to function types
363 |       AccelerometerData, Error
364 |     >,
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
    |                               `- error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:367:23: error: @escaping attribute only applies to function types
365 |     startDeviceMotionUpdates: @escaping (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) ->
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
    |                       `- error: @escaping attribute only applies to function types
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
369 |       MagnetometerData, Error
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:74: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:368:31: error: @escaping attribute only applies to function types
366 |       Effect<DeviceMotion, Error>,
367 |     startGyroUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<GyroData, Error>,
368 |     startMagnetometerUpdates: @escaping (AnyHashable, OperationQueue) -> Effect<
    |                               `- error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:371:31: error: @escaping attribute only applies to function types
369 |       MagnetometerData, Error
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                               `- error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:372:30: error: @escaping attribute only applies to function types
370 |     >,
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                              `- error: @escaping attribute only applies to function types
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:373:22: error: @escaping attribute only applies to function types
371 |     stopAccelerometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
    |                      `- error: @escaping attribute only applies to function types
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
375 |   ) {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:374:30: error: @escaping attribute only applies to function types
372 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
373 |     stopGyroUpdates: @escaping (AnyHashable) -> Effect<Never, Never>,
374 |     stopMagnetometerUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
    |                              `- error: @escaping attribute only applies to function types
375 |   ) {
376 |     self.accelerometerData = accelerometerData
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:429:32: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
427 |   /// Returns a bitmask specifying the available attitude reference frames on the device.
428 |   var availableAttitudeReferenceFrames: () -> CMAttitudeReferenceFrame
429 |   var create: (AnyHashable) -> Effect<Never, Never>
    |                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
430 |   var destroy: (AnyHashable) -> Effect<Never, Never>
431 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:430:33: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
428 |   var availableAttitudeReferenceFrames: () -> CMAttitudeReferenceFrame
429 |   var create: (AnyHashable) -> Effect<Never, Never>
430 |   var destroy: (AnyHashable) -> Effect<Never, Never>
    |                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
431 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
432 |   var gyroData: (AnyHashable) -> GyroData?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:442:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
440 |   var isMagnetometerAvailable: (AnyHashable) -> Bool
441 |   var magnetometerData: (AnyHashable) -> MagnetometerData?
442 |   var set: (AnyHashable, Properties) -> Effect<Never, Never>
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
444 |   var startDeviceMotionUpdates:
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:443:67: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
441 |   var magnetometerData: (AnyHashable) -> MagnetometerData?
442 |   var set: (AnyHashable, Properties) -> Effect<Never, Never>
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
    |                                                                   `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:445:64: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
443 |   var startAccelerometerUpdates: (AnyHashable, OperationQueue) -> Effect<AccelerometerData, Error>
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
    |                                                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:446:58: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
444 |   var startDeviceMotionUpdates:
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
    |                                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:447:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
445 |     (AnyHashable, CMAttitudeReferenceFrame, OperationQueue) -> Effect<DeviceMotion, Error>
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
    |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:448:50: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
446 |   var startGyroUpdates: (AnyHashable, OperationQueue) -> Effect<GyroData, Error>
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:449:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
447 |   var startMagnetometerUpdates: (AnyHashable, OperationQueue) -> Effect<MagnetometerData, Error>
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:450:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
448 |   var stopAccelerometerUpdates: (AnyHashable) -> Effect<Never, Never>
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
452 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/MotionManager/MotionManagerInterface.swift:451:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
449 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
450 |   var stopGyroUpdates: (AnyHashable) -> Effect<Never, Never>
451 |   var stopMagnetometerUpdates: (AnyHashable) -> Effect<Never, Never>
    |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
452 | }
453 |
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
[306/309] Compiling ComposableCoreMotion HeadphoneMotionManagerMock.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:10:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 8 | extension HeadphoneMotionManager {
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:10:13: error: @escaping attribute only applies to function types
 8 | extension HeadphoneMotionManager {
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
   |             `- error: @escaping attribute only applies to function types
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:11:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
13 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:11:14: error: @escaping attribute only applies to function types
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
   |              `- error: @escaping attribute only applies to function types
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
13 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:21:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
19 |     },
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
23 |       _unimplemented("stopDeviceMotionUpdates")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:20:31: error: @escaping attribute only applies to function types
18 |       _unimplemented("isDeviceMotionAvailable")
19 |     },
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:22:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
23 |       _unimplemented("stopDeviceMotionUpdates")
24 |     }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:22:30: error: @escaping attribute only applies to function types
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
   |                              `- error: @escaping attribute only applies to function types
23 |       _unimplemented("stopDeviceMotionUpdates")
24 |     }
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:13: error: @escaping attribute only applies to function types
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |             `- error: @escaping attribute only applies to function types
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:14: error: @escaping attribute only applies to function types
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |              `- error: @escaping attribute only applies to function types
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:77:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
79 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:76:31: error: @escaping attribute only applies to function types
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:30: error: @escaping attribute only applies to function types
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                              `- error: @escaping attribute only applies to function types
79 |   ) {
80 |     self.create = create
[307/309] Compiling ComposableCoreMotion Exports.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:10:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 8 | extension HeadphoneMotionManager {
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:10:13: error: @escaping attribute only applies to function types
 8 | extension HeadphoneMotionManager {
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
   |             `- error: @escaping attribute only applies to function types
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:11:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
13 |     },
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:11:14: error: @escaping attribute only applies to function types
 9 |   public static func unimplemented(
10 |     create: @escaping (AnyHashable) -> Effect<Action, Never> = { _ in _unimplemented("create") },
11 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in _unimplemented("destroy") },
   |              `- error: @escaping attribute only applies to function types
12 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion? = { _ in _unimplemented("deviceMotion")
13 |     },
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:21:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
19 |     },
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
23 |       _unimplemented("stopDeviceMotionUpdates")
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:20:31: error: @escaping attribute only applies to function types
18 |       _unimplemented("isDeviceMotionAvailable")
19 |     },
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:22:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
23 |       _unimplemented("stopDeviceMotionUpdates")
24 |     }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerMock.swift:22:30: error: @escaping attribute only applies to function types
20 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
21 |       Effect<DeviceMotion, Error> = { _, _ in _unimplemented("startDeviceMotionUpdates") },
22 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never> = { _ in
   |                              `- error: @escaping attribute only applies to function types
23 |       _unimplemented("stopDeviceMotionUpdates")
24 |     }
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:13: error: @escaping attribute only applies to function types
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |             `- error: @escaping attribute only applies to function types
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:14: error: @escaping attribute only applies to function types
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |              `- error: @escaping attribute only applies to function types
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:77:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
79 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:76:31: error: @escaping attribute only applies to function types
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:30: error: @escaping attribute only applies to function types
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                              `- error: @escaping attribute only applies to function types
79 |   ) {
80 |     self.create = create
[308/309] Compiling ComposableCoreMotion HeadphoneMotionManagerInterface.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:26:42: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
24 |   /// A motion manager must be first created before you can use its functionality, such as
25 |   /// starting device motion updates or accessing data directly from the manager.
26 |   public func create(id: AnyHashable) -> Effect<Action, Never> {
   |                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
27 |     self.create(id)
28 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:34:43: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
32 |   /// In is good practice to destroy a headphone motion manager once you are done with it, such as
33 |   /// when you leave a screen or no longer need motion data.
34 |   public func destroy(id: AnyHashable) -> Effect<Never, Never> {
   |                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
35 |     self.destroy(id)
36 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:61:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
59 |     id: AnyHashable,
60 |     to queue: OperationQueue = .main
61 |   ) -> Effect<DeviceMotion, Error> {
   |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
62 |     self.startDeviceMotionUpdates(id, queue)
63 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:66:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
64 |
65 |   /// Stops device-motion updates.
66 |   public func stopDeviceMotionUpdates(id: AnyHashable) -> Effect<Never, Never> {
   |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
67 |     self.stopDeviceMotionUpdates(id)
68 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:13: error: @escaping attribute only applies to function types
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |             `- error: @escaping attribute only applies to function types
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:14: error: @escaping attribute only applies to function types
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |              `- error: @escaping attribute only applies to function types
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:77:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
79 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:76:31: error: @escaping attribute only applies to function types
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:30: error: @escaping attribute only applies to function types
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                              `- error: @escaping attribute only applies to function types
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:89:32: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
87 |   }
88 |
89 |   var create: (AnyHashable) -> Effect<Action, Never>
   |                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
90 |   var destroy: (AnyHashable) -> Effect<Never, Never>
91 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:90:33: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
88 |
89 |   var create: (AnyHashable) -> Effect<Action, Never>
90 |   var destroy: (AnyHashable) -> Effect<Never, Never>
   |                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
91 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
92 |   var isDeviceMotionActive: (AnyHashable) -> Bool
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:94:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
92 |   var isDeviceMotionActive: (AnyHashable) -> Bool
93 |   var isDeviceMotionAvailable: (AnyHashable) -> Bool
94 |   var startDeviceMotionUpdates: (AnyHashable, OperationQueue) -> Effect<DeviceMotion, Error>
   |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
95 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
96 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:95:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
93 |   var isDeviceMotionAvailable: (AnyHashable) -> Bool
94 |   var startDeviceMotionUpdates: (AnyHashable, OperationQueue) -> Effect<DeviceMotion, Error>
95 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
   |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
96 | }
97 |
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
[309/309] Compiling ComposableCoreMotion HeadphoneMotionManagerLive.swift
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:26:42: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
24 |   /// A motion manager must be first created before you can use its functionality, such as
25 |   /// starting device motion updates or accessing data directly from the manager.
26 |   public func create(id: AnyHashable) -> Effect<Action, Never> {
   |                                          `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
27 |     self.create(id)
28 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:34:43: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
32 |   /// In is good practice to destroy a headphone motion manager once you are done with it, such as
33 |   /// when you leave a screen or no longer need motion data.
34 |   public func destroy(id: AnyHashable) -> Effect<Never, Never> {
   |                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
35 |     self.destroy(id)
36 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:61:8: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
59 |     id: AnyHashable,
60 |     to queue: OperationQueue = .main
61 |   ) -> Effect<DeviceMotion, Error> {
   |        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
62 |     self.startDeviceMotionUpdates(id, queue)
63 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:66:59: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
64 |
65 |   /// Stops device-motion updates.
66 |   public func stopDeviceMotionUpdates(id: AnyHashable) -> Effect<Never, Never> {
   |                                                           `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
67 |     self.stopDeviceMotionUpdates(id)
68 |   }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:40: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |                                        `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:71:13: error: @escaping attribute only applies to function types
69 |
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
   |             `- error: @escaping attribute only applies to function types
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:41: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:72:14: error: @escaping attribute only applies to function types
70 |   public init(
71 |     create: @escaping (AnyHashable) -> Effect<Action, Never>,
72 |     destroy: @escaping (AnyHashable) -> Effect<Never, Never>,
   |              `- error: @escaping attribute only applies to function types
73 |     deviceMotion: @escaping (AnyHashable) -> DeviceMotion?,
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:77:7: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
   |       `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
79 |   ) {
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:76:31: error: @escaping attribute only applies to function types
74 |     isDeviceMotionActive: @escaping (AnyHashable) -> Bool,
75 |     isDeviceMotionAvailable: @escaping (AnyHashable) -> Bool,
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
   |                               `- error: @escaping attribute only applies to function types
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:57: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                                                         `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:78:30: error: @escaping attribute only applies to function types
76 |     startDeviceMotionUpdates: @escaping (AnyHashable, OperationQueue) ->
77 |       Effect<DeviceMotion, Error>,
78 |     stopDeviceMotionUpdates: @escaping (AnyHashable) -> Effect<Never, Never>
   |                              `- error: @escaping attribute only applies to function types
79 |   ) {
80 |     self.create = create
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:89:32: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
87 |   }
88 |
89 |   var create: (AnyHashable) -> Effect<Action, Never>
   |                                `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
90 |   var destroy: (AnyHashable) -> Effect<Never, Never>
91 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:90:33: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
88 |
89 |   var create: (AnyHashable) -> Effect<Action, Never>
90 |   var destroy: (AnyHashable) -> Effect<Never, Never>
   |                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
91 |   var deviceMotion: (AnyHashable) -> DeviceMotion?
92 |   var isDeviceMotionActive: (AnyHashable) -> Bool
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:94:66: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
92 |   var isDeviceMotionActive: (AnyHashable) -> Bool
93 |   var isDeviceMotionAvailable: (AnyHashable) -> Bool
94 |   var startDeviceMotionUpdates: (AnyHashable, OperationQueue) -> Effect<DeviceMotion, Error>
   |                                                                  `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
95 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
96 | }
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
/Users/admin/builder/spi-builder-workspace/Sources/ComposableCoreMotion/HeadphoneMotionManager/HeadphoneMotionManagerInterface.swift:95:49: error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
93 |   var isDeviceMotionAvailable: (AnyHashable) -> Bool
94 |   var startDeviceMotionUpdates: (AnyHashable, OperationQueue) -> Effect<DeviceMotion, Error>
95 |   var stopDeviceMotionUpdates: (AnyHashable) -> Effect<Never, Never>
   |                                                 `- error: generic type 'Effect' specialized with too many type parameters (got 2, but expected 1)
96 | }
97 |
/Users/admin/builder/spi-builder-workspace/.build/checkouts/swift-composable-architecture/Sources/ComposableArchitecture/Effect.swift:127:18: note: generic type 'Effect' declared here
125 | /// > above. If you are using Swift's concurrency tools and the `.run` function on ``Effect``,
126 | /// > then threading is automatically handled for you.
127 | public typealias Effect<Action> = EffectPublisher<Action, Never>
    |                  `- note: generic type 'Effect' declared here
128 |
129 | extension EffectPublisher where Failure == Never {
BUILD FAILURE 6.0 macosSpm