14

我正在尝试定义一个需要实现enum原始值的协议String。

我不相信目前可以强制使用enum，而且我不确定我是否真的在乎，只要我可以拨打电话fromRaw()并接收String.

因此，我试图保持以下内容的简洁性，同时将原始值限制Beta为enuma String：

protocol Alpha {
    typealias Beta: RawRepresentable
}

struct Gamma: Alpha {
    enum Beta: String {
        case Delta = "delta"
    }
}

struct Eta<T: Alpha, U: RawRepresentable where T.Beta == U> {
    let alpha: T
    let beta: U
    init(alpha: T, beta: U) {
        self.alpha = alpha
        self.beta = beta
        println("beta is: \(beta.toRaw())")
    }
}

let gamma = Gamma()
Eta(alpha: gamma, beta: .Delta) // "beta is delta"

上述问题是允许其他原始值，因此这是有效的：

struct Epsilon: Alpha {
    enum Beta: Int {
        case Zeta = 6
    }
}

let epsilon = Epsilon()
Eta(alpha: epsilon, beta: .Zeta) // "beta is 6"

为了解决这个问题，我目前正在这样做：

protocol StringRawRepresentable: RawRepresentable {
    class func fromRaw(raw: String) -> Self?
}

protocol Alpha {
    typealias Beta: StringRawRepresentable
}

struct Gamma: Alpha {
    enum Beta: String, StringRawRepresentable {
        case Delta = "delta"
    }
}

// Type 'Epsilon' does not conform to protocol 'Alpha'
struct Epsilon: Alpha {
    enum Beta: Int {
        case Zeta = 6
    }
}

struct Eta<T: Alpha, U: StringRawRepresentable where T.Beta == U> {
    let alpha: T
    let beta: U
    init(alpha: T, beta: U) {
        self.alpha = alpha
        self.beta = beta
        println("beta is: \(beta.toRaw())")
    }
}

let gamma = Gamma()
Eta(alpha: gamma, beta: .Delta) // "beta is delta"

有没有一种方法可以在原始示例中声明typealias不同的限制？RawRepresentableString

更新

指定U: RawRepresentable where U.Raw == String似乎很有希望，所以我试了一下：

protocol Alpha {
    typealias Beta: RawRepresentable
}

struct Gamma: Alpha {
    enum Beta: String {
        case Delta = "delta"
    }
}

struct Eta<T: Alpha, U: RawRepresentable where T.Beta == U, U.Raw == String> {
    let alpha: T
    let beta: U
    init(alpha: T, beta: U) {
        self.alpha = alpha
        self.beta = beta

        // Execution was interrupted, reason: EXC_BAD_ACCESS (code=EXC_I386_GPFLT).
        println("beta is: \(beta.toRaw())")
    }
}

let gamma = Gamma()
Eta(alpha: gamma, beta: .Delta) // "beta is delta"

struct Epsilon: Alpha {
    enum Beta: Int {
        case Zeta = 6
    }
}

let epsilon = Epsilon()
Eta(alpha: epsilon, beta: .Zeta) // Error only occurs when this is executed

虽然这在技术上阻止使用除 a 以外的任何东西String，但我正在寻找编译时约束，这似乎导致运行时异常。

如果可能的话，我也希望由协议强制执行，而不是消费者需要检查.Raw == String

4

4 回答 4

7

只是为了补充一点，因为它有点旧，您更新的示例现在可以在 swift 2+ 中运行，并且会在编译时抱怨 .Zeta 是模棱两可的，除非它是 String 类型。

您还可以将检查放入协议扩展的模式匹配中。举个例子：

extension SequenceType where Generator.Element:RawRepresentable,
                         Generator.Element.RawValue == String {
    func toStringArray() -> [String] {
        return self.map { $0.rawValue }
    }
}
于 2015-12-05T05:47:15.170 回答
2

这现在应该是可能的。例如，以下协议允许类定义自己的符合字符串的“输入”参数枚举：

protocol AttributeContainer {
   associatedtype InputKey: RawRepresentable where InputKey.RawValue: StringProtocol
   func set(value: Any?, for inputKey: InputKey)
}

这可以按如下方式使用：

class MyClass: AttributeContainer {

    enum AttributeKey: String {
       case attributeA, attributeB, attributeC
    }

    func set(value: Any?, for inputKey: InputKey) {
        // Handle the setting of attributes here
    }

}

这类似于 AppleCodingKey在Codable协议中的处理方式。我发现它在做诸如在数据库中存储任意类类型之类的事情时很有用。

于 2018-06-13T08:38:23.973 回答
0

让我们在这里看看我们的选择。首先，它（从 Xcode 6 beta 5 开始）是一个众所周知的限制，我们不能以简单和预期的方式指定枚举类型约束。其次，你需要一些非常清楚的东西：能够调用fromRaw(String). 第三，你想要一个编译器错误。我想说你最好的选择是编写一个协议来做到这一点，并向消费者下达确保他/她给你一个fromRaw(String). 在这种情况下，这就是我要做的，简化您的第二个代码片段：

protocol Alpha {
    typealias Beta: RawRepresentable
    func fromRaw(raw: String) -> Beta?
}

struct Gamma: Alpha {
    enum Beta: String {
        case Delta = "delta"
        case Omega = "omega"
    }
    func fromRaw(raw: String) -> Beta? {
        return Beta.fromRaw(raw)
    }
}

struct Eta<T: Alpha, U: RawRepresentable where T.Beta == U> {
    let alpha: T
    let beta: U
    init(alpha: T, beta: U) {
        self.alpha = alpha
        self.beta = beta
        println("beta is: \(beta.toRaw())")
    }
}

let gamma = Gamma()
let a = Eta(alpha: gamma, beta: .Delta) // "beta is delta"
println(gamma.fromRaw("delta"))  // Optional(Enum Value)
println(gamma.fromRaw("omega")!) // Enum Value

从哲学上讲，这更符合您的需求：您说“我想要的东西不仅是 RawRepresentable，还想要一个fromRaw(String)。弄清楚你如何给我它”。Gamma 结构是最简单的例子，消费者详细说明他的枚举，然后说“好的，我可以给你我的标准fromRaw()，因为它有效。

于 2014-08-10T17:09:34.817 回答
0

我和一位同事讨论了这一点，在 Swift 2.0/2.1 中，您可以使用协议执行此操作：https ://gist.github.com/designatednerd/5645d286df0ce939714b

在我正在使用的应用程序中试用它，就像一个魅力。:)

于 2015-10-27T22:45:18.127 回答