anchor.diff:              )
   
     | Typ_fun (bs, codomain) -> 
  -        let (bts, newC) = extractBindersTypes c bs in
  -        (let codomainML = (extractComp  newC codomain) in 
  +        let bts = extractBindersTypes c bs in
  +        (let codomainML = (extractComp  c codomain) in 
           if  (codomainML = erasedContent) 
           then erasedContent 
           else  (curry bts codomainML))
  
positive.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 = {
      tyVars : list<ident>;
      tyConstants : list<lident>;
      allowTypeVars : bool
  }
  
  let emptyContext : context = {tyVars=[]; tyConstants =[]; allowTypeVars=true}
  
  (* 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:context) (tyVars : list<ident>) (tyConsts : list<lident>) (alowTypeVars_ : bool ): context = 
      { tyVars = List.append c.tyVars tyVars; tyConstants = List.append c.tyConstants tyConsts; allowTypeVars = alowTypeVars_}
  
  let disallowTypeVars (c:context) : context = extendContext c [] [] false
  
  let contains (c:context) (b:btvar) : bool =     
      List.contains ( b.v.realname.idText)  (List.map (fun x -> x.idText) c.tyVars) (*needed for sh, its ppname is _, and range is 0*)
      || List.contains (b.v.realname.idRange)  (List.map (fun x -> x.idRange) c.tyVars) (*needed for inductive constructors. names often have extra things appended*)
  
  let deltaUnfold (i : lident) (c: context) : (option<typ>) = None (*FIX!!*)
  
  
negative.code: | Inl ty -> extractTyp c ty
  | Inr _ -> erasedContent 
  
  and extractBinderType  (c:context) (bn : binder): mlty =
  match bn with
  | (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) 
  