Minor doc and code review

Author: d-plaindoux

README.md

@@ -200,10 +200,11 @@ optimisations cf. [celma parser in direct style](https://github.com/d-plaindoux/
 
 This version target an aggressive and an efficient parser compilation. For this
 purpose the compilation follows a traditional control and data flow mainly inspired 
-by the paper [A Typed, Algebraic Approach to Parsing](https://www.cl.cam.ac.uk/~jdy22/papers/a-typed-algebraic-approach-to-parsing.pdf). 
+by the papers like [A Typed, Algebraic Approach to Parsing](https://www.cl.cam.ac.uk/~jdy22/papers/a-typed-algebraic-approach-to-parsing.pdf) 
+and [Fusing Lexing and Parsing](https://www.cl.cam.ac.uk/~jdy22/papers/fusing-lexing-and-parsing.pdf).
 
 First, we express [Celma in Celma](https://github.com/d-plaindoux/celma/blob/master/lang/v1/parser/src/parser.rs).
-This gives us an AST denoting parsers expressed using the Celma language.
+This gives us an AST denoting parsers expressed using the Celma language i.e. Celma(v1) thanks to Celma(v0).
 
 ### Type checking
 

lang/v0/macro/Cargo.toml

@@ -8,8 +8,10 @@ edition = "2021"
 proc-macro = true
 
 [dependencies]
+syn = "2.0.98"
 celma_v0_core = { version = "0.1.0", path = "../core" }
 celma_v0_parser = { version = "0.1.0", path = "../parser" }
+proc-macro2 = "1.0.93"
 
 [dev-dependencies]
 bencher = "0.1.5"

lang/v0/macro/src/lib.rs

@@ -16,37 +16,38 @@
 
 extern crate proc_macro;
 
+use celma_v0_core::parser::response::Response;
 use celma_v0_core::parser::response::Response::{Reject, Success};
 use celma_v0_core::parser::specs::Parse;
 use celma_v0_core::stream::char_stream::CharStream;
 use celma_v0_core::stream::specs::Stream;
 use celma_v0_parser::parser::{celma_parsec, celma_parsec_rules};
 use celma_v0_parser::transpiler::Transpile;
-use proc_macro::TokenStream;
+use syn::Error;
 
 #[proc_macro]
-pub fn parsec(input: TokenStream) -> TokenStream {
+pub fn parsec(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let source = input.to_string();
     let result = celma_parsec()
         .parse(CharStream::new(source.as_str()))
         .map(|ast| ast.transpile());
 
-    match result {
-        Success(code, _, _) => match code {
-            Ok(code) => code.into(),
-            Err(err) => panic!("{}", err.into_compile_error()),
-        },
-        Reject(s, _) => panic!("Parse error at {:?}", s.position()),
-    }
+    conclude_parsing(result)
 }
 
 #[proc_macro]
-pub fn parsec_rules(input: TokenStream) -> TokenStream {
+pub fn parsec_rules(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let source = input.to_string();
     let result = celma_parsec_rules()
         .parse(CharStream::new(source.as_str()))
         .map(|ast| ast.transpile());
 
+    conclude_parsing(result)
+}
+
+fn conclude_parsing(
+    result: Response<Result<proc_macro2::TokenStream, Error>, CharStream<(usize, usize, usize)>>,
+) -> proc_macro::TokenStream {
     match result {
         Success(code, _, _) => match code {
             Ok(code) => code.into(),

lang/v0/parser/Cargo.toml

@@ -5,9 +5,8 @@ authors = ["dplaindoux <[email protected]>"]
 edition = "2021"
 
 [dependencies]
-celma_v0_core = { version = "0.1.0", path = "../core" }
-celma_v0_ast = { version = "0.1.0", path = "../ast" }
-celma_v1_ast = { version = "0.1.0", path = "../../v1/ast" }
 proc-macro2 = "1.0.93"
 quote = "1.0.38"
 syn = "2.0.96"
+celma_v0_core = { version = "0.1.0", path = "../core" }
+celma_v0_ast = { version = "0.1.0", path = "../ast" }