Swift: prueba con valor opcional en caso de interruptor

En Swift, ¿cómo puedo escribir un caso en una declaración de cambio que prueba el valor que se cambia con el contenido de un opcional , omitiendo el caso si el opcional contiene nil?

Así es como me imagino que esto podría verse:

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
}

Si lo escribo exactamente así, el compilador se queja de que someOptionalno se desenvuelve, pero si lo desenvuelvo explícitamente agregando !al final, por supuesto, obtengo un error de tiempo de ejecución en cualquier momento que someOptionalcontenga nil. Agregar en ?lugar de !tendría algún sentido para mí (en el espíritu del encadenamiento opcional, supongo), pero no hace que el error del compilador desaparezca (es decir, en realidad no desenvuelve el opcional).

Opcional es enumcomo este:

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case none
    case some(T)

    // ...
}

Por lo tanto, puede hacer coincidir los patrones de coincidencia habituales de "Valores asociados" :

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")
}

Si desea hacer coincidir desde someValue, usando expresión de guardia :

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

Y para Swift> 2.0

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

A partir de Xcode 7, “ x?se puede usar un nuevo patrón para emparejar patrones con opcionales como sinónimo de .some(x)”. Esto significa que en Swift 2 y versiones posteriores, la siguiente variación de la respuesta de rintaro también funcionará:

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.
}

En Swift 4 puede usar Optional: ExpressibleByNilLiteral de Apple para envolver opcional

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

Ejemplo

enum MyEnum {
    case normal
    case cool
}

algunos

let myOptional: MyEnum? = MyEnum.normal

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

    case .none: 
    break

    default:
    break
}

ninguna

let myOptional: MyEnum? = nil

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

    case .none: 
    // Found nil
    break

    default:
    break
}

defecto

let myOptional: MyEnum? = MyEnum.cool

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

    case .none: 
    break

    default:
    // Found .Cool enum
    break
}

Enum con valor

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

algo de valor

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
}