review initial AST remove useless parametric type

Author: d-plaindoux

lang/README.md

@@ -9,12 +9,6 @@ the Rust compilation stage.
 In the V0 the compilation is a direct style Parsec generation without any 
 optimisations. 
 
-### V1
-
-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)
-
 #### Abstract syntax tree
 
 ```rust
@@ -37,10 +31,16 @@ pub enum ASTParsec {
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ASTParsecRule {
-    pub public: bool,
     pub name: String,
     pub input: String,
     pub returns: String,
     pub rule: Box<ASTParsec>,
 }
-```
+```
+
+### V1
+
+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)
+

lang/v0/ast/src/syntax.rs

@@ -15,37 +15,37 @@
  */
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum ASTParsec<I> {
+pub enum ASTParsec {
     PIdent(String),
     // Are these constructors required?
-    PAtom(I),
-    PAtoms(Vec<I>),
-    PBind(String, Box<ASTParsec<I>>),
+    PAtom(char),
+    PAtoms(Vec<char>),
+    PBind(String, Box<ASTParsec>),
     // --------------------------------
     PCode(String),
-    PMap(Box<ASTParsec<I>>, String),
-    PSequence(Box<ASTParsec<I>>, Box<ASTParsec<I>>),
-    PChoice(Box<ASTParsec<I>>, Box<ASTParsec<I>>),
-    PNot(Box<ASTParsec<I>>),
-    PTry(Box<ASTParsec<I>>),
-    PCheck(Box<ASTParsec<I>>),
-    POptional(Box<ASTParsec<I>>),
-    PRepeat(bool, Box<ASTParsec<I>>),
-    PLookahead(Box<ASTParsec<I>>),
+    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>),
 }
 
 
 
-impl<I> ASTParsec<I> {
+impl ASTParsec {
     pub fn wrap(self) -> Box<Self> {
         Box::new(self)
     }
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ASTParsecRule<I> {
+pub struct ASTParsecRule {
     pub name: String,
     pub input: String,
     pub returns: String,
-    pub rule: ASTParsec<I>,
+    pub rule: ASTParsec,
 }

lang/v0/parser/src/parser.rs

@@ -76,8 +76,7 @@ where
 // -------------------------------------------------------------------------------------------------
 
 #[inline]
-fn parsec_rules<'a, S>(
-) -> impl Parse<Vec<ASTParsecRule<char>>, S> + Combine<Vec<ASTParsecRule<char>>> + 'a
+fn parsec_rules<'a, S>() -> impl Parse<Vec<ASTParsecRule>, S> + Combine<Vec<ASTParsecRule>> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
@@ -96,13 +95,11 @@ where
         .and(parsec())
         .and_left(skip())
         .map(
-            |(((n, i), r), b): (((String, Option<String>), String), ASTParsec<char>)| {
-                ASTParsecRule {
-                    name: n,
-                    input: i.unwrap_or(String::from("char")),
-                    returns: r,
-                    rule: b,
-                }
+            |(((n, i), r), b): (((String, Option<String>), String), ASTParsec)| ASTParsecRule {
+                name: n,
+                input: i.unwrap_or(String::from("char")),
+                returns: r,
+                rule: b,
             },
         )
         .rep()
@@ -111,7 +108,7 @@ where
 // -------------------------------------------------------------------------------------------------
 
 #[inline]
-fn parsec<'a, S>() -> impl Parse<ASTParsec<char>, S> + Combine<ASTParsec<char>> + 'a
+fn parsec<'a, S>() -> impl Parse<ASTParsec, S> + Combine<ASTParsec> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
@@ -179,8 +176,7 @@ where
     char_in_set(vec!['+', '?', '*'])
 }
 
-fn additional<'a, S>(
-) -> impl Parse<(bool, ASTParsec<char>), S> + Combine<(bool, ASTParsec<char>)> + 'a
+fn additional<'a, S>() -> impl Parse<(bool, ASTParsec), S> + Combine<(bool, ASTParsec)> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
@@ -192,7 +188,7 @@ where
 }
 
 #[inline]
-fn atom<'a, S>() -> impl Parse<ASTParsec<char>, S> + Combine<ASTParsec<char>> + 'a
+fn atom<'a, S>() -> impl Parse<ASTParsec, S> + Combine<ASTParsec> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
@@ -216,7 +212,7 @@ where
 }
 
 #[inline]
-fn atom2<'a, S>() -> impl Parse<ASTParsec<char>, S> + Combine<ASTParsec<char>> + 'a
+fn atom2<'a, S>() -> impl Parse<ASTParsec, S> + Combine<ASTParsec> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
@@ -225,10 +221,10 @@ where
         .and_right(lazy(|| parser(parsec())))
         .and_left(skip())
         .and_left(a_char(')'))
-    .or(code().map(PCode))
-    .or(delimited_char().map(PAtom))
-    .or(delimited_string().map(|l| PAtoms(l.chars().collect())))
-    .or(ident().map(PIdent))
+        .or(code().map(PCode))
+        .or(delimited_char().map(PAtom))
+        .or(delimited_string().map(|l| PAtoms(l.chars().collect())))
+        .or(ident().map(PIdent))
 }
 
 #[inline]
@@ -261,15 +257,15 @@ where
 
 // -------------------------------------------------------------------------------------------------
 
-pub fn celma_parsec<'a, S>() -> impl Parse<ASTParsec<char>, S> + Combine<ASTParsec<char>> + 'a
+pub fn celma_parsec<'a, S>() -> impl Parse<ASTParsec, S> + Combine<ASTParsec> + 'a
 where
     S: Stream<Item = char> + 'a,
 {
     skip().and_right(parsec()).and_left(skip()).and_left(eos())
 }
 
 pub fn celma_parsec_rules<'a, S>(
-) -> impl Parse<Vec<ASTParsecRule<char>>, S> + Combine<Vec<ASTParsecRule<char>>> + 'a
+) -> impl Parse<Vec<ASTParsecRule>, S> + Combine<Vec<ASTParsecRule>> + 'a
 where
     S: Stream<Item = char> + 'a,
 {

lang/v0/parser/src/transpiler.rs

@@ -29,7 +29,7 @@ pub trait Transpile<E> {
     fn transpile(&self) -> Result<E, Error>;
 }
 
-impl Transpile<TokenStream> for Vec<ASTParsecRule<char>> {
+impl Transpile<TokenStream> for Vec<ASTParsecRule> {
     fn transpile(&self) -> Result<TokenStream, Error> {
         let parsers: TokenStream = self
             .iter()
@@ -42,7 +42,7 @@ impl Transpile<TokenStream> for Vec<ASTParsecRule<char>> {
     }
 }
 
-impl Transpile<TokenStream> for ASTParsecRule<char> {
+impl Transpile<TokenStream> for ASTParsecRule {
     fn transpile(&self) -> Result<TokenStream, Error> {
         let Self {
             name,
@@ -80,7 +80,7 @@ impl Transpile<TokenStream> for ASTParsecRule<char> {
     }
 }
 
-impl Transpile<TokenStream> for ASTParsec<char> {
+impl Transpile<TokenStream> for ASTParsec {
     fn transpile(&self) -> Result<TokenStream, Error> {
         let body = self.transpile_body()?.1;
 
@@ -106,7 +106,7 @@ pub trait TranspileBody<E> {
     fn transpile_body(&self) -> Result<E, Error>;
 }
 
-impl TranspileBody<(Option<String>, TokenStream)> for ASTParsec<char> {
+impl TranspileBody<(Option<String>, TokenStream)> for ASTParsec {
     fn transpile_body(&self) -> Result<(Option<String>, TokenStream), Error> {
         match self {
             PBind(n, p) => Ok((Some(n.clone()), p.transpile_body()?.1)),

lang/v1/parser/src/first.rs

@@ -16,7 +16,7 @@
 
 use crate::token::Token::{AllAtom, Atom};
 use crate::token::{First, Token};
-use celma_lang_v0_ast::syntax::ASTParsec;
+use celma_lang_v1_ast::syntax::ASTParsec;
 
 impl<E> First<E> for ASTParsec<E>
 where

lang/v1/parser/tests/first_tests.rs

@@ -16,7 +16,7 @@
 
 #[cfg(test)]
 mod tests {
-    use celma_lang_v0_ast::syntax::ASTParsec::{PAtom, PIdent};
+    use celma_lang_v1_ast::syntax::ASTParsec::{PAtom, PIdent};
     use celma_lang_v1::token::First;
     use celma_lang_v1::token::Token::{AllAtom, Atom};