lite refactoring

Author: functora

rust/rustell/src/lib.rs

@@ -7,83 +7,98 @@ use chumsky::text::{Char, Padded};
 
 #[derive(Eq, PartialEq, Debug, Clone)]
 pub enum Expr<'src> {
-    Use(UseExpr<'src>),
+    Use(ExprUse<'src>),
     Other(&'src str),
 }
 
 #[derive(Eq, PartialEq, Debug, Clone)]
-pub enum UseExpr<'src> {
+pub enum ExprUse<'src> {
     Item {
         module: &'src str,
         rename: Option<&'src str>,
-        nested: Option<Box<UseExpr<'src>>>,
+        nested: Option<Box<ExprUse<'src>>>,
     },
-    Many(Vec<UseExpr<'src>>),
+    Many(Vec<ExprUse<'src>>),
     Glob,
 }
 
-pub fn parser<'src>() -> impl Parser<
+pub fn expr<'src>() -> impl Parser<
     'src,
     &'src str,
     Vec<Expr<'src>>,
     extra::Err<Rich<'src, char>>,
 > {
-    let use_expr = || {
-        lexeme("use")
-            .ignore_then(use_parser())
-            .then_ignore(lexeme(";").or_not())
-            .map(Expr::Use)
-    };
-
-    let other = use_expr()
-        .not()
-        .ignore_then(any())
+    expr_use()
+        .or(expr_other())
         .repeated()
-        .at_least(1)
-        .to_slice()
-        .map(Expr::Other);
+        .collect::<Vec<_>>()
+}
 
-    use_expr().or(other).repeated().collect::<Vec<_>>()
+fn expr_use<'src>() -> impl Parser<
+    'src,
+    &'src str,
+    Expr<'src>,
+    extra::Err<Rich<'src, char>>,
+> {
+    lexeme("use")
+        .ignore_then(expr_use_rec())
+        .then_ignore(lexeme(";").or_not())
+        .map(Expr::Use)
 }
 
-fn use_parser<'src>() -> impl Parser<
+fn expr_use_rec<'src>() -> impl Parser<
     'src,
     &'src str,
-    UseExpr<'src>,
+    ExprUse<'src>,
     extra::Err<Rich<'src, char>>,
 > {
-    recursive(|use_parser| {
+    recursive(|expr_use| {
         let ident = || text::ascii::ident().padded();
         let item = ident()
             .then(
                 lexeme("as").ignore_then(ident()).or_not(),
             )
             .then(
                 lexeme("::")
-                    .ignore_then(use_parser.clone())
+                    .ignore_then(expr_use.clone())
                     .or_not(),
             )
             .map(|((module, rename), nested)| {
-                UseExpr::Item {
+                ExprUse::Item {
                     module,
                     rename,
                     nested: nested.map(Box::new),
                 }
             });
 
-        let many = use_parser
+        let many = expr_use
             .separated_by(lexeme(','))
             .allow_trailing()
             .collect::<Vec<_>>()
             .delimited_by(lexeme('{'), lexeme('}'))
-            .map(UseExpr::Many);
+            .map(ExprUse::Many);
 
-        let glob = lexeme("*").map(|_| UseExpr::Glob);
+        let glob = lexeme("*").map(|_| ExprUse::Glob);
 
         item.or(many).or(glob)
     })
 }
 
+fn expr_other<'src>() -> impl Parser<
+    'src,
+    &'src str,
+    Expr<'src>,
+    extra::Err<Rich<'src, char>>,
+> {
+    expr_use()
+        .not()
+        .ignore_then(any())
+        .repeated()
+        .at_least(1)
+        .to_slice()
+        .map(Expr::Other)
+}
+
 fn lexeme<'src, T, I, E>(seq: T) -> Padded<Just<T, I, E>>
 where
     I: Input<'src>,

rust/rustell/src/main.rs

@@ -6,8 +6,10 @@ fn main() {
     io::stdin()
         .read_to_string(&mut src)
         .expect("Failed to read stdin");
-    match parser().parse(src.trim()).into_result() {
+    match expr().parse(src.trim()).into_result() {
         Ok(ast) => println!("{:#?}", ast),
-        Err(errs) => errs.into_iter().for_each(|e| println!("{e:?}")),
+        Err(errs) => {
+            errs.into_iter().for_each(|e| println!("{e:?}"))
+        }
     };
 }