anchor.diff:  
   let mkAccuVar (v:var) = Accu(Var v, [])
   let mkAccuMatch (s : t) (c : t -> t) = Accu(Match (s, c), [])
  -let mkAccuRec (b:letbinding) (env:list<t>) = Accu(Rec(b, env), [])
  +let mkAccuRec (b:letbinding) (bs:list<letbinding>) (env:list<t>) = Accu(Rec(b, bs, env), [])
   
   let isAccu (trm:t) =
     match trm with
  
positive.code:   | Var of var
    | Match of t * (* the scutinee *)
               (t -> t) (* the closure that pattern matches the scrutiny *)
    | Rec of letbinding * list<t> (* Danel: This wraps a unary F* rec. def. as a thunk in F# *)
  //IN F*: and t : Type0 =
  and t = //JUST FSHARP
    | Lam of (t -> t) * aqual
  
negative.code:        let args_no = count_abstractions lb.lbdef in
         // Printf.printf "Args no. %d\n" args_no;
         if test_args ts args_no then (* if the arguments are not symbolic and the application is not partial compute *)
           readback env (curry (translate_letbinding env (make_rec_env lbs bs) lb) ts)
         else (* otherwise do not unfold *)
           let head =
             (* Zoe: I want the head to be [let rec f = lb in f]. Is this the right way to construct it? *)
  