Heeft != betekenis in OCaml?

Het lijkt een equivalentievergelijking te zijn voor sommige typen, maar niet voor strings.

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

Dit is zoals verwacht.

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

Waarom evalueert "odp" != "odp"tot true? Wat doet het eigenlijk? Zou het geen typefout moeten genereren?

Antwoord 1, autoriteit 100%

je hebt het verschil ervaren tussen structurele en fysieke gelijkheid.

<>is voor =(structurele gelijkheid) zoals !=is voor ==( fysieke gelijkheid)

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

is onwaar omdat elk op verschillende geheugenlocaties wordt geïnstantieerd, waarbij het volgende wordt gedaan:

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

Meestal wil je =en <>gebruiken.

bewerken over wanneer structurele en fysieke gelijkheid gelijkwaardig zijn:

U kunt de what_is_it-functiegebruiken en alle typen die zowel structureel als fysiek gelijk zouden zijn. Zoals vermeld in de opmerkingen hieronder en in het gelinkte artikel, hebben karakters, gehele getallen, eenheid, lege lijst en sommige varianten van varianten deze eigenschap.

Antwoord 2, autoriteit 18%

Het tegenovergestelde voor !=operator is ==operator, niet de =operator.

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

De == operator is een “fysieke gelijkheid”. Wanneer u "a" == "a"typt, vergelijkt u twee verschillende instantiesvan tekenreeksen die toevallig op elkaar lijken, dus de operator retourneert false. Terwijl het hebben van één instantie ervoor zorgt dat het waar wordt geretourneerd:

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

Antwoord 3, autoriteit 14%

Een korte uitleg over ==en !=in OCaml naast alle juiste antwoorden die al zijn gegeven:

1/ ==en !=leggen implementatiedetails bloot die u eigenlijk niet wilt weten. Voorbeeld:

# 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

Tot nu toe, zo goed: xen t.(0)zijn fysiek gelijk omdat t.(0)een verwijzing bevat naar hetzelfde blok waar xnaar verwijst. Dit is wat basiskennis van de implementatie dicteert. MAAR:

# 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

Wat u hier ziet, zijn de resultaten van een verder nuttige optimalisatie met floats.

2/ Aan de andere kant is er een veilige manier om ==te gebruiken, en dat is een snelle maar onvolledige manier om te controleren op structurele gelijkheid.

Als u een gelijkheidsfunctie op binaire bomen schrijft

let equal t1 t2 =
  match ...

het controleren van t1en t2op fysieke gelijkheid is een snelle manier om te detecteren dat ze duidelijk structureel gelijk zijn, zonder ze zelfs maar te herhalen en te lezen. Dat is:

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

En als je er rekening mee houdt dat in OCaml de operator “boolean or” “lui” is,

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

Antwoord 4, autoriteit 2%

Het zijn net twee ‘Tom’s in je klas! Omdat:

In dit geval "odp" = "odp"
omdat het TWEEstrings zijn met DEZELFDEWAARDE!!

Ze zijn dus niet ==omdat ze TWEEverschillende strings zijn die op verschillende(Geheugen) locatieworden opgeslagen

Ze zijn =omdat ze de identieke tekenreekswaardehebben.

Nog een stap dieper, “odp” is een anonieme variabele. En twee anonieme variabelen leiden tot deze Tweestrings.

Voor uw gemak:

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

Antwoord 5

ints is het enige type waar fysieke en structurele gelijkheid hetzelfde zijn, omdat ints het enige type is dat uit de doos is gehaald