fix: Rework how hanging lambda/parens are handled

Less hacks which leads to a much more consistent formatting in the face
of newlines and comments

Cargo.toml

@@ -148,3 +148,6 @@ debug = 1
 
 [profile.release]
 debug = 1
+
+[patch.crates-io]
+pretty = { path = "../pretty.rs", version = "0.9.0" }

README.md

@@ -93,8 +93,14 @@ let { (*>), (<*), wrap } = import! std.applicative
 
 let { for } = import! std.traversable
 
-type Op = | Add | Sub | Div | Mul
-type Expr = | Int Int | Binop Expr Op Expr
+type Op =
+    | Add
+    | Sub
+    | Div
+    | Mul
+type Expr =
+    | Int Int
+    | Binop Expr Op Expr
 
 let parse : String -> Result String Expr =
     // Gluon has a small parser combinator library which makes it easy to define an expression parser
@@ -110,7 +116,9 @@ let parse : String -> Result String Expr =
         lazy_parser,
         chainl1,
         (<?>),
-        ? } = import! std.parser
+        ?
+    } =
+        import! std.parser
     let { (<|>) } = import! std.alternative
 
     let lex x = x <* spaces
@@ -123,13 +131,14 @@ let parse : String -> Result String Expr =
         | Err _ -> parser.fail "Unable to parse integer"
 
     let operator =
-        satisfy_map (\c ->
-            match c with
-            | '*' -> Some Mul
-            | '+' -> Some Add
-            | '-' -> Some Sub
-            | '/' -> Some Div
-            | _ -> None)
+        satisfy_map
+            (\c ->
+                match c with
+                | '*' -> Some Mul
+                | '+' -> Some Add
+                | '-' -> Some Sub
+                | '/' -> Some Div
+                | _ -> None)
             <?> "operator"
 
     rec
@@ -145,9 +154,6 @@ let parse : String -> Result String Expr =
 
     let expr _ = binop ()
     in
-
-    // Gluon makes it possible to partially apply functions which we use here to scope all parser functions
-    // inside the `let parse` binding above.
     let parse : String -> Result String Expr = parser.parse (expr () <* spaces)
     parse
 
@@ -175,15 +181,19 @@ let eval expr : Expr -> Int =
             | Mul -> (*)
         f (eval l) (eval r)
 
-do digits =
+do
+digits
+=
     let gen_digit = random.thread_rng.gen_int_range 1 10
     do a = gen_digit
     do b = gen_digit
     do c = gen_digit
     do d = gen_digit
     wrap [a, b, c, d]
 
-let print_digits = for digits (\d ->
+let print_digits = for
+    digits
+    (\d ->
         seq io.print " "
         io.print (show d))
 seq io.print "Four digits:" *> print_digits *> io.println ""
@@ -199,8 +209,7 @@ let guess_loop _ =
         | Ok expr ->
             if validate digits expr then
                 let result = eval expr
-                if result == 24
-                then io.println "Correct!"
+                if result == 24 then io.println "Correct!"
                 else io.println ("Incorrect, " <> int.show.show result <> " != 24") *> guess_loop ()
             else
                 io.println

base/src/error.rs

@@ -216,19 +216,18 @@ impl<E: fmt::Display> InFile<E> {
         self.error
     }
 
-    pub fn emit_string(&self, code_map: &::codespan::CodeMap) -> io::Result<String>
+    pub fn emit_string(&self) -> io::Result<String>
     where
         E: AsDiagnostic,
     {
         let mut output = Vec::new();
         self.emit(
             &mut ::codespan_reporting::termcolor::NoColor::new(&mut output),
-            code_map,
         )?;
         Ok(String::from_utf8(output).unwrap())
     }
 
-    pub fn emit<W>(&self, writer: &mut W, code_map: &::codespan::CodeMap) -> io::Result<()>
+    pub fn emit<W>(&self, writer: &mut W) -> io::Result<()>
     where
         W: ?Sized + ::codespan_reporting::termcolor::WriteColor,
         E: AsDiagnostic,
@@ -242,7 +241,7 @@ impl<E: fmt::Display> InFile<E> {
             if i != 0 {
                 writeln!(writer)?;
             }
-            ::codespan_reporting::emit(&mut *writer, &code_map, &diagnostic)?;
+            ::codespan_reporting::emit(&mut *writer, &self.source, &diagnostic)?;
         }
         Ok(())
     }
@@ -254,7 +253,7 @@ impl<E: fmt::Display + AsDiagnostic> fmt::Display for InFile<E> {
         {
             let mut writer = ::codespan_reporting::termcolor::NoColor::new(&mut buffer);
 
-            self.emit(&mut writer, &self.source)
+            self.emit(&mut writer)
                 .map_err(|_| fmt::Error)?;
         }
 

base/src/lib.rs

@@ -73,8 +73,9 @@ macro_rules! type_cache {
     }
 }
 
+#[macro_export]
 macro_rules! chain {
-    ($alloc: expr; $first: expr, $($rest: expr),+) => {{
+    ($alloc: expr; $first: expr, $($rest: expr),+ $(,)?) => {{
         let mut doc = ::pretty::DocBuilder($alloc, $first.into());
         $(
             doc = doc.append($rest);

base/src/source.rs

@@ -159,7 +159,7 @@ impl<'a> DoubleEndedIterator for CommentIter<'a> {
                 .src
                 .trim_end_matches(|c: char| c.is_whitespace() && c != '\n');
             if self.src.ends_with('\n') {
-                let comment_line = self.src[..self.src.len() - 1].lines().next_back().unwrap();
+                let comment_line = self.src[..self.src.len() - 1].lines().next_back()?;
                 let trimmed = comment_line.trim_start();
 
                 let newline_len = if self.src.ends_with("\r\n") { 2 } else { 1 };