X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=components%2Flibrary%2FcoercDb.ml;h=14ddf7c8631b5054aca10a8accc0268e9c12b05f;hb=65662e7d8de61a338b636f208d04e85eb59e6b8e;hp=c5356b3e17fb2dfe1f4722b22b4a952643bf9464;hpb=a5f945ea6f0fc6df47d90d00a75b6e7cce8e008e;p=helm.git

diff --git a/components/library/coercDb.ml b/components/library/coercDb.ml
index c5356b3e1..14ddf7c86 100644
--- a/components/library/coercDb.ml
+++ b/components/library/coercDb.ml
@@ -25,7 +25,13 @@
 
 (* $Id$ *)
 
-type coerc_carr = Uri of UriManager.uri | Sort of Cic.sort | Term of Cic.term
+type coerc_carr = 
+  | Uri of UriManager.uri 
+  | Sort of Cic.sort 
+  | Term of Cic.term
+  | Fun of int 
+;;
+
 exception EqCarrNotImplemented of string Lazy.t
 exception EqCarrOnNonMetaClosed
 
@@ -34,13 +40,21 @@ let db = ref []
 let coerc_carr_of_term t =
  try
   match t with
-     Cic.Sort s -> Sort s
+   | Cic.Sort s -> Sort s
+   | Cic.Prod _ -> Fun 0 
+     (* BUG: this should be the real arity. The computation
+      requires menv, context etc.., but since carrs are compared discharging Fun
+      arity... it works *)
    | Cic.Appl (t::_)
    | t -> Uri (CicUtil.uri_of_term t)
  with Invalid_argument _ ->
   Term t
 ;;
 
+let uri_of_carr = function
+  | Uri u -> Some u
+  | _ -> None
+
 let rec name_of_carr = function
   | Uri u -> UriManager.name_of_uri u
   | Sort s -> CicPp.ppsort s
@@ -52,46 +66,131 @@ let rec name_of_carr = function
   | Term t -> 
       prerr_endline ("CoercDb.name_of_carr:" ^ CicPp.ppterm t); 
       "FixTheNameMangler"
+  | Fun i -> "FunClass_" ^ string_of_int i   
+;;
 
-let eq_carr src tgt =
+let eq_carr ?(exact=false) src tgt =
   match src, tgt with
-  | Uri src, Uri tgt -> UriManager.eq src tgt
+  | Uri src, Uri tgt -> 
+      let coarse_eq = UriManager.eq src tgt in
+      let src_noxpointer = UriManager.strip_xpointer src in
+      if exact && coarse_eq && UriManager.uri_is_ind src_noxpointer then
+        match 
+          fst (CicEnvironment.get_obj CicUniv.oblivion_ugraph src_noxpointer)
+        with
+        | Cic.InductiveDefinition (_,[],m,_) when m = 0 -> true
+        | Cic.Constant _ -> true
+        | _ -> false
+      else
+        coarse_eq
   | Sort (Cic.Type _), Sort (Cic.Type _) -> true
   | Sort src, Sort tgt when src = tgt -> true
   | Term t1, Term t2 ->
-    if CicUtil.is_meta_closed t1 && CicUtil.is_meta_closed t2 then
-      raise 
-        (EqCarrNotImplemented 
+      if t1 = t2 then true
+      else
+        if CicUtil.is_meta_closed t1 && CicUtil.is_meta_closed t2 then
+          raise 
+          (EqCarrNotImplemented 
           (lazy ("Unsupported carr for coercions: " ^ 
-            CicPp.ppterm t1 ^ " or " ^ CicPp.ppterm t2)))
-    else raise EqCarrOnNonMetaClosed
+          CicPp.ppterm t1 ^ " or " ^ CicPp.ppterm t2)))
+      else raise EqCarrOnNonMetaClosed
+  | Fun _,Fun _ -> true (* only one Funclass? *)
+(*   | Fun i,Fun j when i=j -> true *)
+  | Term t, _
+  | _, Term t when not (CicUtil.is_meta_closed t) -> raise EqCarrOnNonMetaClosed
   | _, _ -> false
+;;
 
 let to_list () =
-  !db
-
-let add_coercion c =
-  db := c :: !db
+  List.map (fun (s,t,l) -> s,t,List.map (fun a,_,b -> a,b) l) !db
+;;
 
-let remove_coercion p = 
-  db := List.filter (fun u -> not(p u)) !db
+let rec myfilter p = function
+  | [] -> []
+  | (s,t,l)::tl ->
+      let l = 
+        HExtlib.filter_map 
+          (fun (u,n,saturations) -> 
+            if p (s,t,u,saturations) then
+              if n = 1 then
+                None
+              else
+                Some (u,n-1,saturations)
+            else
+              Some (u,n,saturations)) 
+          l 
+      in
+      if l = [] then myfilter p tl else (s,t,l)::myfilter p tl
+;;
+  
+let remove_coercion p = db := myfilter p !db;;
 
 let find_coercion f =
-  List.map (fun (_,_,x) -> x) (List.filter (fun (s,t,_) -> f (s,t)) !db)
-
-let is_a_coercion u =
-  List.exists (fun (_,_,x) -> UriManager.eq x u) !db
+    List.map
+    (fun uri,_,saturations -> uri,saturations)
+    (List.flatten
+    (HExtlib.filter_map (fun (s,t,l) -> if f (s,t) then Some l else None) !db))
+;;
 
 let get_carr uri =
   try
-    let src, tgt, _ = List.find (fun (_,_,x) -> UriManager.eq x uri) !db in
+    let src, tgt, _ = 
+      List.find 
+        (fun (_,_,xl) -> List.exists (fun (x,_,_) -> UriManager.eq uri x) xl) 
+        !db 
+    in
     src, tgt
   with Not_found -> assert false (* uri must be a coercion *)
+;;
+
+let is_a_coercion u = 
+  List.exists 
+    (fun (_,_,xl) -> List.exists (fun (x,_,_) -> UriManager.eq u x) xl) 
+    !db
+;;
+
+let is_a_coercion' t = 
+  try
+    let uri = CicUtil.uri_of_term t in
+     is_a_coercion uri
+  with Invalid_argument _ -> false
+;;
+
+let is_a_coercion_to_funclass t =
+  try
+    let uri = CicUtil.uri_of_term t in
+    match snd (get_carr uri) with
+    | Fun i -> Some i
+    | _ -> None
+  with Invalid_argument _ -> None
+  
 
 let term_of_carr = function
   | Uri u -> CicUtil.term_of_uri u
   | Sort s -> Cic.Sort s
+  | Fun _ -> assert false
   | Term _ -> assert false
+;;
   
-
-
+let add_coercion (src,tgt,u,saturations) =
+  let f s t = eq_carr s src && eq_carr t tgt in
+  let where = List.filter (fun (s,t,_) -> f s t) !db in
+  let rest = List.filter (fun (s,t,_) -> not (f s t)) !db in
+  match where with
+  | [] -> db := (src,tgt,[u,1,saturations]) :: !db
+  | (src,tgt,l)::tl ->
+      assert (tl = []); (* not sure, this may be a feature *)
+      if List.exists (fun (x,_,_) -> UriManager.eq u x) l then
+        let l' = List.map
+          (fun (x,n,saturations') ->
+            if UriManager.eq u x then
+             (x,n+1,saturations)
+            else
+             (x,n,saturations))
+          l
+        in
+        db := (src,tgt,l')::tl @ rest
+      else
+        db := (src,tgt,(u,1,saturations)::l)::tl @ rest
+      
+;;