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

        

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 {

Answer 3

AFAIK, Swift does not support type constraint to be specified with enums.

Cited from Swift Manual

Type Constraint Syntax

You write type constraints by placing a single class or protocol constraint after a type parameter’s name, separated by a colon, as part of the type parameter list. The basic syntax for type constraints on a generic function is shown below (although the syntax is the same for generic types):

Strictly limited to a class or protocol unless there's some hidden features which is not mentioned in manual. As far as I tested, struct or enum are all prohibited by the compiler.

enum Test1 : Int
{
    case AAA = 0
}

func test1f<T:Test1>(a: Test1) {}       //  error: Inheritance from non-protocol, non-class type 'Test1'

struct Test2
{
    var aaa:Int =   0
}

func test2f<T:Test2>(a: Test2) {}       //  error: Inheritance from non-protocol, non-class type 'Test1'


class Test3
{
}

func test3f<T:Test3>(a: Test3) {}       //  OK