anchor.diff:          | xs ->
               let (res, rest) = parseIdent [] xs
               in Sexp.Atom(res), rest
  +
       in match Seq.toList str |> parse' with
           | (res, []) -> res
           | (_, rest) -> raise <| UnexpectedItems ("Unexpected items",
  
positive.code: 
  exception UnexpectedItems of string * string
  exception UnexpectedChar of char
  
  let parse str =
      let rec parseList acc = function
  
negative.code:             | (')' :: xs) -> finish acc (')' :: xs)
              | [] -> finish acc []
              | (c :: xs) -> raise <| UnexpectedChar c
  
      and parseIdent acc =
          let finish acc xs = List.rev acc |> List.toArray |> System.String, xs
          in function
              | ('(' :: xs) -> finish acc <| '(' :: xs
              | (')' :: xs) -> finish acc <| ')' :: xs
              | ('"' :: xs) -> finish acc <| '"' :: xs
              | (c :: xs) when System.Char.IsWhiteSpace c ->
                  finish acc xs
              | [] -> finish acc []
              | (c :: xs) -> parseIdent (c :: acc) xs
  
      and parseString acc = function
          | ('"' :: xs) ->
              let res = acc |> List.rev |> List.toArray |> System.String
              in Sexp.Str res, xs
          | ('\\' :: '"' :: xs) -> parseString ('"' :: acc) xs
          | ('\\' :: 'n' :: xs) -> parseString ('\n' :: acc) xs
          | ('\\' :: 'r' :: xs) -> parseString ('\r' :: acc) xs
          | ('\\' :: 't' :: xs) -> parseString ('\t' :: acc) xs
          | ('\\' :: 'b' :: xs) -> parseString ('\b' :: acc) xs
          | (c :: xs) -> parseString (c :: acc) xs
          | [] -> raise UnclosedString
  
      and parse' = function
          | ('(' :: xs) ->
              let (res, rest) = parseList [] xs
              in (Sexp.List(res), rest)
          | ('"' :: xs) -> parseString [] xs
          | [] -> Sexp.List([]), []
          | (c :: xs) when System.Char.IsWhiteSpace c -> parse' xs
          | (c :: xs) when System.Char.IsDigit c -> parseNumber [] false (c :: xs)
  