Criei um pouco de enum "Angle" para poder programar com diferentes formatos angulares intercambiáveis:

enum Angle {
    case Radians(CGFloat)
    case Degrees(CGFloat)
    case Rotations(CGFloat)
}

Acho que há algum código redundante de clichê com essa abordagem. Por exemplo, eu queria adicionar uma var computada que retornasse o float associado subjacente bruto:

var raw:CGFloat {
    switch self {
    case let .Radians(value):
        return value
    case let .Degrees(value):
        return value
    case let .Rotations(value):
        return value
    }
}

Eu tentei mudar isso para ler:

case .Radians(let value), .Degrees(let value):
    return value

Eu esperava que fosse inteligente o suficiente para perceber que isso só resolveria uma partida, então o conflito era ignorável. Mas não existe esse dispositivo. O compilador diz que não pode resolver o conflito entre os doislet value afirmações.

Então, existe um pouco de inteligência idiomática que eu ainda não descobri com o Swift enum que faria com que eu não precisasse me repetir tanto lá?

Outro exemplo semelhante foi quando implementei o* função:

func * (lhs:Angle, rhs:CGFloat) -> Angle {
    switch lhs {
    case .Radians:
        return .Radians(lhs.raw * rhs)
    case .Degrees:
        return .Degrees(lhs.raw * rhs)
    case .Rotations:
        return .Rotations(lhs.raw * rhs)
    }
}

Parece que deveria haver uma maneira mais simples de expressar isso: "Faça o mesmo tipo de enumeração com meu valor associado multiplicado pelo argumento escalar".

(Não tenho certeza se tenho um bom título sobre essa questão, fique à vontade para melhorar / sugerir melhor)