Use + instead cat in printer

Author: osa1

compiler/AstPrinter.fir

@@ -1,35 +1,35 @@
 Expr.pprint(self): Doc
     match self:
         Expr.Var(VarExpr(id, tyArgs)) | Expr.Constr(ConstrExpr(id, tyArgs)):
-            Doc.str(id.name).cat(_ppTyArgs(tyArgs))
+            Doc.str(id.name) + _ppTyArgs(tyArgs)
 
         Expr.ConstrSelect(ConstrSelectExpr(ty, constr, tyArgs)):
-            Doc.str(ty.name).cat(Doc.char('.')).cat(Doc.str(constr.name)).cat(_ppTyArgs(tyArgs))
+            Doc.str(ty.name) + Doc.char('.') + Doc.str(constr.name) + _ppTyArgs(tyArgs)
 
         Expr.FieldSelect(FieldSelectExpr(object, field)):
             let addParens = _needsParens(object.node)
             let doc = object.node.pprint()
             if addParens:
                 doc = parens(doc)
-            doc.cat(Doc.char('.')).cat(Doc.str(field.name))
+            doc + Doc.char('.') + Doc.str(field.name)
 
         Expr.MethodSelect(MethodSelectExpr(object, method, ..)):
             # TODO: Print all of the details.
             let addParens = _needsParens(object.node)
             let doc = object.node.pprint()
             if addParens:
                 doc = parens(doc)
-            doc.cat(Doc.char('.')).cat(Doc.str(method.name))
+            doc + Doc.char('.') + Doc.str(method.name)
 
         Expr.AssocFnSelect(AssocFnSelectExpr(ty, member, tyArgs)):
-            Doc.str(ty.name).cat(Doc.char('.')).cat(Doc.str(member.name)).cat(_ppTyArgs(tyArgs))
+            Doc.str(ty.name) + Doc.char('.') + Doc.str(member.name) + _ppTyArgs(tyArgs)
 
         Expr.Call(CallExpr(fun, args)):
             let addParens = _needsParens(fun.node)
             let doc = fun.node.pprint()
             if addParens:
                 doc = parens(doc)
-            doc.cat(parens(interleave(args.iter().map(CallArg.pprint), Doc.str(", "))))
+            doc + parens(interleave(args.iter().map(CallArg.pprint), Doc.str(", ")))
 
         Expr.Int(IntExpr(text, ..)):
             # TODO: Print all of the details
@@ -41,14 +41,14 @@ Expr.pprint(self): Doc
                 match part:
                     StrPart.Str(str):
                         # TODO: Escapes
-                        doc = doc.cat(Doc.str(str))
+                        doc += Doc.str(str)
                     StrPart.Expr(expr):
-                        doc = doc.cat(Doc.char('`')).cat(expr.node.pprint()).cat(Doc.char('`'))
+                        doc += Doc.char('`') + expr.node.pprint() + Doc.char('`')
             doc
 
         Expr.Char(char):
             # TODO: Escapes
-            Doc.char('\'').cat(Doc.char(char)).cat(Doc.char('\''))
+            Doc.char('\'') + Doc.char(char) + Doc.char('\'')
 
         Expr.Self:
             Doc.str("self")
@@ -57,40 +57,40 @@ Expr.pprint(self): Doc
             # TODO: Precedence and parens
             # TODO: Operator string
             parens(left.node.pprint()) \
-                .cat(Doc.blank(1)) \
-                .cat(Doc.str(op.toStr())) \
-                .cat(Doc.blank(1)) \
-                .cat(parens(right.node.pprint()))
+                + Doc.blank(1) \
+                + Doc.str(op.toStr()) \
+                + Doc.blank(1) \
+                + parens(right.node.pprint())
 
         Expr.UnOp(UnOpExpr(op, expr)):
             let opChar = match op:
                 UnOp.Not: '!'
                 UnOp.Neg: '-'
-            Doc.char(opChar).cat(expr.node.pprint())
+            Doc.char(opChar) + expr.node.pprint()
 
         Expr.Record(fields):
             _ppParenNamedFields(fields)
 
         Expr.Variant(VariantExpr(id, args)):
-            brackets(Doc.str(id.name).cat(_ppParenNamedFields(args)))
+            brackets(Doc.str(id.name) + _ppParenNamedFields(args))
 
         Expr.Return(expr):
