viewcvs.cgi/types/types.ml

open Recursive
open Printf


let map_sort f l =
  SortedList.from_list (List.map f l)

type label = int
type atom  = int

let counter_label = ref 0
let label_table = Hashtbl.create 63
let label_names = Hashtbl.create 63

let label s =
  try Hashtbl.find label_table s
  with Not_found ->
    incr counter_label;
    Hashtbl.add label_table s !counter_label;
    Hashtbl.add label_names !counter_label s;
    !counter_label

let label_name l =
  Hashtbl.find label_names l

let mk_atom = label

let atom_name = label_name

type const = Integer of Big_int.big_int | Atom of atom | Char of Chars.Unichar.t

module I = struct
  type 'a t = {
    ints  : Intervals.t;
    atoms : atom Atoms.t;
    times : ('a * 'a) Boolean.t;
    arrow : ('a * 'a) Boolean.t;
    record: (label * bool * 'a) Boolean.t;
    chars : Chars.t;
  }

  let empty = { 
    times = Boolean.empty; 
    arrow = Boolean.empty; 
    record= Boolean.empty;
    ints  = Intervals.empty;
    atoms = Atoms.empty;
    chars = Chars.empty;
  }

  let any =  {
    times = Boolean.full; 
    arrow = Boolean.full; 
    record= Boolean.full; 
    ints  = Intervals.any;
    atoms = Atoms.any;
    chars = Chars.any;
  }
               
  let interval i = { empty with ints = i }
  let times x y = { empty with times = Boolean.atom (x,y) }
  let arrow x y = { empty with arrow = Boolean.atom (x,y) }
  let record label opt t = { empty with record = Boolean.atom (label,opt,t) }
  let atom a = { empty with atoms = a }
  let char c = { empty with chars = c }
  let constant = function
    | Integer i -> interval (Intervals.atom i)
    | Atom a -> atom (Atoms.atom a)
    | Char c -> char (Chars.atom c)

                   
  let any_record = { empty with record = any.record }

  let cup x y = 
    if x = y then x else { 
      times = Boolean.cup x.times y.times;
      arrow = Boolean.cup x.arrow y.arrow;
      record= Boolean.cup x.record y.record;
      ints  = Intervals.cup x.ints  y.ints;
      atoms = Atoms.cup x.atoms y.atoms;
      chars = Chars.cup x.chars y.chars;
    }
      
  let cap x y = 
    if x = y then x else {
      times = Boolean.cap x.times y.times;
      record= Boolean.cap x.record y.record;
      arrow = Boolean.cap x.arrow y.arrow;
      ints  = Intervals.cap x.ints  y.ints;
      atoms = Atoms.cap x.atoms y.atoms;
      chars = Chars.cap x.chars y.chars;
    }
      
  let diff x y = 
    if x = y then empty else { 
      times = Boolean.diff x.times y.times;
      arrow = Boolean.diff x.arrow y.arrow;
      record= Boolean.diff x.record y.record;
      ints  = Intervals.diff x.ints  y.ints;
      atoms = Atoms.diff x.atoms y.atoms;
      chars = Chars.diff x.chars y.chars;
    }

  let neg x = diff any x
                   
  let equal e a b =
    if a.atoms <> b.atoms then raise NotEqual;
    if a.chars <> b.chars then raise NotEqual;
    if a.ints <> b.ints then raise NotEqual;
    Boolean.equal (fun (x1,x2) (y1,y2) -> e x1 y1; e x2 y2) a.times b.times;
    Boolean.equal (fun (x1,x2) (y1,y2) -> e x1 y1; e x2 y2) a.arrow b.arrow;
    Boolean.equal (fun (l1,o1,x1) (l2,o2,x2) -> 
                     if (l1 <> l2) || (o1 <> o2) then raise NotEqual;
                     e x1 x2) a.record b.record
      
  let map f a =
    { times = Boolean.map (fun (x1,x2) -> (f x1, f x2)) a.times;
      arrow = Boolean.map (fun (x1,x2) -> (f x1, f x2)) a.arrow;
      record= Boolean.map (fun (l,o,x) -> (l,o, f x)) a.record;
      ints  = a.ints;
      atoms = a.atoms;
      chars = a.chars;
    }
    
  let hash h a =
    Hashtbl.hash (map h a)
