Est-ce que! = A un sens dans OCaml?

Cela semble être une comparaison d’équivalence pour certains types, mais pas pour les chaînes.

# 3 != 3;; - : bool = false # 3 != 2;; - : bool = true 

C’est comme prévu.

 # "odp" = "odp";; - : bool = true # "odp" != "odp";; - : bool = true # "odp"  "odp";; - : bool = false 

Pourquoi "odp" != "odp" t-il la valeur true ? Que fait-il réellement? Ne devrait-il pas générer une erreur de type?

vous avez fait la différence entre égalité structurelle et égalité physique.

<> est à = (égalité structurelle) comme != est à == (égalité physique)

 "odg" = "odg" (* true *) "odg" == "odg" (* false *) 

est faux parce que chacun est instancié dans des emplacements mémoire différents, faisant:

 let v = "odg" v == v (* true *) v = v (* true *) 

La plupart du temps, vous voudrez utiliser = et <> .

éditer sur quand égalité structurelle et physique sont équivalentes :

Vous pouvez utiliser la fonction what_is_it et trouver tous les types égaux sur le plan structurel et physique. Comme mentionné dans les commentaires ci-dessous, et dans l’article lié, les caractères, les entiers, l’unité, la liste vide et certaines instances de types de variantes auront cette propriété.

Le contraire pour l’opérateur != est l’opérateur == , pas le = un.

 # "a" != "a" ;; - : bool = true # "a" == "a" ;; - : bool = false 

L’opérateur == est une “égalité physique”. Lorsque vous tapez "a" == "a" , vous comparez deux instances différentes de chaînes qui se ressemblent, de sorte que l’opérateur retourne false . Tout en ayant une instance le rend vrai:

 # let str = "a" in str == str ;; - : bool = true # let str = "a" in str != str ;; - : bool = false 

Une explication rapide sur == et != Dans OCaml en plus de toutes les réponses correctes qui ont déjà été fournies:

1 / == et != Exposent les détails de la mise en œuvre que vous ne voulez vraiment pas connaître. Exemple:

 # let x = Some [] ;; val x : 'a list option = Some [] # let t = Array.create 1 x ;; val t : '_a list option array = [|Some []|] # x == t.(0) ;; - : bool = true 

Jusqu’à présent, tout va bien: x et t.(0) sont physiquement égaux car t.(0) contient un pointeur sur le même bloc que x pointe vers. C’est ce que dicte la connaissance de base de la mise en œuvre. MAIS:

 # let x = 1.125 ;; val x : float = 1.125 # let t = Array.create 1 x ;; val t : float array = [|1.125|] # x == t.(0) ;; - : bool = false 

Ce que vous voyez ici sont les résultats d’une optimisation par ailleurs utile impliquant des flotteurs.

2 / D’autre part, il existe un moyen sûr d’utiliser == , et c’est un moyen rapide mais incomplet de vérifier l’égalité structurelle.

Si vous écrivez une fonction d’égalité sur les arbres binarys

 let equal t1 t2 = match ... 

La vérification de l’égalité physique par t1 et t2 est un moyen rapide de détecter qu’elles sont manifestement égales sur le plan structurel, sans même avoir à les réévaluer et à les lire. C’est:

 let equal t1 t2 = if t1 == t2 then true else match ... 

Et si vous gardez à l’esprit que dans OCaml, l’opérateur «booléen» est «paresseux»,

 let equal t1 t1 = (t1 == t2) || match ... 

Ils sont comme deux “Tom” dans votre classe! Car:

Dans ce cas, "odp" = "odp" car ce sont deux chaînes avec SAME VALUE !!

Ils ne sont donc pas == car ils sont DEUX différentes chaînes de caractères stockées dans différents emplacements (mémoire)

Ils sont = parce qu’ils ont la même valeur de chaîne .

Un pas de plus, “odp” est une variable anonyme. Et deux variables anonymes conduisent à ces deux chaînes.

Pour ta convenance:

 # "odp" = "odp";; - : bool = true # "odp" != "odp";; - : bool = true # "odp" <> "odp";; - : bool = false 

ints est le seul type où l’égalité physique et l’égalité structurelle sont les mêmes, car ints est le seul type qui n’est pas encapsulé