anchor.diff:    | Construct of fv * list<universe> * list<(t * aqual)> (* Zoe: This is used for both type and data constructors*)
     | Unit
     | Bool of bool
  +  | Univ of universe
   
   type head = t
   type annot = option<t>
  
positive.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 env ((mkAccuRec lb bs) :: bs) lb.lbdef) 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? *)
  
negative.code:     | _ ->
          mkAccuTyp u
  
  let is_univ (tm : t)=
    match tm with 
    | Univ _ -> true
    | _ -> false
  
  (* We are not targeting tagless normalization at this point *)
  let rec app (f:t) (x:t) (q:aqual) =
    debug (fun () -> BU.print2 "When creating app: %s applied to %s\n" (t_to_string f) (t_to_string x));
    match f with
    | Lam (f, _) -> f x
    | Accu (a, ts) -> Accu (a, (x,q)::ts)
    | Construct (i, us, ts) ->
      (match x with 
       | Univ u -> Construct (i, u::us, ts) 
       | _ -> Construct (i, us, (x,q)::ts))
    | Unit | Bool _ | Univ _ -> failwith "Ill-typed application"
  
  and iapp (f:t) (args:list<(t * aqual)>) =
    match args with
  