(*
    (Hashtbl.hash { (map h a) with ints = Intervals.empty })
    + (Intervals.hash a.ints)
*)
      
  let iter f a =
    ignore (map f a)
     
  let deep = 4
end

             
module Algebra = Recursive_noshare.Make(I)
include I
include Algebra
module DescrHash = 
  Hashtbl.Make(
    struct 
      type t = descr
      let hash = hash_descr
      let equal = equal_descr
    end
  )

module DescrMap = Map.Make(struct type t = descr let compare = compare end)

let check d =
  Boolean.check d.times;
  Boolean.check d.arrow;
  Boolean.check d.record;
  ()

(*
let define n d = check d; define n d
*)

let cons d =
  let n = make () in
  define n d;
  internalize n


module Print = 
struct
  let print_atom ppf a = Format.fprintf ppf "`%s" (atom_name a)

  let print_const ppf = function
    | Integer i -> Format.fprintf ppf "%s" (Big_int.string_of_big_int i)
    | Atom a -> print_atom ppf a
    | Char c -> Chars.Unichar.print ppf c

  let named = DescrHash.create 10
  let register_global name d = DescrHash.add named d name

  let marks = DescrHash.create 63
  let wh = ref []
  let count_name = ref 0
  let name () =
    incr count_name;
    "X" ^ (string_of_int !count_name)
(* TODO: 
   check that these generated names does not conflict with declared types *)

  let bool_iter f b =
    List.iter (fun (p,n) -> List.iter f p; List.iter f n) b

  let trivial b = b = Boolean.empty || b = Boolean.full

  let worth_abbrev d = 
    not (trivial d.times && trivial d.arrow && trivial d.record) 

  let rec mark n = mark_descr (descr n)
  and mark_descr d =
    if not (DescrHash.mem named d) then
      try 
        let r = DescrHash.find marks d in
        if (!r = None) && (worth_abbrev d) then 
          let na = name () in 
          r := Some na;
          wh := (na,d) :: !wh
      with Not_found -> 
        DescrHash.add marks d (ref None);
        bool_iter (fun (n1,n2) -> mark n1; mark n2) d.times;
        bool_iter (fun (n1,n2) -> mark n1; mark n2) d.arrow;
        bool_iter (fun (l,o,n) -> mark n) d.record

    
  let rec print_union ppf = function
    | [] -> Format.fprintf ppf "Empty"
    | [h] -> h ppf
    | h::t -> Format.fprintf ppf "@[%t |@ %a@]" h print_union t


  let rec print ppf n = print_descr ppf (descr n)
  and print_descr ppf d = 
    try 
      let name = DescrHash.find named d in
      Format.fprintf ppf "%s" name
    with Not_found ->
      try
        match !(DescrHash.find marks d) with
          | Some n -> Format.fprintf ppf "%s" n
          | None -> real_print_descr ppf d
      with
          Not_found -> Format.fprintf ppf "XXX"
  and real_print_descr ppf d = 
    if d = any then Format.fprintf ppf "Any" else
      print_union ppf 
        (Intervals.print d.ints @
         Chars.print d.chars @
         Atoms.print "Atom" print_atom d.atoms @
         Boolean.print "Pair" print_times d.times @
         Boolean.print "Arrow" print_arrow d.arrow @
         Boolean.print "Record" print_record d.record
        )
  and print_times ppf (t1,t2) =
    Format.fprintf ppf "@[(%a,%a)@]" print t1 print t2
  and print_arrow ppf (t1,t2) =
    Format.fprintf ppf "@[(%a -> %a)@]" print t1 print t2
  and print_record ppf (l,o,t) =
    Format.fprintf ppf "@[{ %s =%s %a }@]" 
      (label_name l) (if o then "?" else "") print t

          
  let end_print ppf =
    (match List.rev !wh with
       | [] -> ()
       | (na,d)::t ->
           Format.fprintf ppf " where@ @[%s = %a" na real_print_descr d;
           List.iter 
             (fun (na,d) -> 
                Format.fprintf ppf " and@ %s = %a" na real_print_descr d)
             t;
           Format.fprintf ppf "@]"
    );
    Format.fprintf ppf "@]";
    count_name := 0;
    wh := [];
    DescrHash.clear marks

  let print_descr ppf d =
    mark_descr d;
    Format.fprintf ppf "@[%a" print_descr d;
    end_print ppf

   let print ppf n = print_descr ppf (descr n)

