Add types and review readme

Author: d-plaindoux

README.md

@@ -190,45 +190,52 @@ the Rust compilation stage.
 
 ### V0
 
-In the V0 the compilation is a direct style Parsec generation without any
-optimisations.
+In the V0 the transpilation is a direct style Parsec generation without any
+optimisations. 
 
-#### Abstract syntax tree
+### V1
+
+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)
+
+#### Celma lang in Celma lang
 
 ```rust
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum ASTParsec {
-    PIdent(String),
-    PChar(char),
-    PString(String),
-    PBind(String, Box<ASTParsec>),
-    PMap(Box<ASTParsec>, String),
-    PSequence(Box<ASTParsec>, Box<ASTParsec>),
-    PChoice(Box<ASTParsec>, Box<ASTParsec>),
-    PNot(Box<ASTParsec>),
-    PTry(Box<ASTParsec>),
-    PCheck(Box<ASTParsec>),
-    POptional(Box<ASTParsec>),
-    PRepeat(bool, Box<ASTParsec>),
-    PLookahead(Box<ASTParsec>),
-}
+let skip:{()} = (' '|'\t'|'\n'|'\r')* -> {}
+let ident:{String} = (skip i=#(alpha (alpha|digit|'_')*) skip) -> { i.into_iter().collect() }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ASTParsecRule {
-    pub name: String,
-    pub input: String,
-    pub returns: String,
-    pub rule: Box<ASTParsec>,
-}
-```
+let kind:{String} = (skip '{' v=^'}'* '}' skip) -> { v.into_iter().collect() }
+let code:{String} = (skip '{' c=^'}'* '}' skip) -> { c.into_iter().collect() }
 
-### V1
+let rules:{Vec<ASTParsecRule<char>>} = rule*
+let rule:{ASTParsecRule<char>} = (
+    skip p="pub"? skip "let" skip n=ident i=kind? r=(':' _=kind)? '=' b=parsec skip
+) -> { mk_rule(p.is_some(), n, i, r, b) }
 
-This version target an aggressive and an efficient parser compilation. For this
-purpose the compilation follows a traditional control ans data flow and was
-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)
+let parsec:{ASTParsec<char>} = (
+    skip b=!(binding)? a=atom o=('?'|'*'|'+')? d=additional? t=transform? skip
+) -> { mk_ast_parsec(b, a, o, d, t) }
+
+let binding:{String} = skip _=ident '=' skip
+let additional:{(bool,ASTParsec<char>)} = (skip c='|'? skip p=parsec) -> { (c.is_some(), p) }
 
+let atom:{ASTParsec<char>} = (
+    skip o=('^'|'!'|'#'|'/')? skip p=(atom_block|atom_ident|atom_char|atom_string|atom_code) skip
+) -> { mk_atom(o, p) }
 
