Cargo.toml

@@ -47,11 +47,3 @@ raw = ["raw_audio"]
 name = "blip"
 path = "src/cli/main.rs"
 required-features = ["bin"]
-
-[[example]]
-name = "blip"
-path = "src/cli/main.rs"
-required-features = ["bin"]
-
-[lints.rust]
-missing_docs = "warn"

doc/language-design.txt

@@ -1,8 +1,8 @@
 notes:          dorémi abc... as they appear in the note list
-variables:      $v8         assign '8' to the variable named 'v'
+variables:      $v8
                 $v1+2
                 $vv+1
-                $v-4.1      as soon as the variable mutation string stops being valid, usual sheet music parsing continues (https://en.wikipedia.org/wiki/Maximal_munch)
+                $v-4.1      as soon as the variable mutation string stops being valid, usual sheet music parsing continues
 loops:          (...)
                 (2...)      to loop 2 times
                 (n...)      to loop n times (taking the integer part with the floor function)

src/cli/main.rs

@@ -166,7 +166,7 @@ fn parse_and_compile(opts: &PlayOpts) -> anyhow::Result<Vec<f64>> {
     compiler
         .compile_all(tokens)
         .inspect(|v| {
-            let is_nan = |sample: &f64| sample.abs().is_nan();
+            let is_nan = |sample| sample.abs().is_nan();
             if v.iter().all(is_nan) {
                 error!("🎉 All your samples are NaN, you got yourself a \"Not a Song\" (NaS)!")
             } else if v.iter().any(is_nan) {

src/parser.rs

@@ -10,17 +10,10 @@ use derive_new::new;
 use fasteval::Evaler;
 use log::{debug, trace, warn};
 use nom::{
-    AsChar, Compare, Input, Parser as _,
+    branch::alt, bytes::complete::{tag, take, take_till}, character::{
-    branch::alt,
-    bytes::complete::{tag, take, take_till},
-    character::{
         complete::{char, space1, usize},
         streaming::one_of,
-    },
+    }, combinator::{all_consuming, cut, opt, value}, error::{ErrorKind, FromExternalError, ParseError}, multi::many0, sequence::{delimited, preceded}, AsChar, Compare, Input, Parser as _
-    combinator::{all_consuming, cut, opt, value},
-    error::{ErrorKind, FromExternalError, ParseError},
-    multi::many0,
-    sequence::{delimited, preceded},
 };
 use nom_locate::LocatedSpan;
 
@@ -101,10 +94,7 @@ where
 
 impl<I> FromExternalError<I, anyhow::Error> for LocatedVerboseError<I> {
     fn from_external_error(input: I, _kind: ErrorKind, e: anyhow::Error) -> Self {
-        Self {
+        Self { location: input, error: Some(e) }
-            location: input,
-            error: Some(e),
-        }
     }
 }
 
@@ -240,7 +230,6 @@ impl Note {
             sorted
         };
         move |input: I| {
-            #[allow(clippy::type_complexity)]
             let mut parsers: Vec<Box<dyn Fn(I) -> IResult<I, Self>>> = notes
                 .clone()
                 .drain(..)
@@ -351,11 +340,7 @@ impl Tuplet {
     {
         trace!("making the {} parser", type_name::<Self>());
         |input| {
-            delimited(char('['),
+            delimited(char('['), cut(take_till(|c| c == ']').and_then(cut(expect(all_consuming(token_parser(parser)), "input did not match any known grammar for inner tokens (typo?)")))), cut(
-            cut(take_till(|c| c == ']')
-            .and_then(cut(expect(
-                all_consuming(token_parser(parser)),
-                "input did not match any known grammar for inner tokens (typo?)")))), cut(
                 expect(
                     char(']'), 
                     format!(
@@ -420,14 +405,8 @@ impl Slope {
                                 -> IResult<LocatedSpan<&'a str>, VariableChange>,
                         >,
                     >>()
-                    .as_mut_slice()),
+                    .as_mut_slice()), format!("expected a slope name from available slope names ({:?})", parser.slopes.clone().into_iter().map(|(s1, _)| s1.as_ref().to_string()).collect::<Vec<_>>())))
-                    format!(
+                .and(cut(take_till(|c| c == '}').and_then(cut(expect(all_consuming(token_parser(parser)), "input did not match any known grammar for inner tokens (typo?)"))))),
-                        "expected a slope name from available slope names ({:?})", 
-                        parser.slopes.clone().into_iter().map(|(s1, _)| s1.as_ref().to_string()).collect::<Vec<_>>()
-                    )))
-                .and(cut(take_till(|c| c == '}').and_then(cut(
-                    expect(all_consuming(token_parser(parser)),
-                    "input did not match any known grammar for inner tokens (typo?)"))))),
                 cut(
                     expect(
                         char('}'), 
@@ -541,16 +520,14 @@ mod tests {
         VariableChange('n', "1".parse().unwrap())
     }
 
-    type DefaultParser = Parser<
+    fn parser_generator() -> Parser<
         [&'static str; 3],
         &'static str,
         HashMap<String, VariableChange>,
         String,
         VariableChange,
         [char; 1],
-    >;
+    > {
-
-    fn parser_generator() -> DefaultParser {
         Parser::new(
             ["do", "ré", "mi"],
             HashMap::from([