Come funziona la covarianza facoltativa in Swift

Question

Come funziona la covarianza per Optional s in Swift?

Dire scrivo il seguente codice:

var nativeOptionalView: Optional<UIView> 
let button = UIButton() 
nativeOptionalView = .Some(button) 
var nativeOptionalButton = Optional.Some(button) 

nativeOptionalView = nativeOptionalButton 

Si compila e funziona bene. Tuttavia, se mi definisco MyOptional come

enum MyOptional<T> { 
    case Some(T) 
    case None 
} 

e scrivere la seguente:

var myOptionalView: MyOptional<UIView> 
let button = UIButton() 
myOptionalView = .Some(button) 
var myOptionalButton = MyOptional.Some(button) 

myOptionalView = myOptionalButton 

ottengo l'errore:

error: cannot assign value of type ' MyOptional<UIButton> ' to type ' MyOptional<UIView> '

capisco perché questo errore accade con MyOptional, quello che don' t capire è perché non succede con Optional.

Answer 1

E non lo fa. Swift non supporta generici covarianti personalizzati per ora.

Il correttore di tipo Swift è per espressione, non globale (come in Haskell). Questa attività è handled by l'analisi semantica in lib/Sema. Quindi il sistema di vincoli prova a match the types e i casi speciali di covarianza vengono quindi gestiti per collections e optionals.

Questa è stata una decisione di progettazione linguistica. Dovresti essere in grado di fare tutto il necessario con i tipi e gli accessori di raccolta integrati. Se non lo sei, dovresti probabilmente aprire un radar.

Answer 2

Mentre sono d'accordo sul fatto che ci sia probabilmente un "magico per il compilatore" in corso, questo può essere realizzato nella tua implementazione personalizzata mediante il cast del pulsante su un UIView, ad es.

var myOptionalButton = MyOptional.Some(button as UIView) 

o

var myOptionalButton: MyOptional<UIView> = .Some(button)