Merge pull request #3079 from rtfeldman/formatter-empty-record-patterns

Formatter empty record patterns

compiler/fmt/src/pattern.rs

@@ -85,20 +85,22 @@ impl<'a> Formattable for Pattern<'a> {
             RecordDestructure(loc_patterns) => {
                 buf.indent(indent);
                 buf.push_str("{");
-                buf.spaces(1);
 
-                let mut it = loc_patterns.iter().peekable();
+                if !loc_patterns.is_empty() {
+                    buf.spaces(1);
+                    let mut it = loc_patterns.iter().peekable();
+                    while let Some(loc_pattern) = it.next() {
+                        loc_pattern.format(buf, indent);
 
-                while let Some(loc_pattern) = it.next() {
+                        if it.peek().is_some() {
-                    loc_pattern.format(buf, indent);
+                            buf.push_str(",");
-
+                            buf.spaces(1);
-                    if it.peek().is_some() {
+                        }
-                        buf.push_str(",");
-                        buf.spaces(1);
                     }
+                    buf.spaces(1);
                 }
 
-                buf.push_str(" }");
+                buf.push_str("}");
             }
 
             RequiredField(name, loc_pattern) => {

compiler/fmt/tests/test_fmt.rs

@@ -2727,6 +2727,61 @@ mod test_fmt {
     #[test]
     fn empty_record() {
         expr_formats_same("{}");
+        expr_formats_to("{ }", "{}");
+    }
+
+    #[test]
+    fn empty_record_patterns() {
+        expr_formats_to(
+            indoc!(
+                r#"
+                    f = \{  } -> "Hello World"
+
+                    f
+                "#
+            ),
+            indoc!(
+                r#"
+                    f = \{} -> "Hello World"
+
+                    f
+                "#
+            ),
+        );
+
+        expr_formats_to(
+            indoc!(
+                r#"
+                    f = \a, b -> {  }
+
+                    f
+                "#
+            ),
+            indoc!(
+                r#"
+                    f = \a, b -> {}
+
+                    f
+                "#
+            ),
+        );
+
+        expr_formats_to(
+            indoc!(
+                r#"
+                    { } <- f a b
+
+                    {}
+                "#
+            ),
+            indoc!(
+                r#"
+                    {} <- f a b
+
+                    {}
+                "#
+            ),
+        );
     }
 
     #[test]

examples/benchmarks/AStar.roc

@@ -78,7 +78,7 @@ updateCost = \current, neighbor, model ->
 astar : (position, position -> F64), (position -> Set position), position, Model position -> Result (List position) {}
 astar = \costFn, moveFn, goal, model ->
     when cheapestOpen (\source -> costFn source goal) model is
-        Err {  } ->
+        Err {} ->
             Err {}
 
         Ok current ->

examples/benchmarks/RBTreeInsert.roc

@@ -13,7 +13,7 @@ main =
         |> Task.putLine
 
 show : RedBlackTree I64 {} -> Str
-show = \tree -> showRBTree tree Num.toStr (\{  } -> "{}")
+show = \tree -> showRBTree tree Num.toStr (\{} -> "{}")
 
 showRBTree : RedBlackTree k v, (k -> Str), (v -> Str) -> Str
 showRBTree = \tree, showKey, showValue ->

examples/benchmarks/platform/Task.roc

@@ -6,7 +6,7 @@ Task ok err : Effect.Effect (Result ok err)
 
 forever : Task val err -> Task * err
 forever = \task ->
-    looper = \{  } ->
+    looper = \{} ->
         task
             |> Effect.map
                 \res ->

examples/false-interpreter/False.roc

@@ -200,7 +200,7 @@ interpretCtxLoop = \ctx ->
                         # `"` end of string
                         when Str.fromUtf8 bytes is
                             Ok str ->
-                                {  } <- Task.await (Stdout.raw str)
+                                {} <- Task.await (Stdout.raw str)
                                 Task.succeed (Step { newCtx & state: Executing })
 
                             Err _ ->
@@ -481,7 +481,7 @@ stepExecCtx = \ctx, char ->
                 Ok (T popCtx num) ->
                     when Str.fromUtf8 [ Num.intCast num ] is
                         Ok str ->
-                            {  } <- Task.await (Stdout.raw str)
+                            {} <- Task.await (Stdout.raw str)
                             Task.succeed popCtx
 
                         Err _ ->
@@ -494,7 +494,7 @@ stepExecCtx = \ctx, char ->
             # `.` write int
             when popNumber ctx is
                 Ok (T popCtx num) ->
-                    {  } <- Task.await (Stdout.raw (Num.toStr (Num.intCast num)))
+                    {} <- Task.await (Stdout.raw (Num.toStr (Num.intCast num)))
                     Task.succeed popCtx
 
                 Err e ->

examples/false-interpreter/platform/File.roc

@@ -23,5 +23,5 @@ withOpen : Str, (Handle -> Task {} a) -> Task {} a
 withOpen = \path, callback ->
     handle <- Task.await (open path)
     result <- Task.attempt (callback handle)
-    {  } <- Task.await (close handle)
+    {} <- Task.await (close handle)
     Task.fromResult result

examples/interactive/cli-platform/Task.roc

@@ -6,7 +6,7 @@ Task ok err : Effect.Effect (Result ok err)
 
 forever : Task val err -> Task * err
 forever = \task ->
-    looper = \{  } ->
+    looper = \{} ->
         task
             |> Effect.map
                 \res ->

examples/interactive/effects.roc

@@ -10,8 +10,8 @@ main =
         \line ->
             Effect.after
                 (Effect.putLine "You entered: \(line)")
-                \{  } ->
+                \{} ->
                     Effect.after
                         (Effect.putLine "It is known")
-                        \{  } ->
+                        \{} ->
                             Effect.always {}

examples/interactive/tui.roc

@@ -7,7 +7,7 @@ Model : Str
 
 main : Program Model
 main = {
-    init: \{  } -> "Hello World",
+    init: \{} -> "Hello World",
     update: \model, new -> Str.concat model new,
     view: \model -> Str.concat model "!",
 }