anchor.diff:      in
   
       ({ mlift_wp = sub.lift_wp |> must |> mk_mlift_wp;
  -       mlift_term = BU.map_opt sub.lift mk_mlift_term })
  +       //AR: this is funky
  +       //it is saying, if you don't give us a lift term (a function that lifts terms),
  +       //we are assuming that the function is an identity
  +       //so for example, primitive effects just specify lift wps, and not terms
  +       //for them we assume that the terms are identity functions
  +       //why do we need it?
  +       //suppose programmer writes a layered effect M and defines a lift from DIV to M
  +       //now a PURE computation in the VC gets lifted via: PURE ~> DIV ~> M
  +       //when extracting (and reifying the monadic lifts), we go the same route
  +       //but if there is no lift term from PURE ~> DIV, we get an error
  +       //is this ok to do for DM4F? not sure in general
  +       //but currently PURE and DIV are lifted to DM4F effects using M.return
  +       //and not using the lift term (I don't think the lift term is even supported for DM4F, is it?)
  +       mlift_term =
  +         match sub.lift with
  +         | None -> Some (fun _ _ e -> return_all e)
  +         | Some ts -> Some (mk_mlift_term ts) })
   
   let get_field_projector_name env datacon index =
     let _, t = Env.lookup_datacon env datacon in
  
positive.code: 
    then
      ({ mlift_wp = lift_tf_layered_effect sub.target (sub.lift_wp |> must);
         mlift_term = Some (lift_tf_layered_effect_term (sub.lift |> must) (sub.lift_wp |> must)) })
  
    else
      let mk_mlift_wp ts env c =
  
negative.code:  * Quite simple, just apply the lift term, passing units for the
   * binders that are meant to compute indices
   *)
  let lift_tf_layered_effect_term env (sub:sub_eff)
    (u:universe) (a:typ) (e:term) : term =
  
    let lift = sub.lift |> must |> (fun ts -> inst_tscheme_with ts [u]) |> snd in
  
    let rest_bs =
      let lift_t = sub.lift_wp |> must in
      match (lift_t |> snd |> SS.compress).n with
      | Tm_arrow (_::bs, _) when List.length bs >= 1 ->
        bs |> List.splitAt (List.length bs - 1) |> fst
  