anchor.diff:        translate (def::bs) body
   
       | Tm_let((true, [lb]), body) -> // recursive let with only one recursive definition
  +      let f = Rec (lb.lbdef, bs) in 
  +      translate (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"
  +      //failwith "Not yet implemented"
         
       | _ -> debug_term e; failwith "Not yet implemented"
   
  
positive.code:     branch :: mkBranches branches' cont
    | _ -> failwith "Unexpected pattern" 
  
  let rec translate (bs:list<t>) (e:term) : t =
      match (SS.compress e).n with
      | Tm_delayed _ -> failwith "Impossible"
  
  
negative.code:   (* Zoe: I'm not sure how to use this in our setting since F*'s ast does not
       mark the recursive argument and therefore I'm not sure how to prevent 
       infinite fixpoint unrolling *) 
    | FiX of (t -> t) (* Danel: This is a unary rec. def. that will not be unfolded any more *)
  //IN F*: and t : Type0 =
  and t = //JUST FSHARP
    | Lam of (t -> t)
  