Minor refactoring

Author: d-plaindoux

lang/v0/macro/src/lib.rs

@@ -13,7 +13,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-
 extern crate proc_macro;
 
 use celma_v0_core::parser::response::Response;

lang/v0/parser/src/lib.rs

@@ -1,4 +1,3 @@
-#![warn(clippy::type_complexity)]
 // #![recursion_limit = "256"]
 
 pub mod parser;

lang/v1/parser/src/parser.rs

@@ -19,8 +19,8 @@ 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, PEpsilon, PIdent, PMap, PNot, PRepeat,
-    PSequence, PTry,
+    PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PEpsilon, PIdent, PMap, PNot, PRepeat, PSequence,
+    PTry,
 };
 use celma_v1_ast::syntax::{ASTParsec, ASTParsecRule};
 
@@ -93,16 +93,16 @@ parsec_rules!(
     let skip = (' '|'\t'|'\n'|'\r')* -> {}
     let ident:{String} = (skip i=#(alpha (alpha|digit|'_')*) skip) -> { i.into_iter().collect() }
 
-    let rkind = (^('<'|'>')+ rkind -> {})
-              | ('<' rkind '>' rkind -> {})
+    let kind_content = (^('<'|'>')+ kind_content -> {})
+              | ('<' kind_content '>' kind_content -> {})
               | ()
 
-    let rcode = (^('}'|'{')+ rcode -> {})
-              | ('{' rcode '}' rcode -> {})
+    let code_content = (^('}'|'{')+ code_content -> {})
+              | ('{' code_content '}' code_content -> {})
               | ()
 
-    let kind:{String} = (skip '<' c=#rkind '>' skip) -> { c.into_iter().collect() }
-    let code:{String} = (skip '{' c=#rcode '}' skip) -> { c.into_iter().collect() }
+    let kind:{String} = (skip '<' c=#kind_content '>' skip) -> { c.into_iter().collect() }
+    let code:{String} = (skip '{' c=#code_content '}' skip) -> { c.into_iter().collect() }
 
     let rules:{Vec<ASTParsecRule<char>>} = rule*
     let rule:{ASTParsecRule<char>} = (
@@ -117,7 +117,7 @@ parsec_rules!(
     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
+        skip o=('^'|'!'|'#')? skip p=(atom_block|atom_ident|atom_char|atom_string|atom_code) skip
     ) -> { mk_atom(o, p) }
 
     let atom_block:{ASTParsec<char>} = ('(' p=parsec? ')') -> { p.unwrap_or_else(PEpsilon) }

lang/v1/parser/tests/parser_tests.rs

@@ -20,7 +20,7 @@ mod parser_tests {
     use celma_v0_core::stream::char_stream::CharStream;
     use celma_v0_core::stream::specs::Len;
     use celma_v1::parser::{
-        atom_char, atom_code, atom_ident, atom_string, code, kind, parsec, rcode, rule,
+        atom_char, atom_code, atom_ident, atom_string, code, code_content, kind, parsec, rule,
     };
     use celma_v1_ast::syntax::ASTParsec::{
         PAtom, PAtoms, PBind, PCheck, PChoice, PCode, PEpsilon, PIdent, PNot, PRepeat, PSequence,
@@ -77,22 +77,22 @@ mod parser_tests {
     }
 
     #[test]
-    fn should_parse_ident_empty_rcode() {
-        let response = rcode().parse(CharStream::new("}"));
+    fn should_parse_ident_empty_code_content() {
+        let response = code_content().parse(CharStream::new("}"));
 
         assert_eq!(response.fold(|_, s, _| s.len() == 1, |_, _| false), true);
     }
 
     #[test]
-    fn should_parse_ident_body_with_block_rcode() {
-        let response = rcode().parse(CharStream::new("tutu { titi } toto }"));
+    fn should_parse_ident_body_with_block_code_content() {
+        let response = code_content().parse(CharStream::new("tutu { titi } toto }"));
 
         assert_eq!(response.fold(|_, s, _| s.len() == 1, |_, _| false), true);
     }
 
     #[test]
-    fn should_parse_ident_body_with_block_unbalanced_rcode() {
-        let response = rcode().parse(CharStream::new("{ titi"));
+    fn should_parse_ident_body_with_block_unbalanced_code_content() {
+        let response = code_content().parse(CharStream::new("{ titi"));
 
         assert_eq!(response.fold(|_, _, _| false, |_, _| true), true);
     }