anchor.diff:    and lmk_setcompr(((((f,_),vs),_),b),_) =
        pmk_setcompr(f,pfrees vs [],b)
     and lmk_decimal ((_,l0),ropt) =
  -    let l,r = if ropt = [] then l0,"1" else
  +     let l,r = if ropt = [] then l0,"1" else
                 let r0 = hd ropt in
                 let n_l = num_of_string l0
  -              and n_r = num_of_string r0 in
  -              let n_d = power_num (Int 10) (Int (String.length r0)) in
  -              let n_n = n_l */ n_d +/ n_r in
  -              string_of_num n_n,string_of_num n_d in
  +              let n_r = num_of_string r0
  +              let n_d = power_num (Int 10) (Int (String.length r0))
  +              let n_n = n_l */ n_d +/ n_r
  +              string_of_num n_n,string_of_num n_d
        Combp(Combp(Varp("DECIMAL",dpty),Varp(l,dpty)),Varp(r,dpty))
     and lmk_univ((_,pty),_) =
       Typing(Varp("UNIV",dpty),Ptycon("fun",[pty;Ptycon("bool",[])]))
  
positive.code:    ((possibly (a (Resword "|")) ++
       listof clause (a (Resword "|")) "pattern-match clause" >> snd)
      >> end_itlist (fun s t -> Combp(Combp(Varp("_SEQPATTERN",dpty),s),t))) i in
    (fun inp ->
      match inp with
        [Ident s] -> Varp(s,dpty),[]
      | _ -> preterm inp);;
  
  (* ------------------------------------------------------------------------- *)
  (* Type and term parsers.                                                    *)
  (* ------------------------------------------------------------------------- *)
  
  let parse_type s =
    let pty,l = (parse_pretype o lex o explode) s in
    if l = [] then type_of_pretype pty
    else failwith "Unparsed input following type";;
  
  let parse_term s =
    let ptm,l = (parse_preterm o lex o explode) s in
    if l = [] then
     (term_of_preterm o (retypecheck [])) ptm
    else failwith "Unparsed input following term";;
  
  *)
  
  
negative.code: (* the longest string of symbolics.                                          *)
  (* ------------------------------------------------------------------------- *)
  
  reserve_words ["//"]
  
  let comment_token = ref (Resword "//")
  
  let lex =
    let collect (h,t) = end_itlist (^) (h::t)
    let reserve = function
      | (Ident n as tok) ->
          if is_reserved_word n then Resword(n) else tok
      | t -> t
    let stringof p = atleast 1 p >> end_itlist (^) in
    let simple_ident = stringof(some isalnum) || stringof(some issymb) in
    let undertail = stringof (a "_") ++ possibly simple_ident >> collect in
  