Re: [Caml-list] Comparing variant types

[Ethan Burns <burns.ethan@gmail.com>]

On Friday, April 29, 2011 5:34:16 AM UTC-4, luc.ma...@inria.fr wrote:
> As a general rule, don't do that! :)  (using <> or !=
> for writing  'g').
> 
> 
> For <>, you'll get hurt by data types with non-unique representation
> (such as Set), as already pointed out.
> It is ok to use structural equality when it is not the case, but
> your programm is not as robust as you may want it to be.

Well, in this case I am actually not really writing the function g and instead this comparison is embedded in another function somewhere.  My feeling was that using <> would be perfectly safe because it would translate to an integer comparison.  The structure of a type containing only simple constructors should be unique (I think they are all just mapped to ints).

> For !=, it is much worse, as soon as you add a non-constant
> constructor to your data type, your code is wrong
> (cf. [1] != [1])
> 
> If you aim at robust  code. A recommended (tiresome) alternative
> is to write your own equality function once for all, in
> the following style.
> 
> type dir = Left | Right | Up | Down | No_op
> 
> let dir_equal d1 d2 = match d1,d2 with
> | (Left, Left)
> | (Right,Right)
> | (Up, Up)
> | (Down,Down)
> | (No_op,No_op)
>  -> true
> | (Left,(Right|Up|Down|No_op))
> | (Right,(Left|Up|Down|No_op))
> | (Up,(Left|Right|Down|No_op))
> | (Down,(Left|Right|Up|No_op))
> | (No_op,(Down|Up|Right|Left))
> -> false

This is tiresome indeed!  Also, I am concerned that it is less efficient than just dropping down to compare_val (although I haven't tried it).  Since the type that I am using will only ever have a unique representation, I would love to avoid something like this.

I think that the solution that I will stick with for now is the one given by Dmitry (although I am typically not a fan of != in general).  Fabrice seemed to imply that optimizing <> in this case was 'in the works.'  I will be pretty happy to see that because I am sure that I have other code lying around somewhere that is assuming <> on a simple 'enum type' is just an integer comparison.


Best,
Ethan