go

.gitignore

@@ -1,6 +1,3 @@
 *.cmo
 *.cmi
-*.cmx
-*.o
-*.out
-*.cma
+a.out

.ocamlinit

@@ -1,3 +0,0 @@
-#load "parser.cmo";;
-#load "periodic.cmo";;
-#load "main.cmo";;

Makefile

@@ -1,9 +0,0 @@
-common_files = parser.ml
-extensions = *.cmo *.cmi *.cma *.o *.out *.cmx *.a
-
-lib:
-	ocamlc -c $(common_files) 
-	ocamlc -a parser.cmo -o parser.cma
-
-clean:
-	rm -f $(extensions)

README.md

@@ -1,13 +0,0 @@
-# usagi - simple ocaml parser combinator library
-
-## compilation
-
-```bash
-$ make lib
-```
-
-generate `.cma` that can be linked with `ocamlc -I . parser.cma`
-
-## todo
-
-- [ ] error recovery

main.ml

@@ -1,16 +1,13 @@
 type input = 
   { content : string
-  ; line : int
-  ; offset : int
+  ; column : int
   }
 
-let make_input s = { content = s; line = 0; offset = 0 }
+let make_input s = { content = s; column = 0 }
 
 type error =
   { content : string
-  ; line : int 
-  ; offset : int
-  }
+  ; column : int }
 
 type 'a parser_result = (('a * input) list, error list) result
 
@@ -18,6 +15,8 @@ type 'a parser =
   { run : input -> 'a parser_result
   }
 
+let runParser i p = p.run i
+
 let fold_left1 (f: 'a -> 'a -> 'a) (xs: 'a list) : 'a = match xs with
   | []      -> failwith "TODO: make method total; empty list"
   | x :: xs -> List.fold_left f x xs 
@@ -29,18 +28,16 @@ let append (a: 'a parser_result) (b: 'a parser_result) : 'a parser_result =
   | (v, _)              -> v
 
 let fail (s: string) : 'a parser = 
-  { run = fun x -> Error [{content = s; line = x.line; offset = x.offset}] 
+  { run = fun x -> match x with
+          | {content = _; column = c} -> Error [{content = s; column = c}] 
   }
 
 let get : char parser = 
   { run = function
-          | { content = ""; line = l; offset = o } -> 
-            Error [{ content = "unexpected EOF"; line = l; offset = o }]
-          | { content = xs; line = l; offset = o } ->
-            let x = String.get xs 0 in
-            let xs' = String.sub xs 1 (String.length xs - 1) in
-            let (line', offset') = if x == '\n' then (l+1,0) else (l,o+1) in
-              Ok [(x, {content = xs'; line = line'; offset = offset'})]
+          | { content = ""; column = c } -> 
+            Error [{ content = "unexpected EOF"; column = c }]
+          | { content = xs; column = c } -> 
+            Ok [(String.get xs 0, { content = String.sub xs 1 (String.length xs - 1); column = c+1})]
   }
 
 let return (x: 'a) : 'a parser = 
@@ -96,16 +93,69 @@ let many1 (p: 'a parser): 'a list parser =
   let* xs = many p in
     x::xs |> return
 
-let rec manyTill (p: 'a parser) (q: 'b parser): 'a list parser =
-  (
-  let* x = p in 
-  let* xs = manyTill p q in
-    x::xs |> return
-  ) <++ (q >>= fun _ -> return [])
+type element = 
+  { symbol : string
+  ; count : int
+  }
+
+type molecule =
+  { elements : element list
+  }
+
+let unary_symbol_p : string parser =
+  let* x = upper in
+    String.make 1 x |> return
+
+let binary_symbol_p : string parser =
+  let* x = upper in
+  let* x' = lower in
+    String.make 1 x ^ String.make 1 x' |> return
+
+let symbol_p : string parser = binary_symbol_p <++ unary_symbol_p
+
+let element_count_p : int parser =
+  let* x = many1 digit in
+    List.to_seq x 
+    |> String.of_seq
+    |> int_of_string
+    |> return
+
+let element_p : element parser =
+  let* s = symbol_p in
+  let* n = element_count_p <++ return 1 in
+    { symbol = s
+    ; count = n
+    } |> return
+
+let manyTill1 (p: 'a parser) (q: 'b parser): 'a list parser =
+  let* xs = many1 p in
+  let* _  = q in
+    return xs
 
 let eof : unit parser =
   { run = fun inp -> 
       if inp.content = "" 
-      then Ok [(), inp] 
-      else Error[{content = "expected EOF"; line = inp.line; offset = inp.offset+1}]
+      then Ok [(), {content = ""; column = inp.column}] 
+      else Error [{content = "expected EOF"; column = inp.column+1}]
   }
+
+let molecule_p : molecule parser =
+  let* xs = manyTill1 element_p eof in
+    return { elements = xs }
+
+let parse_molecule s : (molecule, error list) result =
+  match make_input s |> molecule_p.run with
+  | Ok []         -> failwith "TODO: make method total; empty list" 
+  | Ok ((x,_)::_) -> Ok x
+  | Error xs      -> Error xs
+
+let print_molecule (s: molecule) : unit = 
+  List.iter (fun x -> Printf.printf "%s, %i\n" x.symbol x.count) s.elements
+
+let print_error (xs: error list) (s: string) : unit = 
+  List.iter (fun x -> Printf.printf "%s\n%*s\n%s\n" s x.column "^" x.content) xs 
+
+let molecule s : unit =
+  match parse_molecule s with
+  | Ok x     -> print_molecule x 
+  | Error xs -> print_error xs s