返回不透明返回类型的关联类型

Question

我有一个带有关联类型的简单协议，以及一个返回此类型数组的协议扩展。

protocol Foo {
    associatedtype Unit
}

extension Foo {
    var allTheFoos: [Unit] {
        return []
    }
}

然后我有一个在计算属性中返回 some Foo 的结构，以及另一个返回 allTheFoos 数组的计算属性。

struct FakeFoo: Foo {
    typealias Unit = Int
}

struct FooFactory {
    var myFoo: some Foo {
        return FakeFoo()
    }

    /* WHICH RETURN TYPE WILL
       PLEASE THE SWIFT GODS?!
     */
    var allTheFoos: [Foo.Unit] {
        return myFoo.allTheFoos
    }
}

allTheFoos 的返回类型与 Xcode 对 myFoo.allTheFoos 调用的自动完成类型建议相匹配，但可以理解的是，这会产生：

// var allTheFoos: [Foo.Unit] {}
ERROR: Associated type 'Unit' can only be used with a concrete type or generic parameter base

我的问题是：什么返回类型会让 Xcode 开心？

以下是我的尝试，以及相应的错误

// var allTheFoos: [some Foo.Unit] {}
ERROR: 'some' types are only implemented for the declared type of properties and subscripts and the return type of functions

// func allTheFoos() -> some [Foo.Unit]
ERROR: Associated type 'Unit' can only be used with a concrete type or generic parameter base

// func allTheFoos<U: Foo.Unit>() -> [U]
ERROR: Associated type 'Unit' can only be used with a concrete type or generic parameter base
ERROR: Cannot convert return expression of type '[(some Foo).Unit]' to return type '[U]'

// func allTheFoos<U>() -> [U] where U: (some Foo).Unit
ERROR: 'some' types are only implemented for the declared type of properties and subscripts and the return type of functions

仅供参考：我首先在计算属性中执行此操作的原因是为了在某些 SwiftUI 代码中保持简洁。

感谢您提供的任何帮助！

===========更新============

我在示例代码中遗漏了一些重要的内容，因此提供一些上下文：该代码用于单位转换应用程序，因此可以将摄氏度转换为开尔文，将千克转换为磅，以及将其他任何东西转换为其他任何东西。

protocol Unit: Equatable {
    var suffix: String { get }
}

struct Value<UnitType: Unit> {
    let amount: Double
    let unit: UnitType

    var description: String {
        let formatted = String(format: "%.2f", amount)
        return "\(formatted)\(unit.suffix)"
    }
}

值被限制为单位类型，因此无法将摄氏度转换为升。

因此，我们有一个Conversion 协议将所有相似的单元存储在一起：

protocol Conversion {
    associatedtype UnitType: Unit

    var allUnits: [UnitType] { get }
    func convert(value: Value<UnitType>, to unit: UnitType) -> Value<UnitType>
}

extension Conversion {
    func allConversions(for value: Value<UnitType>) -> [Value<UnitType>] {
        let units = self.allUnits.filter { $0 != value.unit }
        return units.map { convert(value: value, to: $0) }
    }
}

因此，温度转换的示例如下：

struct Temperature: Conversion {
    enum Units: String, Unit, CaseIterable {
        case celsius, farenheit, kelvin

        var suffix: String {
            switch self {
            case .celsius:   return "˚C"
            case .farenheit: return "˚F"
            case .kelvin:    return "K"
            }
        }
    }

    var allUnits: [Units] { return Units.allCases }

    func convert(value: Value<Units>, to unit: Units) -> Value<Units> {
        /* ... */
    }
}

最后，实际出现问题的应用代码在这里：

struct MyApp {
    var current: some Conversion {
        return Temperature()
    }

    // ERROR: Associated type 'UnitType' can only be used with a concrete type or generic parameter base
    var allConversions: [Value<Conversion.UnitType>] {
        // This value is grabbed from the UI
        let amount = 100.0
        let unit = current.allUnits.first!
        let value = Value(amount: amount, unit: unit)

        return current.allConversions(for: value)
    }
}

Answer 1

看看你是如何实现AnyValue的，我想你想要的只是：

var allConversions: [String] {
    let units = self.allUnits.filter { $0 != value.unit }
    return units.map { convert(value: value, to: $0) }.description
}

或者类似的东西。与您所描述的匹配的所有算法都只是“转换->字符串”。如果是这种情况，您真正想要的只是 CustomStringConvertible。

Answer 2

设法使用一些类型擦除解决了这个问题：

struct AnyValue {
    let description: String

    init<U: Unit>(_ value: Value<U>) {
        self.description = value.description
    }
}

允许：

var allConversions: [AnyValue] {
    // This value is grabbed from the UI
    let amount = 100.0
    let unit = current.allUnits.first!
    let value = Value(amount: amount, unit: unit)

    return current.allConversions(for: value).map(AnyValue.init)
}

但是，这感觉像是一种笨拙的解决方案（并且引入了不透明的返回类型来避免这种解决方案）。有没有更好的办法？