end


module Positive =
struct
  type rhs = [ `Type of descr | `Cup of v list | `Times of v * v ]
  and v = { mutable def : rhs; mutable node : node option }


  let rec make_descr seen v =
    if List.memq v seen then empty
    else
      let seen = v :: seen in
      match v.def with
        | `Type d -> d
        | `Cup vl -> 
            List.fold_left (fun acc v -> cup acc (make_descr seen v)) empty vl
        | `Times (v1,v2) -> times (make_node v1) (make_node v2)

  and make_node v =
    match v.node with
      | Some n -> n
      | None ->
          let n = make () in
          v.node <- Some n;
          let d = make_descr [] v in
          define n d;
          n

  let forward () = { def = `Cup []; node = None }
  let def v d = v.def <- d
  let cons d = let v = forward () in def v d; v
  let ty d = cons (`Type d)
  let cup vl = cons (`Cup vl)
  let times d1 d2 = cons (`Times (d1,d2))
  let define v1 v2 = def v1 (`Cup [v2]) 

  let solve v = internalize (make_node v)
end


let get_record r =
  let add = SortedMap.add (fun (o1,t1) (o2,t2) -> (o1&&o2, cap t1 t2)) in
  let line (p,n) =
    let accu = List.fold_left 
                 (fun accu (l,o,t) -> add l (o,descr t) accu) [] p in
    List.fold_left 
      (fun accu (l,o,t) -> add l (not o,neg (descr t)) accu) accu n in
  List.map line r
    

(* Subtyping algorithm *)

let diff_t d t = diff d (descr t)
let cap_t d t = cap d (descr t)
let cap_product l = 
  List.fold_left 
    (fun (d1,d2) (t1,t2) -> (cap_t d1 t1, cap_t d2 t2))
    (any,any)
    l


module Assumptions = Set.Make(struct type t = descr let compare = compare end)

let memo = ref Assumptions.empty
let cache_false = ref Assumptions.empty

exception NotEmpty

let rec empty_rec d =
  if Assumptions.mem d !cache_false then false 
  else if Assumptions.mem d !memo then true
  else if not (Intervals.is_empty d.ints) then false
  else if not (Atoms.is_empty d.atoms) then false
  else if not (Chars.is_empty d.chars) then false
  else (
    let backup = !memo in
    memo := Assumptions.add d backup;
    if 
      (empty_rec_times d.times) &&
      (empty_rec_arrow d.arrow) &&
      (empty_rec_record d.record) 
    then true
    else (
      memo := backup;
      cache_false := Assumptions.add d !cache_false;
      false
    )
  )

and empty_rec_times c =
  List.for_all empty_rec_times_aux c

and empty_rec_times_aux (left,right) =
  let rec aux accu1 accu2 = function
    | (t1,t2)::right ->
        let accu1' = diff_t accu1 t1 in
        if not (empty_rec accu1') then aux accu1' accu2 right;
        let accu2' = diff_t accu2 t2 in
        if not (empty_rec accu2') then aux accu1 accu2' right
    | [] -> raise NotEmpty
  in
  let (accu1,accu2) = cap_product left in
  (empty_rec accu1) || (empty_rec accu2) ||
  (try aux accu1 accu2 right; true with NotEmpty -> false)

and empty_rec_arrow c =
  List.for_all empty_rec_arrow_aux c

and empty_rec_arrow_aux (left,right) =
  let single_right (s1,s2) =
    let rec aux accu1 accu2 = function
      | (t1,t2)::left ->
          let accu1' = diff_t accu1 t1 in
          if not (empty_rec accu1') then aux accu1 accu2 left;
          let accu2' = cap_t accu2 t2 in
          if not (empty_rec accu2') then aux accu1 accu2 left
      | [] -> raise NotEmpty
    in
    let accu1 = descr s1 in
    (empty_rec accu1) ||
    (try aux accu1 (diff any (descr s2)) left; true with NotEmpty -> false)
  in
  List.exists single_right right

and empty_rec_record c =
  let aux = List.exists (fun (_,(opt,t)) -> (not opt) && (empty_rec t)) in
  List.for_all aux (get_record c)

let is_empty d =
  let old = !memo in
  let r = empty_rec d in
  if not r then memo := old; 
(*  cache_false := Assumptions.empty;  *)
  r

let non_empty d = 
  not (is_empty d)

let subtype d1 d2 =
  is_empty (diff d1 d2)

(* Sample value *)
module Sample =
struct

let rec find f = function
  | [] -> raise Not_found
  | x::r -> try f x with Not_found -> find f r

type t =
  | Int of Big_int.big_int
  | Atom of atom
  | Char of Chars.Unichar.t
  | Pair of t * t
  | Record of (label * t) list
  | Fun of (node * node) list

let rec gen_atom i l =
  if SortedList.mem l i then gen_atom (succ i) l  else i

let rec sample_rec memo d =
  if (Assumptions.mem d memo) || (is_empty d) then raise Not_found 
  else 
    try Int (Intervals.sample d.ints) with Not_found ->
    try Atom (Atoms.sample (gen_atom 0) d.atoms) with Not_found ->
    try Char (Chars.sample d.chars) with Not_found ->
    try sample_rec_arrow d.arrow with Not_found ->

    let memo = Assumptions.add d memo in
    try sample_rec_times memo d.times with Not_found ->
    try sample_rec_record memo d.record with Not_found -> 
    raise Not_found


and sample_rec_times memo c = 
  find (sample_rec_times_aux memo) c

and sample_rec_times_aux memo (left,right) =
  let rec aux accu1 accu2 = function
    | (t1,t2)::right ->
        let accu1' = diff_t accu1 t1 in
        if non_empty accu1' then aux accu1' accu2 right else
          let accu2' = diff_t accu2 t2 in
          if non_empty accu2' then aux accu1 accu2' right else
            raise Not_found
    | [] -> Pair (sample_rec memo accu1, sample_rec memo accu2)
  in
  let (accu1,accu2) = cap_product left in
  if (is_empty accu1) || (is_empty accu2) then raise Not_found;
  aux accu1 accu2 right

and sample_rec_arrow c =
  find sample_rec_arrow_aux c

and check_empty_simple_arrow_line left (s1,s2) = 
  let rec aux accu1 accu2 = function
    | (t1,t2)::left ->
        let accu1' = diff_t accu1 t1 in
        if non_empty accu1' then aux accu1 accu2 left;
        let accu2' = cap_t accu2 t2 in
        if non_empty accu2' then aux accu1 accu2 left
    | [] -> raise NotEmpty
  in
  let accu1 = descr s1 in
  (is_empty accu1) ||
  (try aux accu1 (diff any (descr s2)) left; true with NotEmpty -> false)

and check_empty_arrow_line left right = 
  List.exists (check_empty_simple_arrow_line left) right

and sample_rec_arrow_aux (left,right) =
  if (check_empty_arrow_line left right) then raise Not_found
  else Fun left


and sample_rec_record memo c =
  Record (find (sample_rec_record_aux memo) (get_record c))

and sample_rec_record_aux memo fields =
  let aux acc (l,(o,t)) = if o then acc else (l, sample_rec memo t) :: acc in
  List.fold_left aux [] fields

let get x = sample_rec Assumptions.empty x

  let rec print_sep f sep ppf = function
    | [] -> ()
    | [x] -> f ppf x
    | x::rem -> f ppf x; Format.fprintf ppf "%s" sep; print_sep f sep ppf rem


  let rec print ppf = function
    | Int i -> Format.fprintf ppf "%s" (Big_int.string_of_big_int i)
    | Atom a -> Format.fprintf ppf "`%s" (atom_name a)
    | Char c -> Chars.Unichar.print ppf c
    | Pair (x1,x2) -> Format.fprintf ppf "(%a,%a)" print x1 print x2
    | Record r ->
        Format.fprintf ppf "{ %a }"
          (print_sep 
             (fun ppf (l,x) -> 
                Format.fprintf ppf "%s = %a"
                (label_name l)
                print x
             )
             " ; "
          ) r
    | Fun iface ->
        Format.fprintf ppf "(fun ( %a ) x -> ...)"
          (print_sep
             (fun ppf (t1,t2) ->
                Format.fprintf ppf "%a -> %a; "
                Print.print t1 Print.print t2
             )
             " ; "
          ) iface
end


module Product =
struct
  type t = (descr * descr) list

  let other d = { d with times = empty.times }
  let is_product d = is_empty (other d)

  let need_second = function _::_::_ -> true | _ -> false

  let normal_aux d =
    let res = ref [] in

    let add (t1,t2) =
      let rec loop t1 t2 = function
        | [] -> res := (ref (t1,t2)) :: !res
        | ({contents = (d1,d2)} as r)::l ->
            (*OPT*) 
            if d1 = t1 then r := (d1,cup d2 t2) else
              
              let i = cap t1 d1 in
              if is_empty i then loop t1 t2 l
              else (
                r := (i, cup t2 d2);
                let k = diff d1 t1 in 
                if non_empty k then res := (ref (k,d2)) :: !res;
                
                let j = diff t1 d1 in 
                if non_empty j then loop j t2 l
              )
      in
      loop t1 t2 !res
    in
    List.iter add d;
    List.map (!) !res

(*
This version explodes when dealing with
   Any - [ t1? t2? t3? ... tn? ]
==> need partitioning 
*)
  let get_aux d =
    let line accu (left,right) =
      let debug = List.length right = 28 in
      let rec aux accu d1 d2 = function
        | (t1,t2)::right ->
            let accu = 
              let d1 = diff_t d1 t1 in
              if is_empty d1 then accu else aux accu d1 d2 right in
            let accu =
              let d2 = diff_t d2 t2 in
              if is_empty d2 then accu else aux accu d1 d2 right in
            accu
        | [] -> (d1,d2) :: accu
      in
      let (d1,d2) = cap_product left in
      if (is_empty d1) || (is_empty d2) then accu else aux accu d1 d2 right
    in
    List.fold_left line [] d

(* Partitioning:

(t,s) - ((t1,s1) | (t2,s2) | ... | (tn,sn))
=
(t & t1, s - s1) | ... | (t & tn, s - sn) | (t - (t1|...|tn), s)

*)

  let get_aux d =
    let accu = ref [] in
    let line (left,right) =
      let (d1,d2) = cap_product left in
      if (non_empty d1) && (non_empty d2) then
        let right = List.map (fun (t1,t2) -> descr t1, descr t2) right in
        let right = normal_aux right in
        let resid1 = ref d1 in
        let () = 
          List.iter
            (fun (t1,t2) ->
               let t1 = cap d1 t1 in
               if (non_empty t1) then
                 let () = resid1 := diff !resid1 t1 in
                 let t2 = diff d2 t2 in
                 if (non_empty t2) then accu := (t1,t2) :: !accu
            ) right in
        if non_empty !resid1 then accu := (!resid1, d2) :: !accu 
    in
    List.iter line d;
    !accu

  let get d = get_aux d.times

  let pi1 = List.fold_left (fun acc (t1,_) -> cup acc t1) empty
  let pi2 = List.fold_left (fun acc (_,t2) -> cup acc t2) empty

  let restrict_1 rects pi1 =
    let aux accu (t1,t2) = 
      let t1 = cap t1 pi1 in if is_empty t1 then accu else (t1,t2)::accu in
    List.fold_left aux [] rects
  
  type normal = t

  module Memo = Map.Make(struct 
                           type t = (node * node) Boolean.t
                           let compare = compare end)
                           

  let memo = ref Memo.empty
  let normal d = 
    let d = d.times in
    try Memo.find d !memo 
    with
        Not_found ->
          let gd = get_aux d in
          let n = normal_aux gd in
          memo := Memo.add d n !memo;
          n

  let any = { empty with times = any.times }
  let is_empty d = d = []
end


module Record = 
struct
  type t = (label, (bool * descr)) SortedMap.t list

  let get d =
    let line r = List.for_all (fun (l,(o,d)) -> o || non_empty d) r in
    List.filter line (get_record d.record)

  let restrict_label_present t l =
    let restr = function 
      | (true, d) -> if non_empty d then (false,d) else raise Exit 
      | x -> x in
    let aux accu r =  
      try SortedMap.change l restr (false,any) r :: accu
      with Exit -> accu in
    List.fold_left aux [] t

  let restrict_label_absent t l =
    let restr = function (true, _) -> (true,empty) | _ -> raise Exit in
    let aux accu r =  
      try SortedMap.change l restr (true,empty) r :: accu
      with Exit -> accu in
    List.fold_left aux [] t

  let restrict_field t l d =
    let restr (_,d1) = 
      let d1 = cap d d1 in 
      if is_empty d1 then raise Exit else (false,d1) in
    let aux accu r = 
      try SortedMap.change l restr (false,d) r :: accu 
      with Exit -> accu in
    List.fold_left aux [] t

  let project_field t l =
    let aux accu x =
      match List.assoc l x with
        | (false,t) -> cup accu t
        | _ -> raise Not_found
    in
    List.fold_left aux empty t

  let project d l =
    project_field (get_record d.record) l

  type normal = 
      [ `Success
      | `Fail
      | `Label of label * (descr * normal) list * normal ]

  let rec merge_record n r =
    match (n, r) with
      | (`Success, _) | (_, []) -> `Success
      | (`Fail, r) ->
          let aux (l,(o,t)) n = 
            `Label (l, [t,n], if o then n else `Fail) in
          List.fold_right aux r `Success
      | (`Label (l1,present,absent), (l2,(o,t2))::r') ->
          if (l1 < l2) then
            let pr =  List.map (fun (t,x) -> (t, merge_record x r)) present in
            let t = List.fold_left (fun a (t,_) -> diff a t) any present in
            let pr = 
              if non_empty t then (t, merge_record `Fail r) :: pr
              else pr in
            `Label (l1,pr,merge_record absent r)
          else if (l2 < l1) then
            let n' = merge_record n r' in
            `Label (l2, [t2, n'], if o then n' else n)
          else
            let res = ref [] in
            let aux a (t,x) = 
              (let t = diff t t2 in 
               if non_empty t then res := (t,x) :: !res);
              (let t = cap t t2 in
               if non_empty t then res := (t, merge_record x r') :: !res);
              diff a t 
            in
            let t2 = List.fold_left aux t2 present in
            let () = 
              if non_empty t2 then 
              res := (t2, merge_record `Fail r') :: !res in
            let abs = if o then merge_record absent r' else absent in
            `Label (l1, !res, abs)

  module Unify = Map.Make(struct type t = normal let compare = compare end)

  let repository = ref Unify.empty

  let rec canonize = function
    | `Label (l,pr,ab) as x ->
        (try Unify.find x !repository 
         with Not_found -> 
           let pr = List.map (fun (t,n) -> canonize n,t) pr in
           let pr = SortedMap.from_list cup pr in
           let pr = List.map (fun (n,t) -> (t,n)) pr in
           let x = `Label (l, pr, canonize ab) in
           try Unify.find x !repository
           with Not_found -> repository := Unify.add x x !repository; x
        )
    | x -> x

  let normal d =
    let r = canonize (List.fold_left merge_record `Fail (get d)) in
    repository := Unify.empty;
    r

  type normal' =
      [ `Success
      | `Label of label * (descr * descr) list * descr option ] option

(* NOTE: this function relies on the fact that generic order
         makes smallest labels appear first *)

  let first_label d =
    let d = d.record in
    let min = ref None in
    let lab (l,o,t) = match !min with 
      | Some l' when l >= l' -> () 
      | _ -> if o && (descr t = any) then () else min := Some l in
    let line (p,n) =
      (match p with f::_ -> lab f | _ -> ());
      (match n with f::_ -> lab f | _ -> ()) in
    List.iter line d;
    match !min with
      | None -> if d = [] then `Empty else `Any
      | Some l -> `Label l

  let normal' (d : descr) l =
    let ab = ref empty in
    let rec extract f = function
      | (l',o,t) :: rem when l = l' -> 
          f o (descr t); extract f rem
      | x :: rem -> x :: (extract f rem)
      | [] -> [] in
    let line (p,n) =
      let ao = ref true and ad = ref any in
      let p = 
        extract (fun o d -> ao := !ao && o; ad := cap !ad d) p
      and n = 
        extract (fun o d -> ao := !ao && not o; ad := diff !ad d) n
      in
      (* Note: p and n are still sorted *)
      let d = { empty with record = [(p,n)] } in
      if !ao then ab := cup d !ab;
      (!ad, d) in
    let pr = List.map line d.record in
    let pr = Product.normal_aux pr in
    let ab = if is_empty !ab then None else Some !ab in
    (pr, ab)
            

  let any = { empty with record = any.record }
  let is_empty d = d = []
  let descr l =
    let line l = map_sort (fun (l,(o,d)) -> (l,o,cons d)) l, [] in 
    { empty with record = map_sort line l }
end


let memo_normalize = ref DescrMap.empty


let rec rec_normalize d =
  try DescrMap.find d !memo_normalize
  with Not_found ->
    let n = make () in
    memo_normalize := DescrMap.add d n !memo_normalize;
    let times = 
      map_sort
        (fun (d1,d2) -> [(rec_normalize d1, rec_normalize d2)],[])
        (Product.normal d)
    in
    let record = 
      map_sort
        (fun f -> map_sort (fun (l,(o,d)) -> (l,o,rec_normalize d)) f, [])
        (Record.get d)
    in
    define n { d with times = times; record = record };
    n

let normalize n =
  descr (internalize (rec_normalize n))

module Arrow =
struct
  let check_simple left s1 s2 =
    let rec aux accu1 accu2 = function
      | (t1,t2)::left ->
          let accu1' = diff_t accu1 t1 in
          if non_empty accu1' then aux accu1 accu2 left;
          let accu2' = cap_t accu2 t2 in
          if non_empty accu2' then aux accu1 accu2 left
      | [] -> raise NotEmpty
    in
    let accu1 = descr s1 in
    (is_empty accu1) ||
    (try aux accu1 (diff any (descr s2)) left; true with NotEmpty -> false)
      
  let check_strenghten t s =
    let left = match t.arrow with [ (p,[]) ] -> p | _ -> assert false in
    let rec aux = function
      | [] -> raise Not_found
      | (p,n) :: rem ->
          if (List.for_all (fun (a,b) -> check_simple left a b) p) &&
            (List.for_all (fun (a,b) -> not (check_simple left a b)) n) then
              { empty with arrow = [ (SortedList.cup left p, n) ] }
          else aux rem
    in
    aux s.arrow

  let check_simple_iface left s1 s2 =
    let rec aux accu1 accu2 = function
      | (t1,t2)::left ->
          let accu1' = diff accu1 t1 in
          if non_empty accu1' then aux accu1 accu2 left;
          let accu2' = cap accu2 t2 in
          if non_empty accu2' then aux accu1 accu2 left
      | [] -> raise NotEmpty
    in
    let accu1 = descr s1 in
    (is_empty accu1) ||
    (try aux accu1 (diff any (descr s2)) left; true with NotEmpty -> false)

  let check_iface iface s =
    let rec aux = function
      | [] -> false
      | (p,n) :: rem ->
          ((List.for_all (fun (a,b) -> check_simple_iface iface a b) p) &&
           (List.for_all (fun (a,b) -> not (check_simple_iface iface a b)) n))
          || (aux rem)
    in
    aux s.arrow

  type t = descr * (descr * descr) list list

  let get t =
    List.fold_left
      (fun ((dom,arr) as accu) (left,right) ->
         if Sample.check_empty_arrow_line left right 
         then accu
         else (
           let left =
             List.map 
               (fun (t,s) -> (descr t, descr s)) left in
           let d = List.fold_left (fun d (t,_) -> cup d t) empty left in
           (cap dom d, left :: arr)
         )
      )
      (any, [])
      t.arrow

  let domain (dom,_) = dom

  let apply_simple t result left = 
    let rec aux result accu1 accu2 = function
      | (t1,s1)::left ->
          let result = 
            let accu1 = diff accu1 t1 in
            if non_empty accu1 then aux result accu1 accu2 left
            else result in
          let result =
            let accu2 = cap accu2 s1 in
            aux result accu1 accu2 left in
          result
      | [] -> 
          if subtype accu2 result 
          then result
          else cup result accu2
    in
    aux result t any left
      
  let apply (_,arr) t =
    List.fold_left (apply_simple t) empty arr

  let need_arg (dom, arr) =
    List.exists (function [_] -> false | _ -> true) arr

  let apply_noarg (_,arr) =
    List.fold_left 
      (fun accu -> 
         function 
           | [(t,s)] -> cup accu s
           | _ -> assert false
      )
      empty arr

  let any = { empty with arrow = any.arrow }
  let is_empty (_,arr) = arr = []
end
  

module Int = struct
  let has_int d i = Intervals.contains i d.ints

  let get d = d.ints
  let put i = { empty with ints = i }
  let is_int d = is_empty { d with ints = Intervals.empty }
  let any = { empty with ints = Intervals.any }
end

module Atom = struct
  let has_atom d a = Atoms.contains a d.atoms
end

module Char = struct
  let has_char d c = Chars.contains c d.chars
  let any = { empty with chars = Chars.any }
end

(*
let rec print_normal_record ppf = function
  | Success -> Format.fprintf ppf "Yes"
  | Fail -> Format.fprintf ppf "No"
  | FirstLabel (l,present,absent) ->
      Format.fprintf ppf "%s?@[<v>@\n" (label_name l);
      List.iter
        (fun (t,n) ->
           Format.fprintf ppf "(%a)=>@[%a@]@\n" 
             Print.print_descr t
             print_normal_record n
        ) present;
      if absent <> Fail then
        Format.fprintf ppf "(absent)=>@[%a@]@\n" print_normal_record absent;
      Format.fprintf ppf "@]" 
*)


(* 
let pr s = Types.Print.print Format.std_formatter (Syntax.make_type (Syntax.parse s));;

let pr' s = Types.Print.print Format.std_formatter 
   (Types.normalize (Syntax.make_type (Syntax.parse s)));;

BUG:
pr "'a | 'b where 'a = ('a , 'a) and 'b= ('b , 'b)";;
*)


(*
  let nr s =
    let t = Types.descr (Syntax.make_type (Syntax.parse s)) in
    let n = Types.normal_record' t.Types.record in
    Types.print_normal_record Format.std_formatter n;;
*)