val - ocaml vs haskell

¿Tiene!=Significado en OCaml?

Question

Parece ser una comparación de equivalencia para algunos tipos, pero no para cadenas.

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

Esto es como se esperaba

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

¿Por qué "odp" != "odp" evalúa a true ? ¿Qué está haciendo realmente? ¿No debería generar un error de tipo?

Answer 1

¡Son como dos "Tom" en tu clase! Porque:

En este caso, "odp" = "odp" porque son DOS cadenas con MISMO VALOR !!

Entonces no son == porque son DOS cadenas diferentes almacenan en diferentes (Memoria) ubicación

Son = porque tienen el mismo valor de cadena .

Un paso más profundo, "odp" es una variable anónima. Y dos variables anónimas conducen a este Dos cadenas.

Por su conveniencia:

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

Answer 2

Lo contrario para != operador es == operador, no el = uno.

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

El operador == es una "igualdad física". Cuando escribe "a" == "a" , compara dos instancias diferentes de cadenas que se parecen, por lo que el operador devuelve false . Si bien tener una instancia hace que vuelva verdadero:

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

Answer 3

Los Ints son el único tipo en el que la igualdad física y estructural es la misma, porque los Ints son el único tipo que se desempaqueta

Answer 4

Una explicación rápida sobre == y != En OCaml además de todas las respuestas correctas que ya se han proporcionado:

1 / == y != Exponer detalles de implementación que realmente no quiere saber. Ejemplo:

# 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

Hasta ahora, todo bien: x y t.(0) son físicamente iguales porque t.(0) contiene un puntero al mismo bloque al que apunta x . Esto es lo que dicta el conocimiento básico de la implementación. PERO:

# 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

Lo que está viendo aquí son los resultados de una optimización de otra manera útil que involucra flotadores.

2 / Por otro lado, hay una manera segura de usar == , y eso es una manera rápida pero incompleta de verificar la igualdad estructural.

Si está escribiendo una función de igualdad en árboles binarios

let equal t1 t2 =
  match ...

comprobar t1 y t2 para la igualdad física es una manera rápida de detectar que obviamente son estructuralmente iguales, sin siquiera tener que recurrir y leerlos. Es decir:

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

Y si se tiene en cuenta que en OCaml el operador "booleano o" es "flojo",

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

Answer 5

has experimentado la diferencia entre igualdad estructural y física.

<> es a = (igualdad estructural) como != es a == (igualdad física)

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

es falso porque cada instancia se instancia en diferentes ubicaciones de memoria, haciendo:

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

La mayoría de las veces querrás usar = y <> .

edite sobre cuándo la igualdad estructural y física son equivalentes :

Puede usar la función what_is_it y descubrir todos los tipos que serían iguales tanto estructural como físicamente. Como se menciona en los comentarios a continuación, y en el artículo vinculado, los caracteres, enteros, unidades, listas vacías y algunas instancias de tipos variantes tendrán esta propiedad.