Can compare returned values ​​except -1, 0 and 1?

Question

docs for the Pervasives.compare function indicates that

compare xy returns 0 if x is y , a negative integer if x less than y , and a positive integer if x greater than y .

This suggests that it can return any negative or positive integer, not just -1 or 1 , to represent a greater or lesser degree. But is this really happening ?

This will do a write code like

 match String.compare key new_key with | 1 -> Node (left, insert new_key right, key) | -1 -> Node (insert new_key left, right, key) | _ -> Node (left, right, key) 

much harder (using when , maybe?).

I'm particularly interested in String.compare . Looking at its implementation , it simply goes to Pervasives.compare , which, in turn, is implemented initially using external . I don’t know what he is doing.

Answer 1

I am wondering why one cannot use the @kne wrapper offered directly. Your code will look like this:

 match String.compare key new_key with | 0 -> Node (left, right, key) | x when x > 0 -> Node (left, insert new_key right, key) | _ (* x < 0*) -> Node (insert new_key left, right, key) 

This saves the function call and is not significantly longer than the 1/0/1 method. In addition, comparisons are often provided by the user (see, for example, Set.OrderedType ), where the restriction may be violated in any case.

Answer 2

The answer itself shows that no other values ​​can be returned in the current implementation. However, I would be very careful to rely on this. Until compare is documented as three-digit, future versions of OCaml may change this behavior.

[EDIT, replying to a comment] To avoid awkward differences in the case (as outlined in the original question), you can wrap compare in a function that returns the type of three values, for example:

 type comparison = Less | Equal | More let my_compare ab = match compare ab with | 0 -> Equal | c when c>0 -> More | _ -> Less 

Answer 3

Is this really happening?

No.

Pervasives.compare is run using external .

I think this applies to compare.c , which implements a string case using

 #define LESS -1 #define EQUAL 0 #define GREATER 1 mlsize_t len1 = caml_string_length(v1); mlsize_t len2 = caml_string_length(v2); int res = memcmp(String_val(v1), String_val(v2), len1 <= len2 ? len1 : len2); if (res < 0) return LESS; if (res > 0) return GREATER; if (len1 != len2) return len1 - len2; 

Thus, it seems that it really can return an arbitrary integer for strings such as compare "a" "abc" ( -2 ).

But if we try in Ocaml, this will not happen and just return -1 . Why not?
Since the real comparison function , which is exposed to the Ocaml code, normalizes the results:

 CAMLprim value caml_compare(value v1, value v2) { intnat res = compare_val(v1, v2, 1); if (res < 0) return Val_int(LESS); else if (res > 0) return Val_int(GREATER); else return Val_int(EQUAL); } 

So it really cannot return any int other than the three.