Fornecendo um valor padrão para um Opcional no Swift?

O idioma para lidar com opcionais no Swift parece excessivamente detalhado, se tudo o que você deseja fazer é fornecer um valor padrão no caso em que é nulo:

if let value = optionalValue {
    // do something with 'value'
} else {
    // do the same thing with your default value
}

que envolve a duplicação desnecessária de código ou

var unwrappedValue
if let value = optionalValue {
    unwrappedValue = value
} else {
    unwrappedValue = defaultValue
}

o que unwrappedValuenão requer ser uma constante.

A mônada de Scala's Option (que é basicamente a mesma ideia que a Swift's Optional) possui o método getOrElsepara esse fim:

val myValue = optionalValue.getOrElse(defaultValue)

Estou esquecendo de algo? O Swift já tem uma maneira compacta de fazer isso? Ou, na sua falta, é possível definir getOrElseem uma extensão para Opcional?

Atualizar

A Apple agora adicionou um operador coalescente:

var unwrappedValue = optionalValue ?? defaultValue

O operador ternário é seu amigo neste caso

var unwrappedValue = optionalValue ? optionalValue! : defaultValue

Você também pode fornecer sua própria extensão para a enumeração opcional:

extension Optional {
    func or(defaultValue: T) -> T {
        switch(self) {
            case .None:
                return defaultValue
            case .Some(let value):
                return value
        }
    }
}

Então você pode simplesmente fazer:

optionalValue.or(defaultValue)

No entanto, eu recomendo aderir ao operador ternário, pois outros desenvolvedores entenderão isso muito mais rapidamente sem precisar investigar o ormétodo

Nota : Eu comecei um módulo para adicionar auxiliares comuns como esta orem Optionalque rápida.

Em agosto de 2014, a Swift tinha um operador coalescente (??) que permite isso. Por exemplo, para uma String opcional myOptional, você pode escrever:

result = myOptional ?? "n/a"

se você escreveu:

let result = optionalValue ?? 50

e optionalValue != nilentão resultserá optionaltambém e você precisará desembrulhá-lo no futuro

Mas você pode escrever operador

infix operator ??? { associativity left precedence 140 }

func ???<T>(optLeft:T?, right:T!) -> T!
{
    if let left = optLeft
    {
        return left
    }
    else { return right}
}

Agora você pode:

 let result = optionalValue ??? 50

E quando optionalValue != nilentão resultseráunwraped

O seguinte parece funcionar

extension Optional {
    func getOrElse<T>(defaultValue: T) -> T {
        if let value = self? {
            return value as T
        } else {
            return defaultValue
        }
    }
}

no entanto, a necessidade de lançar value as Té um truque feio. Idealmente, deve haver uma maneira de afirmar que Té igual ao tipo contido no Opcional. Como está, digite conjuntos de inferências com Tbase no parâmetro fornecido para getOrElse e falhe no tempo de execução se isso não corresponder ao Opcional e o Opcional for nulo:

let x: Int?

let y = x.getOrElse(1.414) // y inferred as Double, assigned 1.414

let a: Int? = 5

let b: Double = a.getOrElse(3.14) // Runtime failure casting 5 to Double