transfer commit

src/parse/expression.rs

@@ -8,120 +8,120 @@ use super::lexer::Lexeme;
 
 /// Parses any number of expr wrapped in (), [] or {}
 fn sexpr_parser<P>(
-    expr: P
+  expr: P
 ) -> impl Parser<Lexeme, Clause, Error = Simple<Lexeme>> + Clone
 where P: Parser<Lexeme, Expr, Error = Simple<Lexeme>> + Clone {
-    Lexeme::paren_parser(expr.repeated()).map(|(del, b)| Clause::S(del, to_mrc_slice(b)))
+  Lexeme::paren_parser(expr.repeated()).map(|(del, b)| Clause::S(del, to_mrc_slice(b)))
 }
 
 /// Parses `\name.body` or `\name:type.body` where name is any valid name and type and body are
 /// both expressions. Comments are allowed and ignored everywhere in between the tokens
 fn lambda_parser<P>(
-    expr: P
+  expr: P
 ) -> impl Parser<Lexeme, Clause, Error = Simple<Lexeme>> + Clone
 where P: Parser<Lexeme, Expr, Error = Simple<Lexeme>> + Clone {
-    just(Lexeme::BS)
+  just(Lexeme::BS)
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .ignore_then(enum_parser!(Lexeme::Name))
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .then(
+    just(Lexeme::Type)
     .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .ignore_then(enum_parser!(Lexeme::Name))
+    .ignore_then(expr.clone().repeated())
     .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .then(
-        just(Lexeme::Type)
-        .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-        .ignore_then(expr.clone().repeated())
-        .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-        .or_not().map(Option::unwrap_or_default)
-    )
-    .then_ignore(just(Lexeme::name(".")))
-    .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .then(expr.repeated().at_least(1))
-    .map(|((name, typ), body): ((String, Vec<Expr>), Vec<Expr>)| {
-        // for ent in &mut body { ent.bind_parameter(&name) };
-        Clause::Lambda(name, to_mrc_slice(typ), to_mrc_slice(body))
-    })
+    .or_not().map(Option::unwrap_or_default)
+  )
+  .then_ignore(just(Lexeme::name(".")))
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .then(expr.repeated().at_least(1))
+  .map(|((name, typ), body): ((String, Vec<Expr>), Vec<Expr>)| {
+    // for ent in &mut body { ent.bind_parameter(&name) };
+    Clause::Lambda(name, to_mrc_slice(typ), to_mrc_slice(body))
+  })
 }
 
 /// see [lambda_parser] but `@` instead of `\` and the name is optional
 fn auto_parser<P>(
-    expr: P
+  expr: P
 ) -> impl Parser<Lexeme, Clause, Error = Simple<Lexeme>> + Clone
 where P: Parser<Lexeme, Expr, Error = Simple<Lexeme>> + Clone {
-    just(Lexeme::At)
+  just(Lexeme::At)
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .ignore_then(enum_parser!(Lexeme::Name).or_not())
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .then(
+    just(Lexeme::Type)
     .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .ignore_then(enum_parser!(Lexeme::Name).or_not())
+    .ignore_then(expr.clone().repeated())
     .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .then(
-        just(Lexeme::Type)
-        .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-        .ignore_then(expr.clone().repeated())
-        .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-        .or_not().map(Option::unwrap_or_default)
-    )
-    .then_ignore(just(Lexeme::name(".")))
-    .then_ignore(enum_parser!(Lexeme::Comment).repeated())
-    .then(expr.repeated().at_least(1))
-    .try_map(|((name, typ), body): ((Option<String>, Vec<Expr>), Vec<Expr>), s| {
-        if name.is_none() && typ.is_empty() {
-            Err(Simple::custom(s, "Auto without name or type has no effect"))
-        } else { 
-            Ok(Clause::Auto(name, to_mrc_slice(typ), to_mrc_slice(body)))
-        }
-    })
+    .or_not().map(Option::unwrap_or_default)
+  )
+  .then_ignore(just(Lexeme::name(".")))
+  .then_ignore(enum_parser!(Lexeme::Comment).repeated())
+  .then(expr.repeated().at_least(1))
+  .try_map(|((name, typ), body): ((Option<String>, Vec<Expr>), Vec<Expr>), s| {
+    if name.is_none() && typ.is_empty() {
+      Err(Simple::custom(s, "Auto without name or type has no effect"))
+    } else { 
+      Ok(Clause::Auto(name, to_mrc_slice(typ), to_mrc_slice(body)))
+    }
+  })
 }
 
 /// Parses a sequence of names separated by :: <br/>
 /// Comments are allowed and ignored in between
 fn name_parser() -> impl Parser<Lexeme, Vec<String>, Error = Simple<Lexeme>> + Clone {
-    enum_parser!(Lexeme::Name).separated_by(
-        enum_parser!(Lexeme::Comment).repeated()
-        .then(just(Lexeme::NS))
-        .then(enum_parser!(Lexeme::Comment).repeated())
-    ).at_least(1)
+  enum_parser!(Lexeme::Name).separated_by(
+    enum_parser!(Lexeme::Comment).repeated()
+    .then(just(Lexeme::NS))
+    .then(enum_parser!(Lexeme::Comment).repeated())
+  ).at_least(1)
 }
 
 /// Parse any legal argument name starting with a `$`
 fn placeholder_parser() -> impl Parser<Lexeme, String, Error = Simple<Lexeme>> + Clone {
-    enum_parser!(Lexeme::Name).try_map(|name, span| {
-        name.strip_prefix('$').map(&str::to_string)
-            .ok_or_else(|| Simple::custom(span, "Not a placeholder"))
-    })
+  enum_parser!(Lexeme::Name).try_map(|name, span| {
+    name.strip_prefix('$').map(&str::to_string)
+      .ok_or_else(|| Simple::custom(span, "Not a placeholder"))
+  })
 }
 
 /// Parse an expression
 pub fn xpr_parser() -> impl Parser<Lexeme, Expr, Error = Simple<Lexeme>> {
-    recursive(|expr| {
-        let clause = 
-        enum_parser!(Lexeme::Comment).repeated()
-        .ignore_then(choice((
-            enum_parser!(Lexeme >> Literal; Int, Num, Char, Str).map(Clause::Literal),
-            placeholder_parser().map(|key| Clause::Placeh{key, vec: None}),
-            just(Lexeme::name("...")).to(true)
-                .or(just(Lexeme::name("..")).to(false))
-                .then(placeholder_parser())
-                .then(
-                    just(Lexeme::Type)
-                    .ignore_then(enum_parser!(Lexeme::Int))
-                    .or_not().map(Option::unwrap_or_default)
-                )
-                .map(|((nonzero, key), prio)| Clause::Placeh{key, vec: Some((
-                    prio.try_into().unwrap(),
-                    nonzero
-                ))}),
-            name_parser().map(|qualified| Clause::Name {
-                local: if qualified.len() == 1 {Some(qualified[0].clone())} else {None},
-                qualified: to_mrc_slice(qualified)
-            }),
-            sexpr_parser(expr.clone()),
-            lambda_parser(expr.clone()),
-            auto_parser(expr.clone()),
-            just(Lexeme::At).ignore_then(expr.clone()).map(|arg| {
-                Clause::Explicit(Mrc::new(arg))
-            })
-        ))).then_ignore(enum_parser!(Lexeme::Comment).repeated());
-        clause.clone().then(
-            just(Lexeme::Type)
-            .ignore_then(clause.clone())
-            .repeated()
+  recursive(|expr| {
+    let clause = 
+    enum_parser!(Lexeme::Comment).repeated()
+    .ignore_then(choice((
+      enum_parser!(Lexeme >> Literal; Int, Num, Char, Str).map(Clause::Literal),
+      placeholder_parser().map(|key| Clause::Placeh{key, vec: None}),
+      just(Lexeme::name("...")).to(true)
+        .or(just(Lexeme::name("..")).to(false))
+        .then(placeholder_parser())
+        .then(
+          just(Lexeme::Type)
+          .ignore_then(enum_parser!(Lexeme::Int))
+          .or_not().map(Option::unwrap_or_default)
         )
-        .map(|(val, typ)| Expr(val, to_mrc_slice(typ)))
-    }).labelled("Expression")
+        .map(|((nonzero, key), prio)| Clause::Placeh{key, vec: Some((
+          prio.try_into().unwrap(),
+          nonzero
+        ))}),
+      name_parser().map(|qualified| Clause::Name {
+        local: if qualified.len() == 1 {Some(qualified[0].clone())} else {None},
+        qualified: to_mrc_slice(qualified)
+      }),
+      sexpr_parser(expr.clone()),
+      lambda_parser(expr.clone()),
+      auto_parser(expr.clone()),
+      just(Lexeme::At).ignore_then(expr.clone()).map(|arg| {
+        Clause::Explicit(Mrc::new(arg))
+      })
+    ))).then_ignore(enum_parser!(Lexeme::Comment).repeated());
+    clause.clone().then(
+      just(Lexeme::Type)
+      .ignore_then(clause.clone())
+      .repeated()
+    )
+    .map(|(val, typ)| Expr(val, to_mrc_slice(typ)))
+  }).labelled("Expression")
 }