Preparation for sharing

- rustfmt
- clippy
- comments
- README

src/parse/name.rs

@@ -1,22 +1,28 @@
-use chumsky::{self, prelude::*, Parser};
+use chumsky::prelude::*;
+use chumsky::{self, Parser};
+
+use super::decls::{BoxedSimpleParser, SimpleParser};
 
 /// Matches any one of the passed operators, preferring longer ones
-fn op_parser<'a>(ops: &[impl AsRef<str> + Clone])
--> BoxedParser<'a, char, String, Simple<char>>
-{
-  let mut sorted_ops: Vec<String> = ops.iter()
-    .map(|t| t.as_ref().to_string()).collect();
+fn op_parser<'a>(
+  ops: &[impl AsRef<str> + Clone],
+) -> BoxedSimpleParser<'a, char, String> {
+  let mut sorted_ops: Vec<String> =
+    ops.iter().map(|t| t.as_ref().to_string()).collect();
   sorted_ops.sort_by_key(|op| -(op.len() as i64));
-  sorted_ops.into_iter()
+  sorted_ops
+    .into_iter()
     .map(|op| just(op).boxed())
     .reduce(|a, b| a.or(b).boxed())
     .unwrap_or_else(|| {
       empty().map(|()| panic!("Empty isn't meant to match")).boxed()
-    }).labelled("operator").boxed()
+    })
+    .labelled("operator")
+    .boxed()
 }
 
 /// Characters that cannot be parsed as part of an operator
-/// 
+///
 /// The initial operator list overrides this.
 static NOT_NAME_CHAR: &[char] = &[
   ':', // used for namespacing and type annotations
@@ -28,35 +34,34 @@ static NOT_NAME_CHAR: &[char] = &[
 ];
 
 /// Matches anything that's allowed as an operator
-/// 
+///
 /// FIXME: `@name` without a dot should be parsed correctly for overrides.
 /// Could be an operator but then parametrics should take precedence,
 /// which might break stuff. investigate.
-/// 
+///
 /// TODO: `'` could work as an operator whenever it isn't closed.
 /// It's common im maths so it's worth a try
-/// 
+///
 /// TODO: `.` could possibly be parsed as an operator in some contexts.
 /// This operator is very common in maths so it's worth a try.
 /// Investigate.
-pub fn modname_parser<'a>()
--> impl Parser<char, String, Error = Simple<char>> + 'a
-{
+pub fn modname_parser<'a>() -> impl SimpleParser<char, String> + 'a {
   filter(move |c| !NOT_NAME_CHAR.contains(c) && !c.is_whitespace())
-    .repeated().at_least(1)
+    .repeated()
+    .at_least(1)
     .collect()
     .labelled("modname")
 }
 
 /// Parse an operator or name. Failing both, parse everything up to
 /// the next whitespace or blacklisted character as a new operator.
-pub fn name_parser<'a>(ops: &[impl AsRef<str> + Clone])
--> impl Parser<char, String, Error = Simple<char>> + 'a
-{
+pub fn name_parser<'a>(
+  ops: &[impl AsRef<str> + Clone],
+) -> impl SimpleParser<char, String> + 'a {
   choice((
     op_parser(ops), // First try to parse a known operator
     text::ident().labelled("plain text"), // Failing that, parse plain text
-    modname_parser() // Finally parse everything until tne next forbidden char
+    modname_parser(), // Finally parse everything until tne next forbidden char
   ))
   .labelled("name")
 }
@@ -65,7 +70,7 @@ pub fn name_parser<'a>(ops: &[impl AsRef<str> + Clone])
 /// and text, just not at the start.
 pub fn is_op(s: impl AsRef<str>) -> bool {
   return match s.as_ref().chars().next() {
-    Some(x) => !x.is_alphanumeric(), 
-    None => false
-  }
+    Some(x) => !x.is_alphanumeric(),
+    None => false,
+  };
 }