(* un modul parametrizat, la fel ca modulul standard Set
 * are în plus o funcție care creează o mulțime dintr-o listă *)

module LstSet (Elt: Set.OrderedType) =        (* Elt = modulul pentru elemente *)
  struct
    include Set.Make(Elt)        (* include conținutul modulului set *)

    (* creează mulțime din listă
     * adaugă elemente la mulțimea vidă *)

    let set_of_list = List.fold_left (fun r e -> add e r) empty
  end

(* modul parametrizat cu două module pentru cele două tipuri de elemente *)

module CartSet (Elt1: Set.OrderedType) (Elt2: Set.OrderedType) =
  struct
    module S1 = LstSet(Elt1)        (* modul pentru multimea de primul tip *)
    module S2 = LstSet(Elt2)        (* modul pentru multimea de al doilea tip *)

      (* modul cu tipul perechilor dintre tipul 1 și tipul 2
       * e definit tipul elementelor: tip pereche
       * si funcția de comparare -- se preia cea standard
       * include modulul, odată ce e definit *)
    include LstSet(struct type t = S1.elt * S2.elt
                              let compare = compare end)
    let cartprod s1 s2 =
      (* mulțime de perechi între un element din s1 și b
       * e1 parcurge multimea s1; se adaugă perechea (e1, b) la acumulator *)
      let appendpairs s1 b = S1.fold (fun e1 -> add (e1, b)) s1
      (* parcurge mulțimea 2, creează perechi cu toate elementele din s1 *)
      in S2.fold (appendpairs s1) s2 empty
  end

module CS = CartSet(struct type t = int let compare = compare end)(Char)
;;

(* face produsul cartezian
 * apoi transformă în listă pentru vizualizare în interpretor *)
CS.elements (CS.cartprod (CS.S1.set_of_list [1;2;3]) (CS.S2.set_of_list ['a';'b']));;

This document was generated using caml2html