(* $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
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 ->
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 t = CicUtil.term_of_uri src in
+ let ty,_ = CicTypeChecker.type_of_aux' [] [] t CicUniv.oblivion_ugraph in
+ (match ty, exact with
+ | Cic.Prod _, true -> false
+ | Cic.Prod _, false -> coarse_eq
+ | _ -> coarse_eq)
| Sort (Cic.Type _), Sort (Cic.Type _) -> true
| Sort src, Sort tgt when src = tgt -> true
| Term t1, Term t2 ->
(lazy ("Unsupported carr for coercions: " ^
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
+ List.map (fun (s,t,l) -> s,t,List.map (fun a,_,b -> a,b) l) !db
+;;
let rec myfilter p = function
| [] -> []
| (s,t,l)::tl ->
- let l = List.filter (fun u -> not (p (s,t,u))) l in
+ 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.flatten
- (List.map
- (fun (_,_,x) -> x)
- (List.filter (fun (s,t,_) -> f (s,t)) !db))
-;;
-
-let is_a_coercion u =
- List.exists (fun (_,_,xl) -> List.exists (UriManager.eq u) xl) !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 (_,_,xl) -> List.exists (UriManager.eq uri) xl) !db
+ 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) =
+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]) :: !db
+ | [] -> db := (src,tgt,[u,1,saturations]) :: !db
| (src,tgt,l)::tl ->
assert (tl = []); (* not sure, this may be a feature *)
- db := (src,tgt,u::l)::tl @ rest
+ 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
+
;;
-
-
+type coerc_db = (coerc_carr * coerc_carr * (UriManager.uri * int * int) list) list
+let dump () = !db
+let restore coerc_db = db := coerc_db