He definido una enumeración para representar una selección de una "estación"; Las estaciones están definidas por un entero positivo único, por lo que he creado la siguiente enumeración para permitir que los valores negativos representen selecciones especiales:

enum StationSelector : Printable {
    case Nearest
    case LastShown
    case List
    case Specific(Int)

    func toInt() -> Int {
        switch self {
        case .Nearest:
            return -1
        case .LastShown:
            return -2
        case .List:
            return -3
        case .Specific(let stationNum):
            return stationNum
        }
    }

    static func fromInt(value:Int) -> StationSelector? {
        if value > 0 {
            return StationSelector.Specific(value)
        }
        switch value {
        case -1:
            return StationSelector.Nearest
        case -2:
            return StationSelector.LastShown
        case -3:
            return StationSelector.List
        default:
            return nil
        }
    }

    var description: String {
    get {
        switch self {
        case .Nearest:
            return "Nearest Station"
        case .LastShown:
            return "Last Displayed Station"
        case .List:
            return "Station List"
        case .Specific(let stationNumber):
            return "Station #\(stationNumber)"
        }
    }
    }
}

Me gustaría usar estos valores como claves en un diccionario. Declarar un diccionario produce el error esperado de que StationSelector no se ajusta a Hashable. Conformarse con Hashable es fácil con una función hash simple:

var hashValue: Int {
get {
    return self.toInt()
}
}

Sin embargo,Hashable requiere conformidad conEquatable, y parece que no puedo definir el operador igual en mi enumeración para satisfacer al compilador.

func == (lhs: StationSelector, rhs: StationSelector) -> Bool {
    return lhs.toInt() == rhs.toInt()
}

El compilador se queja de que se trata de dos declaraciones en una sola línea y quiere poner un; despuésfunc, lo que tampoco tiene sentido.

¿Alguna idea?