Fornire un valore predefinito per un facoltativo in Swift?

Il linguaggio per trattare con gli opzionali in Swift sembra eccessivamente dettagliato, se tutto ciò che vuoi fare è fornire un valore predefinito nel caso in cui sia nullo:

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

che comporta inutilmente la duplicazione del codice, o

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

che richiede di unwrappedValuenon essere una costante.

La monade di Scala's Option (che è sostanzialmente la stessa idea di Swift's Optional) ha il metodo getOrElseper questo scopo:

val myValue = optionalValue.getOrElse(defaultValue)

Mi sto perdendo qualcosa? Swift ha già un modo compatto di farlo? Oppure, in mancanza, è possibile definire getOrElseun'estensione per Opzionale?

Aggiornare

Apple ha ora aggiunto un operatore di coalescenza:

var unwrappedValue = optionalValue ?? defaultValue

L'operatore ternario è tuo amico in questo caso

var unwrappedValue = optionalValue ? optionalValue! : defaultValue

Puoi anche fornire la tua estensione per l'enum facoltativo:

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

Quindi puoi semplicemente fare:

optionalValue.or(defaultValue)

Tuttavia, raccomando di attenersi all'operatore ternario poiché altri sviluppatori lo capiranno molto più rapidamente senza dover studiare il ormetodo

Nota : ho iniziato un modulo per aggiungere aiutanti comuni come questo orsu Optionaldi SWIFT.

A partire da agosto 2014 Swift ha un operatore di coalescenza (??) che lo consente. Ad esempio, per una stringa opzionale myOptional potresti scrivere:

result = myOptional ?? "n/a"

se hai scritto:

let result = optionalValue ?? 50

e optionalValue != nilpoi resultlo sarà optionalanche tu e dovrai scartarlo in futuro

Ma puoi scrivere operatore

infix operator ??? { associativity left precedence 140 }

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

Ora puoi:

 let result = optionalValue ??? 50

E quando sarà optionalValue != nilallora resultunwraped

Quanto segue sembra funzionare

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

tuttavia la necessità di lanciare value as Tè un brutto trucco. Idealmente, dovrebbe esserci un modo per affermare che Tè lo stesso del tipo contenuto nell'Opzionale. TAllo stato attuale, digitare i set di inferenza in base al parametro fornito a getOrElse e quindi non riesce in fase di esecuzione se questo non corrisponde a Opzionale e Opzionale è diverso da zero:

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