Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] Strange physical equality behavior
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: brogoff@s...
Subject: Re: [Caml-list] Strange physical equality behavior
On Tue, 11 Nov 2003, Oleg Trott wrote:
> On Sunday 09 November 2003 08:33 pm, Jacques Garrigue wrote:
> > The functorial approach offers a much cleaner solution.
>
> I'm not convinced.
>
> With non-functorial sets:
>
> type t = Leaf of string | Node of t Set.t
>
> How would you do this with functorial sets? Perhaps like this:
>
> http://groups.google.com/groups?selm=fa.dlqsupe.1c6ajga%40ifi.uio.no
>
>     module A : sig
>                  type t = Leaf of string | Node of ASet.t
>                  val compare: t -> t -> int
>                end
>              = struct
>                  type t = Leaf of string | Node of ASet.t
>                  let compare t1 t2 =
>                    match (t1, t2) with
>                      (Leaf s1, Leaf s2) -> Pervasives.compare s1 s2
>                    | (Leaf _, Node _) -> 1
>                    | (Node _, Leaf _) -> -1
>                    | (Node n1, Node n2) -> ASet.compare n1 n2
>                end
>     and ASet : Set.S with type elt = A.t
>              = Set.Make(A)
>
> (BTW, that example doesn't yet work in 3.07-2 default toplevel. And couldn't
> one write "let compare = Pervasives.compare" above? )

 module rec A : (* a forgotten "rec" inserted *)
    sig
      type t = Leaf of string | Node of ASet.t
      val compare: t -> t -> int
    end
    = struct
      type t = Leaf of string | Node of ASet.t
      let compare t1 t2 =
        match (t1, t2) with
          (Leaf s1, Leaf s2) -> Pervasives.compare s1 s2
        | (Leaf _, Node _) -> 1
        | (Node _, Leaf _) -> -1
        | (Node n1, Node n2) -> ASet.compare n1 n2
    end
and ASet : Set.S with type elt = A.t
      = Set.Make(A)

It's a simple syntax error. And, if we use Pervasives.compare, we don't know
for sure how the Leaf <-> Node comparison will work, do we? What if it's
dependent on the order of occurrence of those constructors in the type
definition?

Functors can be heavy, but I prefer that approach too. Having a bit of
recursiveness in the module language makes them much nicer. Now if we can
just get generics...

-- Brian


-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners