Version française
Home     About     Download     Resources     Contact us    

This site is updated infrequently. For up-to-date information, please visit the new OCaml website at

Browse thread
Comparing two things of any two types, in pure OCaml
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2006-09-09 (07:14)
From: Jacques Garrigue <garrigue@m...>
Subject: Re: [Caml-list] Comparing two things of any two types, in pure OCaml
Hi Oleg,

> This message shows an example of an open, extensible comparison function
> 'a -> 'b -> bool.
> Diego Olivier Fernandez Pons wrote about a help system associating (by
> means of a hashtable) a documentation string to a function. Alas, the
> hash function is not perfect and collisions are possible. Therefore,
> we need to validate each hashtable hit by physically (==) comparing
> the function (whose documentation we need to lookup) against the
> target function. The functions to document have generally different
> types. This raises two questions: how to store functions of different
> types in the same data structure, and how to compare a candidate
> function against these functions of different types. The physical
> comparison function (==) cannot be used as it is: we need a comparison
> function [cmp : 'a -> 'b -> bool] that can take arguments of any two
> types, returning false if the argument types are different.
> Jacques Garrigue suggested using Obj.repr. He also wrote ``Type
> theoretician answer: What you would need to do that transparently
> inside the type system is generic functions with dynamics.'' and
> mentioned GADT.

Small comment: By transparently I meant "without any type
annotation". Then I gave a solution using normal datatypes for
annotations, and polymorphic methods, and just mentioned that GADTs
were not useful in this case. Note that my solution cannot directly
use polymorphic variants, as it uses non-regular types, and
polymorphic variants have to be regular. But an interesting question
is whether that solution could be made more modular, to enable
extension with new type constructors.

> It seems however that open polymorphic variants are ideal for the
> task. We start with
> let myeq (x : [>]) (y : [>]) = false;;
> We can add another clause, for int->bool functions:
> let myeq x y = match (x,y) with
> 	(`T'int2bool (x : int->bool), `T'int2bool y) -> x == y
> 	| _ -> myeq x y;;
> Let us extend myeq once again:
> let myeq x y = match (x,y) with
> 	(`T'int2bool'2bool (x : (int->bool)->bool), 
> 	 `T'int2bool'2bool y) -> x == y
> 	| _ -> myeq x y;;

While such a solution is appealing, there are drawbacks.
1) You have to add a new case for each new function type, rather than
   each type constructor.
2) In the open case, there is no static protection against mistyping a
   variant constructor. But you can check it dynamically:
     let type_handled x = myeq x x
   This will return true only if x's type is handled by myeq.
2) Polymorphic variant typing does not always play well with
   modularity. For instance, you cannot define an hashtable in a
   module, and add new cases no included in the original type in
   another module. For this reason, exceptions may be better for
   extension across modules.

This said, I love polymorphic variants anyway...

Jacques Garrigue