與詮釋

Question

可比枚舉比較它有一個Int爲原始值我已經添加了枚舉：

func <<T: RawRepresentable>(a: T, b: T) -> Bool where T.RawValue: Comparable { 
    return a.rawValue < b.rawValue 
} 

現在我可以這樣做：

enum Foo: Int { 
    case a = 1 
    case b = 2 
} 

let a = Foo.a 
let b = Foo.b 

print(a < b) // true 

但我怎麼應該，所以我可以比較像枚舉：

print(b < 1) // error 

Answer 1

你只想做更多的東西你已經做：

func <<T:RawRepresentable>(a:T, b:Int) -> Bool where T.RawValue == Int { 
    return a.rawValue < b 
} 

Answer 2

Int不RawRepresentable，所以它不能與你<運營商使用。

這裏有兩個定位：

1. 讓2個新<重載：

   • <<T: RawRepresentable>(a: T, b: Int)
   • <<T: RawRepresentable>(a: Int, b: T)

2. 請Int符合RawRepresentable，並重寫現有的<過載使用兩種通用類型，如果它們具有相同的RawValue（本身爲Comparable），則可以將其進行比較。

   extension Int: RawRepresentable { 
       public init?(rawValue: Int) { self.init(rawValue) } 
       public var rawValue: Int { return self } 
   } 
   
   func < <T: RawRepresentable, U: RawRepresentable>(a: T, b: U) -> Bool 
       where T.RawValue: Comparable, T.RawValue == U.RawValue { 
        return a.rawValue < b.rawValue 
   } 
   
   enum Foo: Int { 
       case a = 1 
       case b = 2 
   } 
   
   print(Foo.a < Foo.b) 
   print(Foo.b < 1) 
   

Answer 3

稍微更通用的@matt's solution版本 - 這將讓您比較特定RawRepresentable其RawValue。雖然請注意，爲了允許所有4種可能的比較組合，您必須同時實施兩種過載（兩種均爲< & >）。

func < <T : RawRepresentable>(lhs: T, rhs: T.RawValue) -> Bool where T.RawValue : Comparable { 
    return lhs.rawValue < rhs 
} // allows b < 1 

func < <T : RawRepresentable>(lhs: T.RawValue, rhs: T) -> Bool where T.RawValue : Comparable { 
    return lhs < rhs.rawValue 
} // allows 1 < b 

func > <T : RawRepresentable>(lhs: T, rhs: T.RawValue) -> Bool where T.RawValue : Comparable { 
    return lhs.rawValue > rhs 
} // allows b > 1 

func > <T : RawRepresentable>(lhs: T.RawValue, rhs: T) -> Bool where T.RawValue : Comparable { 
    return lhs > rhs.rawValue 
} // allows 1 > b 

雖然這樣說，我會小心使用這種重載。能夠說出諸如b < 1之類的東西並不是那麼糟糕，但當允許你說b < c時c是Int - 它開始變得稍微不清楚你實際比較的是什麼（更不用說增加額外的複雜性了重載分辨率）。

簡單地說，print(b.rawValue < 1)既清晰又簡潔，而且是我寫它的方式。