Swift：枚举协议不起作用

Question

我需要一个枚举的协议定义的一部分是将一个以“self”作为关键字的字典。所以这是我第一次尝试：

protocol Orderable {        // line 1 
    class var first: Self { get } 
    class var last: Self { get } 
    class var strings: [Self : String] { get }  // line 4 
} 

enum Item : Int, Orderable { 
    case ItemA = 0, ItemB, ItemC 
    static let last : Item = Item.ItemC 

    var name : String { return Item.strings[self]! } 

    static let strings: [Item : String] = [ 
     .Item1: "item no. 1", .Item2 : "item no. 2", .Item3: "Item no. 3" 
    ] 
} 

println ("last item is: \(Item.last.name)") // ==> "last item is: item no. 3" 

这未能在第4行出现错误：

型“自我”不符合协议“哈希的”

为了解决这个问题，我试图从Hashable继承Orderable，如下所示：

protocol Orderable : Hashable { ... } 

但是，当我尝试该操作时，Playground崩溃。

这是问题的正确解决方案吗？

Answer 1

操作系统崩溃的问题与Orderable协议没有太大的关系，但更多与您的Item枚举相关。的确，Orderable需要执行Hashable才能正常工作，但是您在Playground中看到的问题更多的是由于Item未正确执行Orderable。当代码写得不对时，游乐场还是相当不稳定的，所以对我来说它并没有让你感到惊讶。

因此，要解决该编译器的bug在Xcode 6.0，你需要做到以下几点：

注：如果您使用的Xcode 6.1，看到更新。

在你Orderable协议，您已经定义first，last，并strings为只读属性计算的，但你将它们定义为读写存储在Item枚举属性。另外，你忽略了完全实现你的first属性。

而不是定义last，例如，作为：

static let last : Item = Item.ItemC 

它需要与表达被定义为var该return小号Item.ItemC：

static var last : Item { return Item.ItemC } 

相同的基本思想可以是适用于first和strings。

而且，在你的strings财产，你已经使用.Item1，.Item2，并.Item3，而不是.ItemA，.ItemB和.ItemC。

因此，如果我们解决了所有我们得到：

protocol Orderable: Hashable { 
    class var first: Self { get } 
    class var last: Self { get } 
    class var strings: [Self : String] { get } 
} 

enum Item : Int, Orderable { 
    case ItemA = 0, ItemB, ItemC 

    static var first: Item { return .ItemA } 
    static var last : Item { return .ItemC } 
    static var strings: [Item: String] { 
     return [ 
      .ItemA: "item no. 1", .ItemB : "item no. 2", .ItemC: "Item no. 3" 
     ] 
    } 

    var name : String { return Item.strings[self]! } 
} 

，与此快速测试很好地工作：

println("last item is: \(Item.last.name)") 
println("first item is: \(Item.first.name)") 
println("item B is \(Item.strings[Item.ItemB])") 

输出：

last item is: Item no. 3

first item is: item no. 1

item B is Optional("item no. 2")

---

更新：正如@David在评论中指出的那样，我上面关于在Item中实现Orderable协议属性的说法似乎只是Xcode 6.0中的一个问题。在Xcode 6.1中，以最初的方式实现属性是完全合理的。在Xcode 6.1操场，这工作得很好：

protocol Orderable: Hashable { 
    class var first: Self { get } 
    class var last: Self { get } 
    class var strings: [Self : String] { get } 
} 

enum Item : Int, Orderable { 
    case ItemA = 0, ItemB, ItemC 

    static var first: Item = .ItemA 
    static var last : Item = .ItemC 
    static var strings: [Item: String] = [ 
     .ItemA: "item no. 1", .ItemB : "item no. 2", .ItemC: "Item no. 3" 
    ] 

    var name : String { return Item.strings[self]! } 
} 

Answer 2

protocol ExampleProtocol { 
    var simpleDescription: String { get } 
    mutating func adjust() 
} 

enum SimpleEnum : ExampleProtocol { 
    case enumMember(String) 
     var simpleDescription: String { 
      get { 
       switch self { 
        case let .enumMember(descript): 
         return descript 
       } 
      } 
    } 
    mutating func adjust() { 
     switch self { 
      case let .enumMember(desc): 
       self = .enumMember(desc + " (adjusted)") 
     } 
    } 
} 

var c = SimpleEnum.enumMember("A simple enum.") 
var csimpleDescription = c.simpleDescription 
c.adjust() 
var dsimpleDescription = c.simpleDescription