| LetIn of string * (* typ **) term * term
| Match of reference * term * (term_context * term) list
| BottomElim
- | TLambda of (* string **) term
+ | TLambda of string * term
| Inst of (*typ_former **) term
| Skip of term
| UnsafeCoerce of term
type term_former_decl = term_context * typ
type term_former_def = term_former_decl * term
+let mk_appl f x =
+ match f with
+ Appl args -> Appl (args@[x])
+ | _ -> Appl [f;x]
+
let rec size_of_term =
function
| Rel r -> 1
| UnitTerm -> 1
| Const c -> 1
- | Lambda (name, body) -> 1 + size_of_term body
+ | Lambda (_, body) -> 1 + size_of_term body
| Appl l -> List.length l
- | LetIn (name, def, body) -> 1 + size_of_term def + size_of_term body
- | Match (name, case, pats) -> 1 + size_of_term case + List.length pats
+ | LetIn (_, def, body) -> 1 + size_of_term def + size_of_term body
+ | Match (_, case, pats) -> 1 + size_of_term case + List.length pats
| BottomElim -> 1
- | TLambda t -> size_of_term t
+ | TLambda (_,t) -> size_of_term t
| Inst t -> size_of_term t
| Skip t -> size_of_term t
| UnsafeCoerce t -> 1 + size_of_term t
| NCic.LetIn _
| NCic.Lambda _
| NCic.Const (NReference.Ref (_,NReference.CoFix _))
- | NCic.Appl [] -> assert false (* NOT POSSIBLE *)
+ | NCic.Appl [] ->
+ assert false (* NOT POSSIBLE *)
| NCic.Match _
| NCic.Const (NReference.Ref (_,NReference.Fix _)) ->
(* be aware: we can be the head of an application *)
;;
-let context_of_typformer status ~metasenv context =
+let rev_context_of_typformer status ~metasenv context =
function
NCic.Const (NReference.Ref (_,NReference.Ind _) as ref)
| NCic.Const (NReference.Ref (_,NReference.Def _) as ref)
| NCic.Const (NReference.Ref (_,NReference.Decl) as ref)
| NCic.Const (NReference.Ref (_,NReference.Fix _) as ref) ->
- (try fst (ReferenceMap.find ref status#extraction_db)
+ (try List.rev (fst (ReferenceMap.find ref status#extraction_db))
with
- Not_found -> assert false (* IMPOSSIBLE *))
+ Not_found ->
+ (* This can happen only when we are processing the type of
+ the constructor of a small singleton type. In this case
+ we are not interested in all the type, but only in its
+ backbone. That is why we can safely return the dummy context here *)
+ let rec dummy = None::dummy in
+ dummy)
| NCic.Match _ -> assert false (* TODO ???? *)
| NCic.Rel n ->
let typ =
| _,NCic.Def _ -> assert false (* IMPOSSIBLE *) in
let typ_ctx = snd (HExtlib.split_nth n context) in
let typ = kind_of status ~metasenv typ_ctx typ in
- fst (split_kind_prods [] typ)
+ List.rev (fst (split_kind_prods [] typ))
| NCic.Meta _ -> assert false (* TODO *)
| NCic.Const (NReference.Ref (_,NReference.Con _))
| NCic.Const (NReference.Ref (_,NReference.CoFix _))
| NCic.Rel n -> Var n
| NCic.Const ref -> TConst ref
| NCic.Appl (he::args) ->
- let he_context = context_of_typformer status ~metasenv context he in
+ let rev_he_context= rev_context_of_typformer status ~metasenv context he in
TAppl (typ_of status ~metasenv context he ::
List.map
(function None -> Unit | Some ty -> typ_of status ~metasenv context ty)
- (skip_args status ~metasenv context (List.rev he_context,args)))
+ (skip_args status ~metasenv context (rev_he_context,args)))
| NCic.Appl _ -> assert false (* TODO: when head is a match/let rec;
otherwise NOT A TYPE *)
| NCic.Meta _
(* CSC: non-invariant assumed here about "_" *)
(match classify status ~metasenv context ty with
| `Kind ->
- TLambda (term_of status ~metasenv ((b,NCic.Decl ty)::context) bo)
+ TLambda (b,term_of status ~metasenv ((b,NCic.Decl ty)::context) bo)
| `KindOrType (* ??? *)
| `Type ->
Lambda (b, term_of status ~metasenv ((b,NCic.Decl ty)::context) bo)
| NCic.Appl (he::args) ->
eat_args status metasenv
(term_of status ~metasenv context he) context
+ (*BUG: recomputing every time the type of the head*)
(typ_of status ~metasenv context
(NCicTypeChecker.typeof status ~metasenv ~subst:[] context he))
args
-(*
- let he_context = context_of_typformer status ~metasenv context he in
- let process_args he =
- function
- `Empty -> he
- | `Inst tl -> Inst (process_args he tl)
- | `Appl (arg,tl) -> process_args (Appl (he,... arg)) tl
- in
- Appl (typ_of status ~metasenv context he ::
- process_args (typ_of status ~metasenv context he)
- (skip_term_args status ~metasenv context (List.rev he_context,args))
-*)
| NCic.Appl _ -> assert false (* TODO: when head is a match/let rec;
otherwise NOT A TYPE *)
| NCic.Meta _ -> assert false (* TODO *)
in
let rec eat_branch n ty context ctx pat =
match (ty, pat) with
- | NCic.Prod (_, _, t), _ when n > 0 ->
+ | TSkip t,_
+ | Forall (_,_,t),_
+ | Arrow (_, t), _ when n > 0 ->
eat_branch (pred n) t context ctx pat
- | NCic.Prod (_, _, t), NCic.Lambda (name, ty, t') ->
+ | _, _ when n > 0 -> assert false (*BUG: is Top possible here?*)
+ (*CSC: unify the three cases below? *)
+ | Arrow (_, t), NCic.Lambda (name, ty, t') ->
+ let ctx =
+ (Some (name,`OfType (typ_of status ~metasenv context ty)))::ctx in
+ let context = (name,NCic.Decl ty)::context in
+ eat_branch 0 t context ctx t'
+ | Forall (_,_,t),NCic.Lambda (name, ty, t') ->
let ctx =
- (*BUG: we should classify according to the constructor type*)
- (Some (name,`OfType (*(typ_of status ~metasenv context ty)*)Unit))::ctx in
+ (Some (name,`OfKind (kind_of status ~metasenv context ty)))::ctx in
let context = (name,NCic.Decl ty)::context in
eat_branch 0 t context ctx t'
+ | TSkip t,NCic.Lambda (name, ty, t') ->
+ let ctx = None::ctx in
+ let context = (name,NCic.Decl ty)::context in
+ eat_branch 0 t context ctx t'
+ | Top,_ -> assert false (*TODO: HOW??*)
(*BUG here, eta-expand!*)
| _, _ -> context,ctx, pat
in
try
List.map2
(fun (_, name, ty) pat ->
+ (*BUG: recomputing every time the type of the constructor*)
+ let ty = typ_of status ~metasenv context ty in
let context,lhs,rhs = eat_branch leftno ty context [] pat in
let rhs =
(* UnsafeCoerce not always required *)
function
[] -> acc
| arg::tl ->
- let mk_appl f x =
- match f with
- Appl args -> Appl (args@[x])
- | _ -> Appl [f;x]
- in
match fomega_whd status tyhe with
Arrow (s,t) ->
let arg =
| _ -> term_of status ~metasenv context arg in
eat_args status metasenv (mk_appl acc arg) context t tl
| Forall (_,_,t) ->
- eat_args status metasenv (Inst acc)
- context (fomega_subst 1 (typ_of status ~metasenv context arg) t) tl
+ (match classify status ~metasenv context arg with
+ | `PropKind -> assert false (*TODO: same as below, coercion needed???*)
+ | `Proposition
+ | `Term `TypeFormer
+ | `Kind ->
+ eat_args status metasenv (UnsafeCoerce (Inst acc))
+ context (fomega_subst 1 Unit t) tl
+ | `Term _ -> assert false (*TODO: ????*)
+ | `KindOrType
+ | `Type ->
+ eat_args status metasenv (Inst acc)
+ context (fomega_subst 1 (typ_of status ~metasenv context arg) t)
+ tl)
| TSkip t ->
eat_args status metasenv acc context t tl
| Top -> assert false (*TODO: HOW??*)
| TAppl tl -> String.concat " " (List.map (pretty_print_type status ctxt) tl)
let pretty_print_term_context status ctx1 ctx2 =
- let name_context, res =
+ let name_context, rev_res =
List.fold_right
- (fun el (ctx1,res) ->
+ (fun el (ctx1,rev_res) ->
match el with
- None -> ""@::ctx1,res
- | Some (name,`OfKind _) -> name@::ctx1,res
+ None -> ""@::ctx1,rev_res
+ | Some (name,`OfKind _) -> name@::ctx1,rev_res
| Some (name,`OfType typ) ->
let name,ctx1 = name@:::ctx1 in
name::ctx1,
- ("(" ^ name ^ " :: " ^ pretty_print_type status ctx1 typ ^ ")")::res
+ ("(" ^ name ^ " :: " ^ pretty_print_type status ctx1 typ ^ ")")::rev_res
) ctx2 (ctx1,[]) in
- name_context, String.concat " " res
+ name_context, String.concat " " (List.rev rev_res)
let rec pretty_print_term status ctxt =
function
in
" " ^ name ^ " " ^ bound_names ^ " -> " ^ body
) pl)
- | Skip t
- | TLambda t -> pretty_print_term status (""@::ctxt) t
+ | Skip t -> pretty_print_term status ("[[skipped]]"@::ctxt) t
+ | TLambda (name,t) ->
+ let name = capitalize `TypeVariable name in
+ pretty_print_term status (name@::ctxt) t
| Inst t -> pretty_print_term status ctxt t
;;
projects / helm.git / blobdiff