Unify pretty printing of AST.Pat.t and NestedPat.t

MLton · Sep 4, 2015 · 0cdc1f1 · 0cdc1f1
1 parent 431e42e
commit 0cdc1f1
Show file tree

Hide file tree

Showing 2 changed files with 14 additions and 16 deletions.
diff --git a/mlton/ast/ast-core.fun b/mlton/ast/ast-core.fun
@@ -128,9 +128,7 @@ structure Pat =
                              seq [str "as ", layoutT pat]])
              | List ps => list (Vector.toListMap (ps, layoutT))
              | Or ps =>
-                  paren
-                  (mayAlign (separate
-                             (Vector.toListMap (ps, layoutT), "|")))
+                  paren (mayAlign (separateLeft (Vector.toListMap (ps, layoutT), "|")))
              | Record {items, flexible} =>
                   seq [str "{",
                        mayAlign (separateRight
@@ -141,7 +139,7 @@ structure Pat =
                                     else ", ...")
                        else empty,
                        str "}"]
-             | Tuple ps => Vector.layout layoutT ps
+             | Tuple ps => Layout.tuple (Vector.toListMap (ps, layoutT))
              | Var {name, fixop} => seq [Fixop.layout fixop, layoutLongvid name]
              | Wild => str "_"
          end

diff --git a/mlton/match-compile/nested-pat.fun b/mlton/match-compile/nested-pat.fun
@@ -39,27 +39,27 @@ fun tuple ps =
    else T {pat = Tuple ps,
            ty = Type.tuple (Vector.map (ps, ty))}
 
-fun layout p =
+fun layout (p, isDelimited) =
    let
       open Layout
+      fun delimit t = if isDelimited then t else paren t
    in
       case node p of
          Con {arg, con, targs} =>
-            let
-               val z =
-                  Pretty.conApp {arg = Option.map (arg, layout),
-                                 con = Con.layout con,
-                                 targs = Vector.map (targs, Type.layout)}
-            in
-               if isSome arg then paren z else z
-            end
+            delimit (Pretty.conApp {arg = Option.map (arg, layoutF),
+                                    con = Con.layout con,
+                                    targs = Vector.map (targs, Type.layout)})
        | Const {const = c, ...} => Const.layout c
-       | Layered (x, p) => paren (seq [Var.layout x, str " as ", layout p])
-       | Or ps => paren (mayAlign (separateRight (Vector.toListMap (ps, layout), "|")))
-       | Tuple ps => tuple (Vector.toListMap (ps, layout))
+       | Layered (x, p) => delimit (seq [Var.layout x, str " as ", layoutT p])
+       | Or ps => paren (mayAlign (separateLeft (Vector.toListMap (ps, layoutT), "|")))
+       | Tuple ps => tuple (Vector.toListMap (ps, layoutT))
        | Var x => Var.layout x
        | Wild => str "_"
    end
+and layoutF p = layout (p, false)
+and layoutT p = layout (p, true)
+
+val layout = layoutT
 
 fun make (p, t) =
    case p of