anchor.diff:        S.mk (Tm_type u) None Range.dummyRange
   
       | Lam (f, t, q) ->
  -      let x = S.new_bv None (readback env t) in (* (readback env t) is the type of the binder *)
  +      let x = S.new_bv None (readback env (t ())) in (* (readback env t) is the type of the binder *)
         let body = readback env (f (mkAccuVar x)) in
         U.abs [(x, q)] body None
   
  
positive.code:              list<branch> 
               // ZP: Keep the original branches to reconstruct just the patterns
               // NS: add a thunked pattern translations here ZP: Not entirely sure that this is needed, trying something simpler first.
               
    | Rec of letbinding * list<letbinding> * list<t> (* Danel: This wraps a unary F* rec. def. as a thunk in F# *)
    (* Zoe : a recursive function definition together with its block of mutually recursive function definitions and its environment *)
  //IN F*: and t : Type0 =
  and t = //JUST FSHARP
    | Lam of (t -> t) * t * aqual //NS: * ((unit -> t) * (type : t) * aqual)
    | Accu of atom * args
    (* For simplicity represent constructors with fv as in F* *)
    | Construct of fv * list<universe> * args (* Zoe: This is used for both type and data constructors*)
  
negative.code:           | [] -> head
            | _ -> U.mk_app head args)
  
  let normalize (env : Env.env) (e:term) : term =
    //debug_sigmap env.sigtab;
    readback env (translate env [] e)
  