anchor.diff:  | Inl ty -> extractTyp c ty
   | Inr _ -> erasedContent 
   
  -(* Return the new context, where this binder might be in scope. Actually this code be reverted back to the old, less complicated state
  -   where c.allowTypeVars was always assumed to be false. *)
  -and extractBinderType  (c:context) (bn : binder): mlty * context =
  +and extractBinderType  (c:context) (bn : binder): mlty =
   match bn with
  -| (Inl btv,_) ->
  -      let k = (btv.sort) in 
  -      let newC = (match k.n with
  -                 | Kind_type -> (if c.allowTypeVars then (extendContext c [btv.v.realname] [] c.allowTypeVars) else c)
  -                 | _ ->  c)
  -       in  (extractKind (disallowTypeVars c) (btv.sort), newC)
  -| (Inr bvv,_) -> (extractTyp (disallowTypeVars c) (bvv.sort), c)
  -
  -and extractBindersTypes  (c:context) (bs : list<binder>): list<mlty> * context =
  -match bs with
  -| (h::tl) ->  let (t,newC) = extractBinderType c h in
  -               let (lt, newNewC) = extractBindersTypes newC tl in
  -               ((t::lt),newNewC)
  -| [] -> ([], c)
  -
  +| (Inl btv,_) -> (extractKind c (btv.sort))
  +| (Inr bvv,_) -> (extractTyp c (bvv.sort))
  +
  +and extractBindersTypes  (c:context) (bs : list<binder>): list<mlty> =
  +  List.map (extractBinderType c) bs
   and extractTyp  (c:context) (ft:typ) : mlty = extractType' c (ft.n)
   and extractKind (c:context) (ft:knd) : mlty = erasedContent
   and extractComp  (c:context) (ft:comp) : mlty = extractComp' c (ft.n) 
  
positive.code:             )
  
    | Typ_fun (bs, codomain) -> 
          let (bts, newC) = extractBindersTypes c bs in
          (let codomainML = (extractComp  newC codomain) in 
          if  (codomainML = erasedContent) 
          then erasedContent 
          else  (curry bts codomainML))
  
negative.code:    In particular, the definition of a type constant is not needed when translating references to it.
     However, enough info is needed to determine whether a type constant is a type scheme. add that.
  *)
  type context = env
  
  (* vars in tyVars will have type Type, irrespective of that types they had in F*. This is to match the limitations of  OCaml*)
  let extendContext (c:env) (tyVars : list<binder>) : env = 
    List.fold push_local_binding c (List.map binding_of_binder tyVars)
  
  
  let contains (c:context) (b:btvar) : bool = 
    try (let _ = (lookup_btvar c b) in true)
    with
     | _ -> false
  
  let deltaUnfold (i : lident) (c: context) : (option<typ>) = None (*FIX!!*)
  
  