protocol - ¿Cómo se implementan los valores opcionales en Swift?

swift protocol optional

Question

Me pregunto cómo se implementan los tipos de valor en Swift (Int, Float ...) para admitir el enlace opcional ("?"). Asumo que esos tipos de valor no se asignan en el montón, sino en la pila. Entonces, ¿dependen de algún tipo de puntero a la pila que puede ser nulo, o la estructura subyacente contiene una bandera booleana?

Answer 1

La mayoría de las respuestas simplemente dicen que las opciones de Swift se implementan con las enum , lo que plantea las preguntas de cómo se implementan las enum . Se debe utilizar algo similar a las uniones etiquetadas en C. Por ejemplo, la enumeración Swift

enum Foo {
  case None
  case Name(String)
  case Price(Double)
}

podría ser imitado en C de la siguiente manera:

enum {FOO_NONE_, FOO_NAME_, FOO_PRICE_};
typedef struct {
   int flavor; // FOO_NONE_, FOO_NAME_ or FOO_PRICE_
   union {
      char *Name;  // payload for FOO_STRING_
      double Price; // payload for FOO_DOUBLE_
   } u;
} 

Answer 2

Las opciones se implementan como se muestra a continuación. Para encontrar esto, haga clic en CMD en una declaración como var x: Optional<Int> . var x: Int? Es solo azúcar sintáctica para eso.

enum Optional<T> : LogicValue, Reflectable {
    case None
    case Some(T)
    init()
    init(_ some: T)

    /// Allow use in a Boolean context.
    func getLogicValue() -> Bool

    /// Haskell''s fmap, which was mis-named
    func map<U>(f: (T) -> U) -> U?
    func getMirror() -> Mirror
}

Answer 3

Swift es de código abierto desde ayer. Puede ver la implementación en GitHub: https://github.com/apple/swift/blob/master/stdlib/public/core/Optional.swift

public enum Optional<Wrapped> : ExpressibleByNilLiteral {

    case none
    case some(Wrapped)

    public init(_ some: Wrapped) { self = .some(some) }

    public init(nilLiteral: ()) {
        self = .none
    }

    public var unsafelyUnwrapped: Wrapped {
        get {
            if let x = self {
                return x
            }
            _debugPreconditionFailure("unsafelyUnwrapped of nil optional")
        }
    }
}

Answer 4

Opcionales se implementan como tipo de enum en Swift.

Consulte el Swift Tour de Apple para ver un ejemplo de cómo se hace esto:

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