How in Swift specify type constraint to be enum?

Question

I want to specify a type constraint that the type should be a raw value enum:

enum SomeEnum: Int {   case One, Two, Three }  class SomeProtocol<E: enum<Int>> { // <- won't compile     func doSomething(e: E) {         compute(e.toRaw())     } } 

How can I do it in Swift? (I used the F# syntax for example)

Answer 1

enum SomeEnum: Int {     case One, Two, Three }  class SomeClass<E: RawRepresentable where E.RawValue == Int>{     func doSomething(e: E) {         print(e.rawValue)     } }  class SomeEnumClass : SomeClass<SomeEnum> {  } 

or directly

class SomeOtherClass{     func doSomething<E: RawRepresentable where E.RawValue == Int>(e: E) {         print(e.rawValue)     } } 

UPDATE for swift3:

enum SomeEnum: Int {     case One, Two, Three }  class SomeClass<E: RawRepresentable> where E.RawValue == Int {     func doSomething(e: E) {         print(e.rawValue)     } }  class SomeEnumClass : SomeClass<SomeEnum> {  } 

resp.

class SomeOtherClass{     func doSomething<E: RawRepresentable>(e: E) where E.RawValue == Int {         print(e.rawValue)     } } 

Answer 2

While you can place enums into a generic type without contraints (<T>), it's not possible to create constraints for all enums or all structs. All the constraints are based on interfaces (subclassing, protocols). Unfortunately, there is nothing in common between two random structs or two random enums.

Structs and enums can't inherit from other structs/enums so the only constraints for enums must be based on protocols.

protocol EnumProtocol {     func method() }  enum TestEnum : Int, EnumProtocol {     case A     case B      func method() {     } }  enum TestEnum2 : Int, EnumProtocol {     case C      func method() {     } }  class EnumGeneric <T : EnumProtocol> {     func method(a: T) {        a.method()     } }  let test = EnumGeneric<TestEnum>() test.method(TestEnum.A) 

Also note that all enums "inheriting" from a primitive type like Int conform to RawRepresentable, so you could

class EnumGeneric <T : RawRepresentable> {     func method(a: T) {        println("\(a.toRaw())");     } } 

but that won't work for enums declared as enum TestEnum {