Quelle est la différence entre les options et le type Nullable

Swift l'a fait Optionals. C # a des Nullabletypes.

Pour autant que je sache, les deux ont le même objectif, outre la valeur d'un certain type, ils stockent des informations sur la variable ou non (non initialisée).

La question est Optionalsjuste des Nullabletypes avec un nom différent ou y a-t-il d'autres différences conceptuelles?

En d'autres termes, parler du concept lui-même, ou dans le contexte de langues qui n'ont pas Optionalsou Nullables, quel est le terme utilisé?

Lors de la mise en œuvre de cette fonctionnalité dans la langue, importe-t-il que je nomme le type Optionals<T>ouNullable<T>

Il y a une connotation différente, même si elles fonctionnent de manière très similaire. Tout le monde sauf Microsoft (insérez le œil ici) utilise nullet nullableuniquement dans le contexte des références. Optionset Maybessont généralement compris comme faisant référence à la fois aux références et aux valeurs, en particulier dans les langages de programmation fonctionnels où la transparence référentielle signifie qu'il n'y a pas beaucoup de différence entre une valeur et une référence.

En d'autres termes, parler du concept lui-même, ou dans le contexte de langages qui n'ont pas Optionalsou Nullables, quel est le terme utilisé?

Optionsest le terme qui provoque le moins de confusion parmi un large public. Seuls les programmeurs C # considéreront un Nullablecomme potentiellement applicable à un type de valeur, et je pense que la plupart d'entre eux sont au moins conscients de ce qu'est un Option.

Dans .NET, il existe deux catégories de types: les références et les valeurs (int, double, structs, enums, etc.). Parmi leurs différences, il y a le fait qu'une référence peut être null, alors qu'une valeur ne peut pas. Ainsi, si vous avez un type de valeur et que vous souhaitez transmettre une sémantique "facultative" ou "inconnue", vous pouvez l'orner avec Nullable<>. Notez qu'il Nullable<>est contraint par type à n'accepter que les types de valeur (il a une where T : structclause). Nullable<>a également des avantages spéciaux du compilateur grâce auxquels une nullvaleur est protégée contre NullReferenceExceptions:

string x = null;
x.ToString(); // throws a NullReferenceException

int? y = null;
y.ToString(); // returns ""

Dans les langages fonctionnels (comme Scala, F #, Haskell, Swift, etc.), il est courant nullde ne pas exister . En effet, dans l'ensemble, les gens considèrent l'existence de nullcomme une mauvaise idée , et les concepteurs de langage ont décidé de résoudre ce problème en le refusant.

Cela signifie que nous avons encore besoin d'un moyen de représenter une non-valeur dans ces langues. Entrez le Optiontype (la nomenclature varie, cela s'appelle Maybeen Haskell). Cela fait un travail similaire à Nullableen ce qu'il encapsule un type pour ajouter le cas où la valeur est "Aucun" ou "Inconnu" etc.

La vraie différence réside dans les fonctions supplémentaires qui vous sont offertes par les langages qui implémentent Option. À titre d'exemple, prenez Option.map(en pseudocode):

function Option<T2> Option.map(opt: Option<T1>, mapFunc: T1 -> T2) {
    if (opt is None) return None
    else return Option<T2>(mapFunc(opt.Value))
}

Le chaînage de fonctions comme Option.mapest un moyen puissant d'éviter le passe-partout de vérification nulle typique que vous voyez partout en C #:

if (service == null)
    return null;
var x = service.GetValue();
if (x == null || x.Property == null)
    return null;
return x.Property.Value;

L'équivalent nul en C # serait:

public static Nullable<T2> Map<T1, T2>(this Nullable<T1> nullable, Func<T1, T2> f)
    where T1 : struct
    where T2 : struct
{
    if (!nullable.HasValue) return (T2?)null;
    else return (T2?) f(nullable.Value);
}

Cependant, cela a une utilité limitée en C # car cela ne fonctionnera que pour les types de valeur.

La nouvelle version de C # propose l'opérateur "propagation nulle" ( ?.) qui est similaire à la Option.mapfonction sauf qu'il n'est applicable qu'aux méthodes et aux accesseurs de propriété. L'échantillon ci-dessus serait réécrit

return service?.GetValue()?.Property?.Value;