anchor.diff:  
   let install_parser,delete_parser,installed_parsers,try_user_parser =
     let rec try_parsers ps i =
  -    if ps = [] then raise Noparse else
  -    try snd(hd ps) i with Noparse -> try_parsers (tl ps) i in
  +    if ps = [] then raise Noparse
  +    else
  +        try snd(hd ps) i
  +        with Noparse -> try_parsers (tl ps) i
     let parser_list =
       ref([]:(string*(lexcode list -> preterm * lexcode list))list) in
     (fun dat -> parser_list := dat::(!parser_list)),
  
positive.code: (* ------------------------------------------------------------------------- *)
  
  let parse_pretype =
    let btyop n n' x y = Ptycon(n,[x;y])
    and mk_apptype =
      function
          ([s],[]) -> s
        | (tys,[c]) -> Ptycon(c,tys)
        | _ -> failwith "Bad type construction"
    and type_atom input =
      match input with
        (Ident s)::rest ->
            (try pretype_of_type(assoc s (type_abbrevs())) with Failure _ ->
             if try get_type_arity s = 0 with Failure _ -> false
             then Ptycon(s,[]) else Utv(s)),rest
      | _ -> raise Noparse
    and type_constructor input =
      match input with
        (Ident s)::rest -> if try get_type_arity s > 0 with Failure _ -> false
                           then s,rest else raise Noparse
      | _ -> raise Noparse in
    let rec pretype i = rightbin sumtype (a (Resword "->")) (btyop "fun") "type" i
    and sumtype i = rightbin prodtype (a (Ident "+")) (btyop "sum") "type" i
    and prodtype i = rightbin carttype (a (Ident "#")) (btyop "prod") "type" i
    and carttype i = leftbin apptype (a (Ident "^")) (btyop "cart") "type" i
    and apptype i = (atomictypes ++ (type_constructor >> (fun x -> [x])
                                  || nothing) >> mk_apptype) i
    and atomictypes i =
          (((a (Resword "(")) ++ typelist ++ a (Resword ")") >> (snd o fst))
        || type_atom >> (fun x -> [x])) i
    and typelist i = listof pretype (a (Ident ",")) "type" i in
    pretype;;
  
  (* ------------------------------------------------------------------------- *)
  (* Hook to allow installation of user parsers.                               *)
  
negative.code:          String.make 1 (Char.chr(int_of_string(a^b^c))),rst
      | _ -> failwith "lex:unrecognized OCaml-style escape in string" in
    let stringchar =
        some (fun i -> i <> "\\" && i <> "\"")
        || (a "\\" ++ escapecode >> snd) in
    let string = a "\"" ++ many stringchar ++ a "\"" >> (fun ((_,s),_) -> "\""^implode s^"\"")
    let rawtoken = (string || some isbra || septok || ident) >> (fun x -> Ident x)
    let simptoken = many (some isspace) ++ rawtoken >> (reserve << snd)
    let rec tokens i =
      try let (t,rst) = simptoken i in
          if t = !comment_token then
            (many (fun i -> if i <> [] && hd i <> "\n" then 1,tl i
                            else raise Noparse) ++ tokens >> snd) rst
          else
            let toks,rst1 = tokens rst in t::toks,rst1
      with Noparse -> [],i in
    fst << (tokens ++ many (some isspace) ++ finished >> (fst << fst))
  
  (* ------------------------------------------------------------------------- *)
  (* Parser for pretypes. Concrete syntax:                                     *)
  