Podanie wartości domyślnej opcjonalnego w języku Swift?

Idiom do radzenia sobie z opcjami w Swift wydaje się nadmiernie rozwlekły, jeśli wszystko, co chcesz zrobić, to podać wartość domyślną w przypadku, gdy jest zerowa:

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

co wiąże się z niepotrzebnym powielaniem kodu lub

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

która unwrappedValuenie wymaga stałej.

Monada Option Scali (która jest w zasadzie tym samym pomysłem co opcja Swift) ma metodę getOrElsedo tego celu:

val myValue = optionalValue.getOrElse(defaultValue)

Czy coś mi brakuje? Czy Swift ma już na to kompaktowy sposób? Lub, jeśli to nie wystarczy, czy można zdefiniować getOrElserozszerzenie dla Optional?

Aktualizacja

Firma Apple dodała teraz operatora koalescencji:

var unwrappedValue = optionalValue ?? defaultValue

Operator trójskładnikowy jest w tym przypadku Twoim przyjacielem

var unwrappedValue = optionalValue ? optionalValue! : defaultValue

Możesz także podać własne rozszerzenie opcjonalnego wyliczenia:

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

Następnie możesz po prostu zrobić:

optionalValue.or(defaultValue)

Zalecam jednak trzymać się operatora trójskładnikowego, ponieważ inni programiści zrozumieją to znacznie szybciej bez konieczności badania ormetody

Uwaga : Zacząłem moduł dodawania wspólne pomocników tak orna OptionalSWIFT.

Od sierpnia 2014 r. Swift ma operatora koalescencji (??), który to umożliwia. Na przykład dla opcjonalnego String myOptional można napisać:

result = myOptional ?? "n/a"

jeśli napisałeś:

let result = optionalValue ?? 50

a optionalValue != nilpotem też resultbędzie optionali będziesz musiał go rozpakować w przyszłości

Ale możesz napisać operator

infix operator ??? { associativity left precedence 140 }

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

Teraz możesz:

 let result = optionalValue ??? 50

A kiedy optionalValue != nilto resultbędzieunwraped

Następujące wydaje się działać

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

jednak potrzeba rzucania value as Tjest brzydka. W idealnym przypadku powinien istnieć sposób potwierdzenia, że Tjest taki sam, jak typ zawarty w pliku Optional. W obecnej postaci wpisz zestawy wnioskowania Tna podstawie parametru podanego w getOrElse, a następnie zakończy się niepowodzeniem w czasie wykonywania, jeśli nie jest to zgodne z wartością opcjonalną, a wartość opcjonalna jest różna od zera:

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