anchor.diff:    (* 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 *) 
  -  | Rec of term * list<t> (* Thunk of a rec. function def. *)
  +  | Rec of letbinding * list<t> (* Thunk of a rec. function def. *)
   //IN F*: and t : Type0 =
   and t = //JUST FSHARP
     | Lam of (t -> t)
  
positive.code:       (match ts with 
         | [] -> head
         | _ -> U.mk_app head args)
      | Accu (Rec (f, bs), ts) -> 
         (match (SS.compress f).n with
          | Tm_abs (args, _, _) -> 
              if (List.length ts = List.length args &&
                  List.fold_right (fun x y -> x && y) (List.map is_not_accu ts) true)
              then readback (iapp (translate ((Accu (Rec (f, bs), []))::bs) f) ts)
              else failwith "TODO: reading back a partially applied recursive function not yet implemented"
                            (* Danel: we need to store more information in the Rec thunks, such as 
                                      the name of the let binder, so as to be able to define this 
                                      case as the following FStar term (pretty printed):
  
                                      let g = readback (translate bs e) in 
                                      g ts_1 ... ts_n
  
                             *)
          | _ -> failwith "Recursive definition not a function")
      | _ -> failwith "Not yet implemented"
      
  
negative.code:       translate (def::bs) body
  
      | Tm_let((true, [lb]), body) -> // recursive let with only one recursive definition
        let f = Accu (Rec (lb, bs), []) in
        translate (f::bs) body
  
        // this will loop infinitely when the recursive argument is symbolic 
  