Swift: test rispetto al valore opzionale nel caso dello switch

In Swift, come posso scrivere un caso in un'istruzione switch che verifica il valore scambiato rispetto al contenuto di un facoltativo , saltando il caso se l'opzionale lo contiene nil?

Ecco come immagino che potrebbe apparire:

let someValue = 5
let someOptional: Int? = nil

switch someValue {
case someOptional:
    // someOptional is non-nil, and someValue equals the unwrapped contents of someOptional
default:
    // either, someOptional is nil, or someOptional is non-nil but someValue does not equal the unwrapped contents of someOptional
}

Se lo scrivo esattamente in questo modo, il compilatore si lamenta che someOptionalnon è scartato, ma se lo scarto esplicitamente aggiungendolo !alla fine, ovviamente ottengo un errore di runtime ogni volta che someOptionalcontiene nil. Aggiungere ?invece di !avrebbe un senso per me (nello spirito del concatenamento opzionale, suppongo), ma non fa sparire l'errore del compilatore (cioè non scartare effettivamente l'opzionale).

Opzionale è solo un enumcome questo:

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)

    // ...
}

Quindi puoi abbinarli come al solito pattern di corrispondenza "Valori associati" :

let someValue = 5
let someOptional: Int? = nil

switch someOptional {
case .Some(someValue):
    println("the value is \(someValue)")
case .Some(let val):
    println("the value is \(val)")
default:
    println("nil")
}

Se vuoi la corrispondenza da someValue, usando l' espressione di guardia :

switch someValue {
case let val where val == someOptional:
    println(someValue)
default:
    break
}

E per Swift> 2.0

switch someValue {
case let val where val == someOptional:
    print("matched")
default:
    print("didn't match; default")        
}

A partire da Xcode 7 (dalle note di rilascio beta 1), "un nuovo x?modello può essere utilizzato per la corrispondenza di modelli con optional come sinonimo di .Some(x)". Ciò significa che in Xcode 7 e versioni successive funzionerà anche la seguente variazione della risposta di rintaro :

let knownValue = 5

switch someOptional {
case knownValue?:
    // Contents of someOptional are knownValue, defined above.
case let otherValue?:
    // Contents of someOptional are *any* non-nil value not already tested for.
    // Unwrapped contents are assigned to otherValue for use inside this case.
default:
    // someOptional is nil.
}

In Swift 4 puoi usare Optional: ExpressibleByNilLiteral di Apple per wrapper facoltativo

https://developer.apple.com/documentation/swift/optional

Esempio

enum MyEnum {
    case normal
    case cool
}

alcuni

let myOptional: MyEnum? = MyEnum.normal

switch smyOptional {
    case .some(.normal): 
    // Found .normal enum
    break

    case .none: 
    break

    default:
    break
}

nessuna

let myOptional: MyEnum? = nil

switch smyOptional {
    case .some(.normal): 
    break

    case .none: 
    // Found nil
    break

    default:
    break
}

predefinito

let myOptional: MyEnum? = MyEnum.cool

switch smyOptional {
    case .some(.normal): 
    break

    case .none: 
    break

    default:
    // Found .Cool enum
    break
}

Enum con valore

enum MyEnum {
    case normal(myValue: String)
    case cool
}

qualche valore

let myOptional: MyEnum? = MyEnum.normal("BlaBla")

switch smyOptional {
case .some(.normal(let myValue)) where myValue == "BlaBla":
    // Here because where find in my myValue "BlaBla"
    break

// Example for get value
case .some(.normal(let myValue)):
    break

// Example for just know if is normal case enum
case .some(.normal):
    break

case .none:
    break

default:

    break
}