parser: Refactor coagulated binops as postfix operators

This allows them to intermingle more nicely with `Try`

src/main.rs

@@ -3,7 +3,7 @@
 use doughlang::{
     ast::{
         Expr,
-        matcher::{Match, Subst},
+        macro_matcher::{Match, Subst},
     },
     lexer::{LexError, Lexer},
     parser::{ParseError, Parser},
@@ -32,6 +32,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 Ok(Response::Deny)
             }
             _ => {
+                lex(line);
                 parse(line);
                 Ok(Response::Accept)
             }
@@ -82,14 +83,19 @@ fn subst() -> Result<(), Box<dyn Error>> {
             continue;
         };
 
-        if p.next_if(TKind::Colon).is_err() {
+        if p.next_if(TKind::Arrow).is_err() {
             let Some(Subst { exp, pat }) = exp.construct(&pat) else {
+                println!("Match failed: {exp} <- {pat}");
                 continue;
             };
-            for (name, pat) in pat.iter() {
+            let mut pats: Vec<_> = pat.into_iter().collect();
+            pats.sort_by(|(a, _), (b, _)| a.cmp(b));
+            for (name, pat) in pats {
                 println!("{name}: {pat}")
             }
-            for (name, expr) in exp.iter() {
+            let mut exprs: Vec<_> = exp.into_iter().collect();
+            exprs.sort_by(|(a, _), (b, _)| a.cmp(b));
+            for (name, expr) in exprs.iter() {
                 println!("{name}: {expr}")
             }
             continue;
@@ -108,7 +114,7 @@ fn parse(document: &str) {
     let mut parser = Parser::new(Lexer::new(document));
     loop {
         match parser.parse::<Expr>(0) {
-            // Err(ParseError::FromLexer(LexError { res: "EOF", .. })) => break,
+            Err(ParseError::FromLexer(LexError { res: "EOF", .. })) => break,
             Err(e) => {
                 println!("\x1b[31m{e}\x1b[0m");
                 break;