Est-ce que != a une signification en OCaml ?

Question

Il semble qu'il s'agisse d'une comparaison d'équivalence pour certains types, mais pas pour les chaînes de caractères.

# 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 est-ce que "odp" != "odp" évaluer pour true ? Que fait-il réellement ? Ne devrait-il pas générer une erreur de type ?

Answer 1

vous avez expérimenté la différence entre structurales et physiques de l'égalité.

<> est = (l'égalité structurelle) comme != est == (physique de l'égalité)

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

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

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

La plupart du temps, vous aurez envie d'utiliser = et <>.

modifier au sujet de laquelle les structures physique et l'égalité sont équivalentes:

Vous pouvez utiliser le what_is_it fonction et trouver tous les types qui serait égale à la fois structurellement et physiquement. Comme mentionné dans les commentaires ci-dessous, et dans l'article lié, des caractères, des entiers, l'unité, la liste vide, et certains cas de la variante de types ont cette propriété.

Answer 2

Le contraire pour != L'opérateur est == et non l'opérateur = un.

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

L'opérateur == est une "égalité physique". Lorsque vous tapez "a" == "a" vous comparez deux différentes instances de chaînes de caractères qui se ressemblent, l'opérateur retourne donc false . Alors qu'en ayant une seule instance, elle renvoie vrai :

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

Answer 3

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

1/ == y != exposer des détails de 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 y t.(0) sont physiquement égaux car t.(0) contient un pointeur sur le même bloc que x pointe vers. C'est ce que la connaissance de base de la mise en œuvre dicte. 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 autrement utile impliquant des flottants.

2/ D'autre part, il existe un moyen sûr d'utiliser == Il s'agit d'un moyen rapide mais incomplet de vérifier l'égalité structurelle.

Si vous écrivez une fonction d'égalité sur des arbres binaires

let equal t1 t2 =
  match ...

vérification de t1 y t2 pour l'égalité physique est un moyen rapide de détecter qu'ils sont manifestement structurellement égaux, sans même devoir les récurer et les lire. C'est-à-dire :

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

Et si vous gardez à l'esprit qu'en OCaml l'opérateur "booléen ou" est "paresseux",

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

Answer 4

Ils sont comme deux "Tom" dans votre classe ! Parce que :

Dans ce cas, "odp" = "odp" parce qu'ils sont DEUX des chaînes de caractères avec SAME VALEUR !

Donc ils ne sont pas == parce qu'ils sont DEUX différentes chaînes de caractères stockées dans différents (Mémoire) emplacement

Ils sont = parce qu'ils ont le valeur de chaîne identique .

Un peu plus loin, "odp" est une variable anonyme. Et deux variables anonymes mènent à ceci Deux ficelles.

Pour votre commodité :

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

Answer 5

Les ints sont le seul type où l'égalité physique et l'égalité structurelle sont les mêmes, car les ints sont le seul type qui n'est pas encadré.