Does compare work for all types?

问题

Let's consider a type t and two variables x,y of type t.

Will the call compare x y be valid for any type t? I couldn't find any counterexample.

回答1:

The polymorphic compare function works by recursively exploring the structure of values, providing an ad-hoc total ordering on OCaml values, used to define structural equality tested by the polymorphic = operator.

It is, by design, not defined on functions and closures, as observed by @antron. The recursive nature of the definition implies that structural equality is not defined on values containing a function or a closure. This recursive nature also imply that the compare function is not defined on recursive values, as mentioned by a @antron as well.

Structural equality, and therefore the compare function and the comparison operators, is not aware of structure invariants and cannot be used to compare (mildly) advanced data structures such as Sets, Maps, HashTbls and so on. If comparison of these structures is desired, a specialised function has to be written, this is why Set and Map define such a function.

When defining your own structures, a good rule of thumb is to distinguish between

concrete types, which are defined only in terms of primitive types and other concrete types. Concrete types should not be used for structures whose processing expects some invariants, because it is easy to create arbitrary values of this type breaking these invariants. For these types, the polymorphic comparison function and operators are appropriate.
abstract types, whose concrete definition is hidden. For these types, it is best to provide specialised comparison function. The mixture library defines a compare mixin that can be used to derive comparison operators from the implementation of a specialised compare function. Its use is illustrated in the README.

回答2:

It doesn't work for function types:

# compare (fun x -> x) (fun x -> x);;
Exception: Invalid_argument "equal: functional value".

Likewise, it won't (generally) work for other types whose values can contain functions:

# type t = A | B of (int -> int);;
type t = A | B of (int -> int)
# compare A A;;
- : int = 0
# compare (B (fun x -> x)) A;;
- : int = 1
# compare (B (fun x -> x)) (B (fun x -> x));;
Exception: Invalid_argument "equal: functional value".

It also doesn't (generally) work for recursive values:

# type t = {self : t};;
type t = { self : t; }
# let rec v = {self = v};;
val v : t = {self = <cycle>}
# let rec v' = {self = v'};;
val v' : t = {self = <cycle>}
# compare v v;;
- : int = 0
# compare v v';;
(* Does not terminate. *)

These cases are also listed in the documentation for compare in Pervasives.

来源：https://stackoverflow.com/questions/34513998/does-compare-work-for-all-types

标签

ocaml