anchor.diff:  type inductiveConstructor = {
     cname: lident;
     ctype : typ;
  -  cargs : binders (*will this list always be empty? it has always been empty: tested nat, list, vec*)
  +  cargs : binders (*will this list always be empty? it has always been empty so far*)
   }
   type inductiveTypeFam = {
     tyName: lident;
  
positive.code: let convRange (r:Range.range) : int = 0 (*FIX!!*)
  let convIdent (id:ident) : mlident = (id.idText ,(convRange id.idRange))
      
  (* This is all the context is needed for extracting F* types to OCaml.
     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_left 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
  
  
negative.code: 
  | Sig_bundle _ -> 
      let ind = parseFirstInductiveType s in
      //let k = lookup_typ_lid c ind.tyName in
      let identsPP = List.map binderPPnames ind.tyBinders in
      let newContext = (extendContext c ind.tyBinders) in
      let nIndices = numIndices ind.k.n ind.tyName.ident.idText in
  