-            Doc.str("return ").cat(expr.node.pprint())
+            Doc.str("return ") + expr.node.pprint()
 
         Expr.Match(MatchExpr(scrutinee, alts)):
-            Doc.str("match ").cat(scrutinee.node.pprint()).cat(Doc.char(':')).cat(Doc.hardLine()) \
-                .cat(interleave(alts.iter().map(_ppAlt), Doc.hardLine())) \
-                .cat(Doc.hardLine())
+            Doc.str("match ") + scrutinee.node.pprint() + Doc.char(':') + Doc.hardLine() \
+                + interleave(alts.iter().map(_ppAlt), Doc.hardLine()) \
+                + Doc.hardLine()
 
         Expr.If(IfExpr(branches, else_branch)):
             let doc = _ppIfBranch("if", branches.get(0).guard, branches.get(0).body)
             for branch: (guard: L[Expr], body: Vec[L[Stmt]]) in branches.iter().skip(1):
-                doc = doc.cat(_ppIfBranch("elif", branch.guard, branch.body))
+                doc += _ppIfBranch("elif", branch.guard, branch.body)
             match else_branch:
                 Option.None: ()
                 Option.Some(stmts):
                     for stmt: L[Stmt] in stmts.iter():
-                        doc = doc.cat(stmt.node.pprint()).cat(Doc.hardLine())
+                        doc += stmt.node.pprint() + Doc.hardLine()
             doc
 
         Expr.Fn_(FnExpr(sig, body, ..)):
@@ -99,7 +99,7 @@ Expr.pprint(self): Doc
 Type.pprint(self): Doc
     match self:
         Type.Named(NamedType(name, args)):
-            Doc.str(name.name).cat(_ppTyArgs(args))
+            Doc.str(name.name) + _ppTyArgs(args)
 
         Type.Var(var_):
             Doc.str(var_.name)
@@ -112,7 +112,7 @@ Type.pprint(self): Doc
                     if fields.len() == 0:
                         doc = Doc.str("..")
                     else:
-                        doc = doc.cat(Doc.str(", .."))
+                        doc += Doc.str(", ..")
             parens(doc)
 
         Type.Variant(alts, extension): panic("")
@@ -145,23 +145,23 @@ _ppNamedList(namedList: Vec[Named[L[a]]], ppItem: Fn(a): exn Doc): exn Doc
 _ppNamed(named: Named[L[a]], ppItem: Fn(a): exn Doc): exn Doc
     let doc = match named.name:
         Option.Some(name):
-            Doc.str(name.name).cat(Doc.str(" = "))
+            Doc.str(name.name) + Doc.str(" = ")
         Option.None:
             Doc.empty()
-    doc.cat(ppItem(named.node.node))
+    doc + ppItem(named.node.node)
 
 _ppAlt(alt: Alt): Doc
     panic("TODO")
 
 _ppIfBranch(prefix: Str, guard: L[Expr], body: Vec[L[Stmt]]): Doc
     let doc = Doc.str(prefix) \
-        .cat(Doc.break_(1)) \
-        .cat(guard.node.pprint()) \
-        .cat(Doc.char(':')) \
-        .cat(Doc.hardLine())
+        + Doc.break_(1) \
+        + guard.node.pprint() \
+        + Doc.char(':') \
+        + Doc.hardLine()
 
     for stmt: L[Stmt] in body.iter():
-        doc = doc.cat(stmt.node.pprint()).cat(Doc.hardLine())
+        doc += stmt.node.pprint() + Doc.hardLine()
 
     doc
 
@@ -181,12 +181,12 @@ interleave[Iterator[iter, Doc, exn]](iter: iter, sep: Doc): exn Doc
         Option.Some(doc): doc
 
     for item: Doc in iter:
-        doc = doc.cat(sep).cat(item)
+        doc += sep + item
 
     doc
 
 parens(doc: Doc): Doc
-    Doc.char('(').cat(doc).cat(Doc.char(')'))
+    Doc.char('(') + doc + Doc.char(')')
 
 brackets(doc: Doc): Doc
-    Doc.char('[').cat(doc).cat(Doc.char(']'))
+    Doc.char('[') + doc + Doc.char(']')