anchor.diff:        case (translate env bs scrut)
   
       | Tm_let((false, [lb]), body) -> // non-recursive let
  -      let def = translate env bs lb.lbdef in
  +      let def = translate_letbinding env bs lb in
         translate env (def::bs) body
   
       | Tm_let((true, [lb]), body) -> // recursive let with only one recursive definition
         let f = mkAccuRec lb bs in
         translate env (f::bs) body (* Danel: storing the rec. def. as F* code wrapped in a thunk *)
  -
  -      // this will loop infinitely when the recursive argument is symbolic
  -      // let def = lb.lbdef in
  -      // let fnorm f = translate (f::bs) def in
  -      // let rec f = fnorm f in
  -      // translate (f::bs) body
  -      //failwith "Not yet implemented"
  -
   
   (* [readback] creates named binders and not De Bruijn *)
   and readback (env:Env.env) (x:t) : term =
  
positive.code:   | Construct of fv * list<universe> * list<(t * aqual)> (* Zoe: This is used for both type and data constructors*)
    | Unit
    | Bool of bool
  
  type head = t
  type annot = option<t>
  
negative.code:    | None ->
         mkConstruct fvar us [] (* Zoe : Z and S dataconstructors from the examples are not in the environment *)
  
  (* translate a let-binding - local or global *)
  and translate_letbinding (env:Env.env) (bs:list<t>) (lb:letbinding) : t =
    let rec make_univ_abst (us:list<univ_name>) (bs:list<t>) (def:term) : t = 
      match us with
      | [] -> translate env bs def 
      | u :: us' -> Lam ((fun u -> make_univ_abst us' (u :: bs) def), None) // Zoe: Leaving univers binder qualifier none for now
    in
    make_univ_abst lb.lbunivs bs lb.lbdef
    
  and translate (env:Env.env) (bs:list<t>) (e:term) : t =
      debug (fun () -> BU.print2 "Term: %s - %s\n" (P.tag_of_term (SS.compress e)) (P.term_to_string (SS.compress e)));
      debug (fun () -> BU.print1 "BS list: %s\n" (String.concat ";; " (List.map (fun x -> t_to_string x) bs)));
  