Recursive Sets?

Recursive Sets?

[Michael Welsh Duggan]

I have been trying to create a recursive type which can express sets
of itself.  The following code is not meant to be correct (it isn't),
but hopefully expresses the sort of thing I want to do.  Can someone
throw some ideas at me?

type foo = 
  | A | B 
  | Set of FooSet.t

module OrderedFoos =
  struct
    type t = foo
    let compare (a:t) (b:t) = compare a b
  end

module FooSet = Set.Make(OrderedFoos)

-- 
Michael Duggan
(md5i@cs.cmu.edu)

Re: Recursive Sets?

[Markus Mottl]

On Wed, 02 Aug 2000, Michael Welsh Duggan wrote:
> I have been trying to create a recursive type which can express sets
> of itself.  The following code is not meant to be correct (it isn't),
> but hopefully expresses the sort of thing I want to do.  Can someone
> throw some ideas at me?

I am afraid, but it is not possible to have mutually recursive module
and type definitions. See the following entry in the archive:

  http://pauillac.inria.fr/bin/wilma_hiliter/caml-list/199901/msg00016.html?line=47#hilite

I don't know what exactly you want to do. Some time ago I implemented a
referentially transparent directory service that might be similar to what
you want to implement, e.g.:

                         +-root-+
                        /  |  |  \
                      a    b  \   c
                      |   /    f
                      d  e    /|\
                             g h i

It is possible to update nodes directly without losing persistence. E.g.:

  let dir1 = (* directory as above,
                the "current working directory" is "root" *) in
  let dir2 = Dir.cd_path dir1 ["f"; "h"; "x"] ...

This will keep "dir1" unchanged, but "dir2" will look as follows (the
CWD will be "root/f/h/x"):

                         +-root-+
                        /  |  |  \
                      a    b  \   c
                      |   /    f
                      d  e    /|\
                             g h i
                               |
                               x

You can parameterize the directory over arbitrary ordered elements. If it
is something like this you need, I could place it online (though, it is
part of a larger project that I'll release in a few weeks, anyway - not
much time right now)...

Regards,
Markus Mottl

-- 
Markus Mottl, mottl@miss.wu-wien.ac.at, http://miss.wu-wien.ac.at/~mottl

Re: Recursive Sets?

[Jean-Christophe Filliatre]

In his message of  August 2, 2000, Michael Welsh Duggan writes: 
> I have been trying to create a recursive type which can express sets
> of itself.  The following code is not meant to be correct (it isn't),
> but hopefully expresses the sort of thing I want to do.  Can someone
> throw some ideas at me?
> 
> type foo = 
>   | A | B 
>   | Set of FooSet.t
> 
> module OrderedFoos =
>   struct
>     type t = foo
>     let compare (a:t) (b:t) = compare a b
>   end
> 
> module FooSet = Set.Make(OrderedFoos)

Actually, the above code would be incorrect, even if ocaml would allow
mutually  recursive   types  and  modules.  Indeed,   you  cannot  use
Pervasives.compare to compare sets,  since sets with the same elements
may have different structural  representation, and therefore would not
give a comparison value of 0.

(Otherwise, there  would have been  a solution: to make  a polymorphic
copy of  Set with Pervasives.compare  as a built-in  comparison, Pset,
and then  to define type  foo = A  | B | foo  Pset.t; I posted  such a
module Pset on this mailing list a few weeks ago).

However, there is  at least one solution to your  problem, which is to
mutually  recursively define  the types  of elements  and the  type of
sets,  and to  mutually  recursively define  the  function to  compare
elements and to compare sets.

If you  take for  instance the implementation  of sets from  the ocaml
standard library,  you get  the code  that I join  below. I  choose an
arbitrary order  relation for  the elements (constructors  are ordered
like this: A < B < S) but of course you can take any other one.

The nice thing  is that you can still have  the representation of sets
abstract, by giving that module a signature like:

======================================================================
type t
type elt = A | B | S of t
val empty : t
val add : elt -> t -> t
...
======================================================================

Hope this helps,
-- 
Jean-Christophe Filliatre    
  Computer Science Laboratory   Phone (650) 859-5173
  SRI International             FAX   (650) 859-2844
  333 Ravenswood Ave.           email filliatr@csl.sri.com
  Menlo Park, CA 94025, USA     web   http://www.csl.sri.com/~filliatr

======================================================================

(* This code is an adaptation of ocaml's standard library module Set. *)

    type elt = A | B | S of t
    and t = Empty | Node of t * elt * t * int

    (* Comparisons. *)

    let rec compare_elt e1 e2 = match e1,e2 with
      | A, A -> 0
      | A, _ -> -1
      | B, A -> 1
      | B, B -> 0
      | B, S _ -> -1
      | S s1, S s2 -> compare s1 s2
      | S _, _ -> 1

    and compare_aux l1 l2 =
        match (l1, l2) with
        ([], []) -> 0
      | ([], _)  -> -1
      | (_, []) -> 1
      | (Empty :: t1, Empty :: t2) ->
          compare_aux t1 t2
      | (Node(Empty, v1, r1, _) :: t1, Node(Empty, v2, r2, _) :: t2) ->
          let c = compare_elt v1 v2 in
          if c <> 0 then c else compare_aux (r1::t1) (r2::t2)
      | (Node(l1, v1, r1, _) :: t1, t2) ->
          compare_aux (l1 :: Node(Empty, v1, r1, 0) :: t1) t2
      | (t1, Node(l2, v2, r2, _) :: t2) ->
          compare_aux t1 (l2 :: Node(Empty, v2, r2, 0) :: t2)

    and compare s1 s2 =
      compare_aux [s1] [s2]

    (* Sets are represented by balanced binary trees (the heights of the
       children differ by at most 2 *)

    let height = function
        Empty -> 0
      | Node(_, _, _, h) -> h

    (* Creates a new node with left son l, value x and right son r.
       l and r must be balanced and | height l - height r | <= 2.
       Inline expansion of height for better speed. *)

    let create l x r =
      let hl = match l with Empty -> 0 | Node(_,_,_,h) -> h in
      let hr = match r with Empty -> 0 | Node(_,_,_,h) -> h in
      Node(l, x, r, (if hl >= hr then hl + 1 else hr + 1))

    (* Same as create, but performs one step of rebalancing if necessary.
       Assumes l and r balanced.
       Inline expansion of create for better speed in the most frequent case
       where no rebalancing is required. *)

    let bal l x r =
      let hl = match l with Empty -> 0 | Node(_,_,_,h) -> h in
      let hr = match r with Empty -> 0 | Node(_,_,_,h) -> h in
      if hl > hr + 2 then begin
        match l with
          Empty -> invalid_arg "Set.bal"
        | Node(ll, lv, lr, _) ->
            if height ll >= height lr then
              create ll lv (create lr x r)
            else begin
              match lr with
                Empty -> invalid_arg "Set.bal"
              | Node(lrl, lrv, lrr, _)->
                  create (create ll lv lrl) lrv (create lrr x r)
            end
      end else if hr > hl + 2 then begin
        match r with
          Empty -> invalid_arg "Set.bal"
        | Node(rl, rv, rr, _) ->
            if height rr >= height rl then
              create (create l x rl) rv rr
            else begin
              match rl with
                Empty -> invalid_arg "Set.bal"
              | Node(rll, rlv, rlr, _) ->
                  create (create l x rll) rlv (create rlr rv rr)
            end
      end else
        Node(l, x, r, (if hl >= hr then hl + 1 else hr + 1))

    (* Same as bal, but repeat rebalancing until the final result
       is balanced. *)

    let rec join l x r =
      match bal l x r with
        Empty -> invalid_arg "Set.join"
      | Node(l', x', r', _) as t' ->
          let d = height l' - height r' in
          if d < -2 or d > 2 then join l' x' r' else t'

    (* Merge two trees l and r into one.
       All elements of l must precede the elements of r.
       Assumes | height l - height r | <= 2. *)

    let rec merge t1 t2 =
      match (t1, t2) with
        (Empty, t) -> t
      | (t, Empty) -> t
      | (Node(l1, v1, r1, h1), Node(l2, v2, r2, h2)) ->
          bal l1 v1 (bal (merge r1 l2) v2 r2)

    (* Same as merge, but does not assume anything about l and r. *)

    let rec concat t1 t2 =
      match (t1, t2) with
        (Empty, t) -> t
      | (t, Empty) -> t
      | (Node(l1, v1, r1, h1), Node(l2, v2, r2, h2)) ->
          join l1 v1 (join (concat r1 l2) v2 r2)

    (* Splitting *)

    let rec split x = function
        Empty ->
          (Empty, None, Empty)
      | Node(l, v, r, _) ->
          let c = compare_elt x v in
          if c = 0 then (l, Some v, r)
          else if c < 0 then
            let (ll, vl, rl) = split x l in (ll, vl, join rl v r)
          else
            let (lr, vr, rr) = split x r in (join l v lr, vr, rr)

    (* Implementation of the set operations *)

    let empty = Empty

    let is_empty = function Empty -> true | _ -> false

    let rec mem x = function
        Empty -> false
      | Node(l, v, r, _) ->
          let c = compare_elt x v in
          c = 0 || mem x (if c < 0 then l else r)

    let rec add x = function
        Empty -> Node(Empty, x, Empty, 1)
      | Node(l, v, r, _) as t ->
          let c = compare_elt x v in
          if c = 0 then t else
          if c < 0 then bal (add x l) v r else bal l v (add x r)

    let singleton x = Node(Empty, x, Empty, 1)

    let rec remove x = function
        Empty -> Empty
      | Node(l, v, r, _) ->
          let c = compare_elt x v in
          if c = 0 then merge l r else
          if c < 0 then bal (remove x l) v r else bal l v (remove x r)

    let rec union s1 s2 =
      match (s1, s2) with
        (Empty, t2) -> t2
      | (t1, Empty) -> t1
      | (Node(l1, v1, r1, h1), Node(l2, v2, r2, h2)) ->
          if h1 >= h2 then
            if h2 = 1 then add v2 s1 else begin
              let (l2, _, r2) = split v1 s2 in
              join (union l1 l2) v1 (union r1 r2)
            end
          else
            if h1 = 1 then add v1 s2 else begin
              let (l1, _, r1) = split v2 s1 in
              join (union l1 l2) v2 (union r1 r2)
            end

    let rec inter s1 s2 =
      match (s1, s2) with
        (Empty, t2) -> Empty
      | (t1, Empty) -> Empty
      | (Node(l1, v1, r1, _), t2) ->
          match split v1 t2 with
            (l2, None, r2) ->
              concat (inter l1 l2) (inter r1 r2)
          | (l2, Some _, r2) ->
              join (inter l1 l2) v1 (inter r1 r2)

    let rec diff s1 s2 =
      match (s1, s2) with
        (Empty, t2) -> Empty
      | (t1, Empty) -> t1
      | (Node(l1, v1, r1, _), t2) ->
          match split v1 t2 with
            (l2, None, r2) ->
              join (diff l1 l2) v1 (diff r1 r2)
          | (l2, Some _, r2) ->
              concat (diff l1 l2) (diff r1 r2)

    let equal s1 s2 =
      compare s1 s2 = 0

    let rec subset s1 s2 =
      match (s1, s2) with
        Empty, _ ->
          true
      | _, Empty ->
          false
      | Node (l1, v1, r1, _), (Node (l2, v2, r2, _) as t2) ->
          let c = compare_elt v1 v2 in
          if c = 0 then
            subset l1 l2 && subset r1 r2
          else if c < 0 then
            subset (Node (l1, v1, Empty, 0)) l2 && subset r1 t2
          else
            subset (Node (Empty, v1, r1, 0)) r2 && subset l1 t2

    let rec iter f = function
        Empty -> ()
      | Node(l, v, r, _) -> iter f l; f v; iter f r

    let rec fold f s accu =
      match s with
        Empty -> accu
      | Node(l, v, r, _) -> fold f l (f v (fold f r accu))

    let rec for_all p = function
        Empty -> true
      | Node(l, v, r, _) -> p v && for_all p l && for_all p r

    let rec exists p = function
        Empty -> false
      | Node(l, v, r, _) -> p v || exists p l || exists p r

    let filter p s =
      let rec filt accu = function
        | Empty -> accu
        | Node(l, v, r, _) ->
            filt (filt (if p v then add v accu else accu) l) r in
      filt Empty s

    let partition p s =
      let rec part (t, f as accu) = function
        | Empty -> accu
        | Node(l, v, r, _) ->
            part (part (if p v then (add v t, f) else (t, add v f)) l) r in
      part (Empty, Empty) s

    let rec cardinal = function
        Empty -> 0
      | Node(l, v, r, _) -> cardinal l + 1 + cardinal r

    let rec elements_aux accu = function
        Empty -> accu
      | Node(l, v, r, _) -> elements_aux (v :: elements_aux accu r) l

    let elements s =
      elements_aux [] s

    let rec min_elt = function
        Empty -> raise Not_found
      | Node(Empty, v, r, _) -> v
      | Node(l, v, r, _) -> min_elt l

    let rec max_elt = function
        Empty -> raise Not_found
      | Node(l, v, Empty, _) -> v
      | Node(l, v, r, _) -> max_elt r

    let choose = min_elt

======================================================================