module ToScott =
struct
+let delta = let open Pure in L(A(V 0, V 0))
+
+let bomb = ref(`Var(-1, -666));;
+
let rec t_of_i_num_var =
function
| `N n -> Scott.mk_n n
- | `Var(v,_) -> Pure.V v
+ | `Var(v,_) as x -> assert (x <> !bomb); Pure.V v
| `Match(t,_,liftno,bs,args) ->
- let bs = List.map (fun (n,t) -> n, t_of_nf (lift liftno t)) !bs in
+ let bs = List.map (
+ function (n,t) -> n,
+ (if t = !bomb then delta
+ else L (t_of_nf (lift (liftno+1) t)))
+ ) !bs in
let t = t_of_i_num_var t in
let m = Scott.mk_match t bs in
+ let m = Pure.A(m,delta) in
List.fold_left (fun acc t -> Pure.A(acc,t_of_nf t)) m args
| `I((v,_), args) -> Listx.fold_left (fun acc t -> Pure.A(acc,t_of_nf t)) (Pure.V v) args
and t_of_nf =
let boundvar x = "v" ^ string_of_int x in
let varname lev l n =
if n < lev then boundvar (lev-n-1)
- else if n < List.length l then List.nth l (n-lev)
+ else if n - lev < List.length l then List.nth l (n-lev)
else "`" ^ string_of_int (n-lev) in
let rec string_of_term_w_pars lev l = function
| `Var(n,ar) -> varname lev l n ^ (if debug_display_arities then ":" ^ string_of_int ar else "")
| `Lam _ as t -> "(" ^ string_of_term_no_pars_lam lev l t ^ ")"
| `Match(t,(v,ar),bs_lift,bs,args) ->
(* assert (bs_lift = lev); *)
- "["^ varname lev l v ^ (if debug_display_arities then ":"^ string_of_int ar else "") ^",match " ^ string_of_term_no_pars lev l (t :> nf) ^
+ "(["^ varname 0 l v ^ (if debug_display_arities then ":"^ string_of_int ar else "") ^",match " ^ string_of_term_no_pars lev l (t :> nf) ^
" with " ^ String.concat " | " (List.map (fun (n,t) -> string_of_int n ^ " => " ^ string_of_term l (t :> nf)) !bs) ^ "] " ^
String.concat " " (List.map (string_of_term l) (args :> nf list)) ^ ")"
and string_of_term_no_pars_app lev l = function
| `N _ as x -> x
| `Match(t,v,bs_lift,bs,args) ->
let bs_lift = bs_lift + if delift_by_one then -1 else 0 in
+ (* Warning! It now applies again the substitution in branches of matches.
+ But careful, it does it many times, for every occurrence of
+ the match. This is okay because what does not occur in with_what. *)
let l' = l - bs_lift in
- let with_what' = lift l' with_what in
+ let with_what' = lift l' (with_what :> nf) in
(* The following line should be the identity when delift_by_one = true because we
are assuming the ts to not contain lambda-bound variables. *)
bs := List.map (fun (n,t) -> n,subst truelam false what with_what' t) !bs ;
- mk_match (cast_to_i_num_var (aux_i_num_var l t)) v bs_lift bs (List.map (aux l) args)
+ let body = cast_to_i_num_var (aux_i_num_var l t) in
+ mk_match body v bs_lift bs (List.map (aux l) (args :> nf list))
and aux l(*lift*) =
(*function iii -> let res = match iii with*)
function