+let atom_block:{ASTParsec<char>} = '(' _=parsec ')'
+let atom_ident:{ASTParsec<char>} = c=ident -> { PIdent(c) }
+let atom_char:{ASTParsec<char>} = c=delimited_char -> { PAtom(c) }
+let atom_string:{ASTParsec<char>} = c=delimited_string -> { PAtoms(c.chars().collect()) }
+let atom_code:{ASTParsec<char>} = c=code -> { PCode(c) }
+
+let transform:{String} = (skip "->" skip _=code)
+
+// Main entries
+let celma_parsec:{ASTParsec<char>} = (_=parsec eos)
+let celma_parsec_rules:{Vec<ASTParsecRule<char>>} = (_=rules eos)
+```
 
 # License
 

lang/v0/ast/src/syntax.rs

@@ -17,11 +17,9 @@
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ASTParsec {
     PIdent(String),
-    // Are these constructors required?
     PAtom(char),
     PAtoms(Vec<char>),
     PBind(String, Box<ASTParsec>),
-    // --------------------------------
     PCode(String),
     PMap(Box<ASTParsec>, String),
     PSequence(Box<ASTParsec>, Box<ASTParsec>),

lang/v1/ast/src/syntax.rs

@@ -14,14 +14,29 @@
  * limitations under the License.
  */
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ASTParsecRule<I> {
+    pub public: bool,
+    pub name: String,
+    pub input: ASTType,
+    pub returns: ASTType,
+    pub rule: ASTParsec<I>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ASTType {
+    PUnit,
+    PChar,
+    PString,
+    POther(String),
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ASTParsec<I> {
     PIdent(String),
-    // Are these constructors required?
     PAtom(I),
     PAtoms(Vec<I>),
     PBind(String, Box<ASTParsec<I>>),
-    // --------------------------------
     PCode(String),
     PMap(Box<ASTParsec<I>>, String),
     PSequence(Box<ASTParsec<I>>, Box<ASTParsec<I>>),
@@ -34,19 +49,8 @@ pub enum ASTParsec<I> {
     PLookahead(Box<ASTParsec<I>>),
 }
 
-
-
 impl<I> ASTParsec<I> {
     pub fn wrap(self) -> Box<Self> {
         Box::new(self)
     }
 }
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ASTParsecRule<I> {
-    pub public: bool,
-    pub name: String,
-    pub input: String,
-    pub returns: String,
-    pub rule: ASTParsec<I>,
-}

lang/v1/parser/src/parser.rs

@@ -17,27 +17,28 @@
 use celma_v0_core::parser::core::eos;
 use celma_v0_core::parser::literal::{delimited_char, delimited_string};
 
+use celma_v0_macro::parsec_rules;
 use celma_v1_ast::syntax::ASTParsec::{
     PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PIdent, PLookahead, PMap, PNot, POptional,
     PRepeat, PSequence, PTry,
 };
 use celma_v1_ast::syntax::{ASTParsec, ASTParsecRule};
-use celma_v0_macro::parsec_rules;
 
 use celma_v0_core::parser::char::{alpha, digit};
+use celma_v1_ast::syntax::ASTType::{PChar, POther, PUnit};
 
 fn mk_rule(
     public: bool,
     name: String,
     input: Option<String>,
-    returns: String,
+    returns: Option<String>,
     body: ASTParsec<char>,
 ) -> ASTParsecRule<char> {
     ASTParsecRule {
         public,
         name,
-        input: input.unwrap_or(String::from("char")),
-        returns,
+        input: input.map_or_else(|| PChar, POther),
+        returns: returns.map_or_else(|| PUnit, POther),
         rule: body,
     }
 }
@@ -98,7 +99,7 @@ parsec_rules!(
 
     let rules:{Vec<ASTParsecRule<char>>} = rule*
     let rule:{ASTParsecRule<char>} = (
-        skip p="pub"? skip "let" skip n=ident i=kind? ':' r=kind '=' b=parsec skip
+        skip p="pub"? skip "let" skip n=ident i=kind? r=(':' _=kind)? '=' b=parsec skip
     ) -> { mk_rule(p.is_some(), n, i, r, b) }
 
     let parsec:{ASTParsec<char>} = (

lang/v1/parser/tests/parser_tests.rs

@@ -18,11 +18,13 @@
 mod parser_tests {
     use celma_v0_core::parser::specs::Parse;
     use celma_v0_core::stream::char_stream::CharStream;
-    use celma_v1_ast::syntax::ASTParsec::{PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PIdent, PLookahead, PNot, POptional, PSequence, PTry};
-    use celma_v1_ast::syntax::ASTParsecRule;
-    use celma_v1::parser::{
-        atom_char, atom_code, atom_ident, atom_string, kind, parsec, rule,
+    use celma_v1::parser::{atom_char, atom_code, atom_ident, atom_string, kind, parsec, rule};
+    use celma_v1_ast::syntax::ASTParsec::{
+        PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PIdent, PLookahead, PNot, POptional,
+        PSequence, PTry,
     };
+    use celma_v1_ast::syntax::ASTParsecRule;
+    use celma_v1_ast::syntax::ASTType::{PChar, PUnit};
 
     #[test]
     fn should_parse_kind() {
@@ -187,9 +189,9 @@ mod parser_tests {
             response.fold(
                 |v, _, _| v
                     == PBind(
-                    String::from("a"),
-                    PTry(PIdent(String::from("entry")).wrap()).wrap()
-                ),
+                        String::from("a"),
+                        PTry(PIdent(String::from("entry")).wrap()).wrap()
+                    ),
                 |_, _| false
             ),
             true
@@ -204,9 +206,9 @@ mod parser_tests {
             response.fold(
                 |v, _, _| v
                     == PBind(
-                    String::from("a"),
-                    PLookahead(PIdent(String::from("entry")).wrap()).wrap()
-                ),
+                        String::from("a"),
+                        PLookahead(PIdent(String::from("entry")).wrap()).wrap()
+                    ),
                 |_, _| false
             ),
             true
@@ -215,16 +217,16 @@ mod parser_tests {
 
     #[test]
     fn should_parse_protected_simple_rule() {
-        let response = rule().parse(CharStream::new("let x:{()} = entry"));
+        let response = rule().parse(CharStream::new("let x = entry"));
 
         assert_eq!(
             response.fold(
                 |v, _, _| v
                     == ASTParsecRule::<char> {
                         public: false,
                         name: String::from("x"),
-                        input: String::from("char"),
-                        returns: String::from("()"),
+                        input: PChar,
+                        returns: PUnit,
                         rule: PIdent(String::from("entry"))
                     },
                 |_, _| false
@@ -235,16 +237,16 @@ mod parser_tests {
 
     #[test]
     fn should_parse_public_simple_rule() {
-        let response = rule().parse(CharStream::new("pub let x:{()} = entry"));
+        let response = rule().parse(CharStream::new("pub let x = entry"));
 
         assert_eq!(
             response.fold(
                 |v, _, _| v
                     == ASTParsecRule::<char> {
                         public: true,
                         name: String::from("x"),
-                        input: String::from("char"),
-                        returns: String::from("()"),
+                        input: PChar,
+                        returns: PUnit,
                         rule: PIdent(String::from("entry"))
                     },
                 |_, _| false