diff --git a/parser-typechecker/src/Unison/PrintError.hs b/parser-typechecker/src/Unison/PrintError.hs
index 8e2c458b34..6d367dfe3b 100644
--- a/parser-typechecker/src/Unison/PrintError.hs
+++ b/parser-typechecker/src/Unison/PrintError.hs
@@ -59,6 +59,7 @@ import Unison.Syntax.Name qualified as Name (toText)
 import Unison.Syntax.NamePrinter (prettyHashQualified0)
 import Unison.Syntax.Parser (Annotated, ann)
 import Unison.Syntax.Parser qualified as Parser
+import Unison.Syntax.Precedence qualified as Precedence
 import Unison.Syntax.TermPrinter qualified as TermPrinter
 import Unison.Term qualified as Term
 import Unison.Type (Type)
@@ -1132,7 +1133,7 @@ renderTerm env e =
         else fromString s
 
 renderPattern :: Env -> Pattern ann -> ColorText
-renderPattern env e = Pr.renderUnbroken . Pr.syntaxToColor . fst $ TermPrinter.prettyPattern env TermPrinter.emptyAc 0 ([] :: [Symbol]) e
+renderPattern env e = Pr.renderUnbroken . Pr.syntaxToColor . fst $ TermPrinter.prettyPattern env TermPrinter.emptyAc Precedence.Annotation ([] :: [Symbol]) e
 
 -- | renders a type with no special styling
 renderType' :: (IsString s, Var v) => Env -> Type v loc -> s
diff --git a/parser-typechecker/src/Unison/Syntax/Precedence.hs b/parser-typechecker/src/Unison/Syntax/Precedence.hs
new file mode 100644
index 0000000000..2a74b1181f
--- /dev/null
+++ b/parser-typechecker/src/Unison/Syntax/Precedence.hs
@@ -0,0 +1,71 @@
+module Unison.Syntax.Precedence where
+
+import Data.Map qualified as Map
+import Unison.Prelude
+
+-- Precedence rules for infix operators.
+-- Lower number means higher precedence (tighter binding).
+-- Operators not in this list have no precedence and will simply be parsed
+-- left-to-right.
+infixRules :: Map Text Precedence
+infixRules =
+  Map.fromList do
+    (ops, prec) <- zip infixLevels (map (InfixOp . Level) [0 ..])
+    map (,prec) ops
+
+-- | Indicates this is the RHS of a top-level definition.
+isTopLevelPrecedence :: Precedence -> Bool
+isTopLevelPrecedence i = i == Basement
+
+increment :: Precedence -> Precedence
+increment = \case
+  Basement -> Bottom
+  Bottom -> Annotation
+  Annotation -> Statement
+  Statement -> Control
+  Control -> InfixOp Lowest
+  InfixOp Lowest -> InfixOp (Level 0)
+  InfixOp (Level n) -> InfixOp (Level (n + 1))
+  InfixOp Highest -> Application
+  Application -> Prefix
+  Prefix -> Top
+  Top -> Top
+
+data Precedence
+  = -- | The lowest precedence, used for top-level bindings
+    Basement
+  | -- | Used for terms that never need parentheses
+    Bottom
+  | -- | Type annotations
+    Annotation
+  | -- | A statement in a block
+    Statement
+  | -- | Control flow constructs like `if`, `match`, `case`
+    Control
+  | -- | Infix operators
+    InfixOp InfixPrecedence
+  | -- | Function application
+    Application
+  | -- | Prefix operators like `'`, `!`
+    Prefix
+  | -- | The highest precedence, used for let bindings and blocks
+    Top
+  deriving (Eq, Ord, Show)
+
+data InfixPrecedence = Lowest | Level Int | Highest
+  deriving (Eq, Ord, Show)
+
+infixLevels :: [[Text]]
+infixLevels =
+  [ ["||", "|"],
+    ["&&", "&"],
+    ["==", "!==", "!=", "==="],
+    ["<", ">", ">=", "<="],
+    ["+", "-"],
+    ["*", "/", "%"],
+    ["^", "^^", "**"]
+  ]
+
+-- | Returns the precedence of an infix operator, if it has one.
+operatorPrecedence :: Text -> Maybe Precedence
+operatorPrecedence op = Map.lookup op infixRules
diff --git a/parser-typechecker/src/Unison/Syntax/TermParser.hs b/parser-typechecker/src/Unison/Syntax/TermParser.hs
index ee4ac0450e..ec4bc42177 100644
--- a/parser-typechecker/src/Unison/Syntax/TermParser.hs
+++ b/parser-typechecker/src/Unison/Syntax/TermParser.hs
@@ -54,6 +54,7 @@ import Unison.Syntax.NameSegment qualified as NameSegment
 import Unison.Syntax.Parser hiding (seq)
 import Unison.Syntax.Parser qualified as Parser (seq, uniqueName)
 import Unison.Syntax.Parser.Doc.Data qualified as Doc
+import Unison.Syntax.Precedence (operatorPrecedence)
 import Unison.Syntax.TypeParser qualified as TypeParser
 import Unison.Term (IsTop, Term)
 import Unison.Term qualified as Term
@@ -69,9 +70,9 @@ import Prelude hiding (and, or, seq)
 {-
 Precedence of language constructs is identical to Haskell, except that all
 operators (like +, <*>, or any sequence of non-alphanumeric characters) are
-left-associative and equal precedence, and operators must have surrounding
-whitespace (a + b, not a+b) to distinguish from identifiers that may contain
-operator characters (like empty? or fold-left).
+left-associative and equal precedence (with a few exceptions), and operators
+must have surrounding whitespace (a + b, not a+b) to distinguish from
+identifiers that may contain operator characters (like empty? or fold-left).
 
 Sections / partial application of infix operators is not implemented.
 -}
@@ -411,9 +412,6 @@ list = Parser.seq Term.list
 hashQualifiedPrefixTerm :: (Monad m, Var v) => TermP v m
 hashQualifiedPrefixTerm = resolveHashQualified =<< hqPrefixId
 
-hashQualifiedInfixTerm :: (Monad m, Var v) => TermP v m
-hashQualifiedInfixTerm = resolveHashQualified =<< hqInfixId
-
 quasikeyword :: (Ord v) => Text -> P v m (L.Token ())
 quasikeyword kw = queryToken \case
   L.WordyId (HQ'.NameOnly n) | nameIsKeyword n kw -> Just ()
@@ -1033,17 +1031,85 @@ term4 = f <$> some termLeaf
     f (func : args) = Term.apps func ((\a -> (ann func <> ann a, a)) <$> args)
     f [] = error "'some' shouldn't produce an empty list"
 
+data InfixParse v
+  = InfixOp (L.Token (HQ.HashQualified Name)) (Term v Ann) (InfixParse v) (InfixParse v)
+  | InfixAnd (L.Token String) (InfixParse v) (InfixParse v)
+  | InfixOr (L.Token String) (InfixParse v) (InfixParse v)
+  | InfixOperand (Term v Ann)
+  deriving (Show, Eq, Ord)
+
 -- e.g. term4 + term4 - term4
 -- or term4 || term4 && term4
-infixAppOrBooleanOp :: (Monad m, Var v) => TermP v m
-infixAppOrBooleanOp = chainl1 term4 (or <|> and <|> infixApp)
+-- The algorithm works as follows:
+-- 1. Parse the expression left-associated
+-- 2. Starting at the leftmost operator subexpression, see if the next operator
+--   has higher precedence. If so, rotate the expression to the right.
+--   e.g. in `a + b * c`, we first parse `(a + b) * c` then rotate to `a + (b * c)`.
+-- 3. Perform the algorithm on the right-hand side if necessary, as `b` might be
+--   an infix expression with lower precedence than `*`.
+-- 4. Proceed to the next operator to the right in the original expression and
+--    repeat steps 2-3 until we reach the end.
+infixAppOrBooleanOp :: forall m v. (Monad m, Var v) => TermP v m
+infixAppOrBooleanOp = do
+  (p, ps) <- prelimParse
+  -- traceShowM ("orig" :: String, foldl' (flip ($)) p ps)
+  let p' = reassociate (p, ps)
+  -- traceShowM ("reassoc" :: String, p')
+  return (applyInfixOps p')
   where
-    or = orf <$> label "or" (reserved "||")
-    orf op lhs rhs = Term.or (ann lhs <> ann op <> ann rhs) lhs rhs
-    and = andf <$> label "and" (reserved "&&")
-    andf op lhs rhs = Term.and (ann lhs <> ann op <> ann rhs) lhs rhs
-    infixApp = infixAppf <$> label "infixApp" (hashQualifiedInfixTerm <* optional semi)
-    infixAppf op lhs rhs = Term.apps' op [lhs, rhs]
+    -- To handle a mix of infix operators with and without precedence rules,
+    -- we first parse the expression left-associated, then reassociate it
+    -- according to the precedence rules.
+    prelimParse =
+      chainl1Accum (InfixOperand <$> term4) genericInfixApp
+    genericInfixApp =
+      (InfixAnd <$> (label "and" (reserved "&&")))
+        <|> (InfixOr <$> (label "or" (reserved "||")))
+        <|> (uncurry InfixOp <$> parseInfix)
+    shouldRotate child parent = case (child, parent) of
+      (Just p1, Just p2) -> p1 < p2
+      _ -> False
+    parseInfix = label "infixApp" do
+      op <- hqInfixId <* optional semi
+      resolved <- resolveHashQualified op
+      pure (op, resolved)
+    reassociate (exp, ops) =
+      foldl' checkOp exp ops
+    checkOp exp op = fixUp (op exp)
+    fixUp = \case
+      InfixOp op tm lhs rhs ->
+        rotate (unqualified op) (InfixOp op tm) lhs rhs
+      InfixAnd op lhs rhs ->
+        rotate "&&" (InfixAnd op) lhs rhs
+      InfixOr op lhs rhs ->
+        rotate "||" (InfixOr op) lhs rhs
+      x -> x
+    rotate op ctor lhs rhs =
+      case lhs of
+        InfixOp lop ltm ll lr
+          | shouldRotate (operatorPrecedence (unqualified lop)) (operatorPrecedence op) ->
+              InfixOp lop ltm ll (fixUp (ctor lr rhs))
+        InfixAnd lop ll lr
+          | shouldRotate (operatorPrecedence "&&") (operatorPrecedence op) ->
+              InfixAnd lop ll (fixUp (ctor lr rhs))
+        InfixOr lop ll lr
+          | shouldRotate (operatorPrecedence "||") (operatorPrecedence op) ->
+              InfixOr lop ll (fixUp (ctor lr rhs))
+        _ -> ctor lhs rhs
+    unqualified t = Maybe.fromJust $ NameSegment.toEscapedText . Name.lastSegment <$> (HQ.toName $ L.payload t)
+    applyInfixOps :: InfixParse v -> Term v Ann
+    applyInfixOps t = case t of
+      InfixOp _ tm lhs rhs ->
+        Term.apps' tm [applyInfixOps lhs, applyInfixOps rhs]
+      InfixOperand tm -> tm
+      InfixAnd op lhs rhs ->
+        let lhs' = applyInfixOps lhs
+            rhs' = applyInfixOps rhs
+         in Term.and (ann lhs' <> ann op <> ann rhs') lhs' rhs'
+      InfixOr op lhs rhs ->
+        let lhs' = applyInfixOps lhs
+            rhs' = applyInfixOps rhs
+         in Term.or (ann lhs' <> ann op <> ann rhs') lhs' rhs'
 
 typedecl :: (Monad m, Var v) => P v m (L.Token v, Type v Ann)
 typedecl =
diff --git a/parser-typechecker/src/Unison/Syntax/TermPrinter.hs b/parser-typechecker/src/Unison/Syntax/TermPrinter.hs
index 5c41701bf8..cddc64399a 100644
--- a/parser-typechecker/src/Unison/Syntax/TermPrinter.hs
+++ b/parser-typechecker/src/Unison/Syntax/TermPrinter.hs
@@ -55,6 +55,7 @@ import Unison.Syntax.Lexer.Unison (showEscapeChar)
 import Unison.Syntax.Name qualified as Name (isSymboly, parseText, parseTextEither, toText, unsafeParseText)
 import Unison.Syntax.NamePrinter (styleHashQualified'')
 import Unison.Syntax.NameSegment qualified as NameSegment (toEscapedText)
+import Unison.Syntax.Precedence (InfixPrecedence (..), Precedence (..), increment, isTopLevelPrecedence, operatorPrecedence)
 import Unison.Syntax.TypePrinter qualified as TypePrinter
 import Unison.Term
 import Unison.Type (Type, pattern ForallsNamed')
@@ -92,7 +93,7 @@ data AmbientContext = AmbientContext
   { -- The operator precedence of the enclosing context (a number from 0 to 11,
     -- or -1 to render without outer parentheses unconditionally).
     -- Function application has precedence 10.
-    precedence :: !Int, -- -2 indicates top level binding, this is occasionally useful
+    precedence :: !Precedence,
     blockContext :: !BlockContext,
     infixContext :: !InfixContext,
     imports :: !Imports,
@@ -125,50 +126,58 @@ data DocLiteralContext
 
    We illustrate precedence rules as follows.
 
-     >=10
-       10f 10x
+     >=Application
+       (Application)f (Application)x
 
    This example shows that a function application f x is enclosed in
-   parentheses whenever the ambient precedence around it is >= 10, and that
-   when printing its two components, an ambient precedence of 10 is used in
+   parentheses whenever the ambient precedence around it is >= Application, and that
+   when printing its two components, an ambient precedence of Application is used in
    both places.
 
    The pretty-printer uses the following rules for printing terms.
 
-     >=12
-       let x = (-1)y
-           1z
+     >=Top
+       let x = (Bottom)y
+           (Statement)z
 
-     >=11
-       ! 11x
-       ' 11x
-       11x ?
+     >=Prefix
+       ! (Prefix)x
+       ' (Prefix)x
+       (Prefix)x ?
 
-     >=10
-       10f 10x 10y ...
+     >=(Application)
+       (Application)f (Application)x (Application)y ...
        termLink t
        typeLink t
 
-     >=3
-       x -> 2y
-       3x + 3y + ... 3z
+     >=(Infix +)
+       (Infix +)x + (Infix +)y + ... (Infix +)z
 
-     >=2
-       if 0a then 0b else 0c
-       handle 0b with 0h
-       case 2x of
-         a | 2g -> 0b
+     Printing an infix operator in infix position has the following additional
+     rule: If the operator has a lower precedence than the ambient precedence,
+     it is enclosed in parentheses. If the operator has no precedence rule,
+     its precedence is assumed to be higher than any operator to its right, and
+     lower than any operator to its left.
 
-     >=0
-       10a : 0Int
+     >(Control)
+       x -> (Control)y
+
+     >=(Control)
+       if (Annotation)a then (Annotation)b else (Annotation)c
+       handle (Annoration)b with (Annotation)h
+       case (Control)x of
+         a | (Control)g -> (Control)b
+
+     >=(Annotation)
+       (Application)a : (Annotation)Int
 
    And the following for patterns.
 
-     >=11
-       x@11p
+     >=Prefix
+       x@(Prefix)p
 
-     >=10
-       Con 10p 10q ...
+     >=Application
+       Con (Application)p (Application)q ...
 
      -- never any external parens added around the following
        { p }
@@ -191,7 +200,7 @@ pretty0 a tm | isTopLevelPrecedence (precedence a) && not (isBindingSoftHangable
   -- we allow use clause insertion here even when it otherwise wouldn't be
   -- (as long as the tm isn't soft hangable, if it gets soft hung then
   -- adding use clauses beforehand will mess things up)
-  tmp <- pretty0 (a {imports = im, precedence = -1}) tm
+  tmp <- pretty0 (a {imports = im, precedence = Bottom}) tm
   pure $ PP.lines (uses <> [tmp])
   where
     (im, uses) = calcImports (imports a) tm
@@ -217,19 +226,19 @@ pretty0
       TermLink' r -> do
         n <- getPPE
         let name = elideFQN im $ PrettyPrintEnv.termName n r
-        pure . paren (p >= 10) $
+        pure . paren (p >= Application) $
           fmt S.LinkKeyword "termLink "
             <> parenIfInfix name ic (styleHashQualified'' (fmt $ S.TermReference r) name)
       TypeLink' r -> do
         n <- getPPE
         let name = elideFQN im $ PrettyPrintEnv.typeName n r
-        pure . paren (p >= 10) $
+        pure . paren (p >= Application) $
           fmt S.LinkKeyword "typeLink "
             <> parenIfInfix name ic (styleHashQualified'' (fmt $ S.TypeReference r) name)
       Ann' tm t -> do
-        tm' <- pretty0 (ac 10 Normal im doc) tm
+        tm' <- pretty0 (ac Application Normal im doc) tm
         tp' <- TypePrinter.pretty0 im 0 t
-        pure . paren (p >= 0) $ tm' <> PP.hang (fmt S.TypeAscriptionColon " :") tp'
+        pure . paren (p >= Annotation) $ tm' <> PP.hang (fmt S.TypeAscriptionColon " :") tp'
       Int' i -> pure . fmt S.NumericLiteral . l $ (if i >= 0 then ("+" ++ show i) else (show i))
       Nat' u -> pure . fmt S.NumericLiteral . l $ show u
       Float' f -> pure . fmt S.NumericLiteral . l $ show f
@@ -247,7 +256,7 @@ pretty0
         where
           -- we only use this syntax if we're not wrapped in something else,
           -- to avoid possible round trip issues if the text ends at an odd column
-          useRaw _ | p >= 0 = Nothing
+          useRaw _ | p >= Annotation = Nothing
           useRaw s | Text.find (== '\n') s == Just '\n' && Text.all ok s = n 3
           useRaw _ = Nothing
           ok ch = isPrint ch || ch == '\n' || ch == '\r'
@@ -278,13 +287,13 @@ pretty0
             conRef = Referent.Con ref CT.Effect
         pure $ styleHashQualified'' (fmt $ S.TermReference conRef) name
       Handle' h body -> do
-        pb <- pretty0 (ac 0 Block im doc) body
-        ph <- pretty0 (ac 0 Block im doc) h
+        pb <- pretty0 (ac Annotation Block im doc) body
+        ph <- pretty0 (ac Annotation Block im doc) h
         let hangHandler = case h of
               -- handle ... with cases
               LamsNamedMatch' [] _ -> \a b -> a <> " " <> b
               _ -> PP.hang
-        pure . paren (p >= 2) $
+        pure . paren (p >= Control) $
           if PP.isMultiLine pb || PP.isMultiLine ph
             then
               PP.lines
@@ -301,36 +310,36 @@ pretty0
                 ]
       Delay' x
         | Match' _ _ <- x -> do
-            px <- pretty0 (ac 0 Block im doc) x
+            px <- pretty0 (ac Annotation Block im doc) x
             let hang = if isSoftHangable x then PP.softHang else PP.hang
-            pure . paren (p >= 3) $
+            pure . paren (p > Control) $
               fmt S.ControlKeyword "do" `hang` px
         | otherwise -> do
             let (im0', uses0) = calcImports im x
-            let allowUses = isLet x || p < 0
+            let allowUses = isLet x || (p == Bottom)
             let im' = if allowUses then im0' else im
             let uses = if allowUses then uses0 else []
-            let soft = isSoftHangable x && null uses && p < 3
+            let soft = isSoftHangable x && null uses && p < Annotation
             let hang = if soft then PP.softHang else PP.hang
-            px <- pretty0 (ac 0 Block im' doc) x
+            px <- pretty0 (ac Annotation Block im' doc) x
             -- this makes sure we get proper indentation if `px` spills onto
             -- multiple lines, since `do` introduces layout block
-            let indent = PP.Width (if soft then 2 else 0) + (if soft && p < 3 then 1 else 0)
-            pure . paren (p >= 3) $
+            let indent = PP.Width (if soft then 2 else 0) + (if soft && p < Application then 1 else 0)
+            pure . paren (p > Control) $
               fmt S.ControlKeyword "do" `hang` PP.lines (uses <> [PP.indentNAfterNewline indent px])
       List' xs -> do
         let listLink p = fmt (S.TypeReference Type.listRef) p
         let comma = listLink ", " `PP.orElse` ("\n" <> listLink ", ")
-        pelems <- traverse (fmap (PP.indentNAfterNewline 2) . pretty0 (ac 0 Normal im doc)) xs
+        pelems <- traverse (fmap (PP.indentNAfterNewline 2) . pretty0 (ac Annotation Normal im doc)) xs
         let open = listLink "[" `PP.orElse` listLink "[ "
         let close = listLink "]" `PP.orElse` ("\n" <> listLink "]")
         pure $ PP.group (open <> PP.sep comma pelems <> close)
       If' cond t f ->
         do
-          pcond <- pretty0 (ac 2 Block im doc) cond
-          pt <- pretty0 (ac 0 Block im doc) t
-          pf <- pretty0 (ac 0 Block im doc) f
-          pure . paren (p >= 2) $
+          pcond <- pretty0 (ac Control Block im doc) cond
+          pt <- pretty0 (ac Annotation Block im doc) t
+          pf <- pretty0 (ac Annotation Block im doc) f
+          pure . paren (p >= Control) $
             if PP.isMultiLine pcond
               then
                 PP.lines
@@ -360,19 +369,19 @@ pretty0
       --   blah
       -- See `isDestructuringBind` definition.
       Match' scrutinee cs@[MatchCase pat guard (AbsN' vs body)]
-        | p <= 2 && isDestructuringBind scrutinee cs -> do
+        | p <= Control && isDestructuringBind scrutinee cs -> do
             n <- getPPE
             let letIntro = case bc of
                   Block -> id
                   Normal -> \x -> fmt S.ControlKeyword "let" `PP.hang` x
             lhs <- do
-              let (lhs, _) = prettyPattern n (ac 0 Block im doc) 10 vs pat
+              let (lhs, _) = prettyPattern n (ac Annotation Block im doc) Application vs pat
               guard' <- printGuard guard
               pure $ PP.group lhs `PP.hang` guard'
             let eq = fmt S.BindingEquals "="
-            rhs <- pretty0 (ac (-1) Block im doc) scrutinee
+            rhs <- pretty0 (ac Bottom Block im doc) scrutinee
             letIntro <$> do
-              prettyBody <- pretty0 (ac (-1) Block im doc) body
+              prettyBody <- pretty0 (ac Bottom Block im doc) body
               pure $
                 PP.lines
                   [ (lhs <> eq) `PP.hang` rhs,
@@ -382,13 +391,13 @@ pretty0
           printGuard Nothing = pure mempty
           printGuard (Just g') = do
             let (_, g) = ABT.unabs g'
-            prettyg <- pretty0 (ac 2 Normal im doc) g
+            prettyg <- pretty0 (ac Control Normal im doc) g
             pure $ fmt S.DelimiterChar "| " <> prettyg
       Match' scrutinee branches ->
         do
-          ps <- pretty0 (ac 2 Normal im doc) scrutinee
+          ps <- pretty0 (ac Control Normal im doc) scrutinee
           pbs <- printCase im doc (arity1Branches branches) -- don't print with `cases` syntax
-          pure . paren (p >= 2) $
+          pure . paren (p >= Control) $
             if PP.isMultiLine ps
               then
                 PP.lines
@@ -396,7 +405,7 @@ pretty0
                     fmt S.ControlKeyword " with" `PP.hang` pbs
                   ]
               else (fmt S.ControlKeyword "match " <> ps <> fmt S.ControlKeyword " with") `PP.hang` pbs
-      Apps' f args -> paren (p >= 10) <$> (PP.hang <$> goNormal 9 f <*> PP.spacedTraverse (goNormal 10) args)
+      Apps' f args -> paren (p >= Application) <$> (PP.hang <$> goNormal (InfixOp Highest) f <*> PP.spacedTraverse (goNormal Application) args)
       t -> pure $ l "error: " <> l (show t)
     where
       goNormal prec tm = pretty0 (ac prec Normal im doc) tm
@@ -416,6 +425,20 @@ pretty0
                   Ref' r -> isSymbolic $ PrettyPrintEnv.termName n (Referent.Ref r)
                   Var' v -> isSymbolic $ HQ.unsafeFromVar v
                   _ -> False
+                -- Gets the precedence of an infix operator, if it has one.
+                termPrecedence :: Term3 v PrintAnnotation -> Maybe Precedence
+                termPrecedence = \case
+                  Ref' r ->
+                    HQ.toName (PrettyPrintEnv.termName n (Referent.Ref r))
+                      >>= operatorPrecedence
+                        . NameSegment.toEscapedText
+                        . Name.lastSegment
+                  Var' v ->
+                    HQ.toName (HQ.unsafeFromVar v)
+                      >>= operatorPrecedence
+                        . NameSegment.toEscapedText
+                        . Name.lastSegment
+                  _ -> Nothing
             case (term, binaryOpsPred) of
               (DD.Doc, _)
                 | doc == MaybeDoc ->
@@ -426,27 +449,27 @@ pretty0
                 let conRef = DD.pairCtorRef
                 name <- elideFQN im <$> applyPPE2 PrettyPrintEnv.termName conRef
                 let pair = parenIfInfix name ic $ styleHashQualified'' (fmt (S.TermReference conRef)) name
-                x' <- pretty0 (ac 10 Normal im doc) x
-                pure . paren (p >= 10) $
+                x' <- pretty0 (ac Application Normal im doc) x
+                pure . paren (p >= Application) $
                   pair
                     `PP.hang` PP.spaced [x', fmt (S.TermReference DD.unitCtorRef) "()"]
               (TupleTerm' xs, _) -> do
                 let tupleLink p = fmt (S.TypeReference DD.pairRef) p
                 let comma = tupleLink ", " `PP.orElse` ("\n" <> tupleLink ", ")
-                pelems <- traverse (fmap (PP.indentNAfterNewline 2) . goNormal 0) xs
+                pelems <- traverse (fmap (PP.indentNAfterNewline 2) . goNormal Annotation) xs
                 let clist = PP.sep comma pelems
                 let open = tupleLink "(" `PP.orElse` tupleLink "( "
                 let close = tupleLink ")" `PP.orElse` ("\n" <> tupleLink ")")
                 pure $ PP.group (open <> clist <> close)
               (App' f@(Builtin' "Any.Any") arg, _) ->
-                paren (p >= 10) <$> (PP.hang <$> goNormal 9 f <*> goNormal 10 arg)
+                paren (p >= Application) <$> (PP.hang <$> goNormal (InfixOp Highest) f <*> goNormal Application arg)
               (DD.Rewrites' rs, _) -> do
                 let kw = fmt S.ControlKeyword "@rewrite"
                     arr = fmt S.ControlKeyword "==>"
                     control = fmt S.ControlKeyword
-                    sub kw lhs = PP.sep " " <$> sequence [pure $ control kw, goNormal 0 lhs, pure arr]
-                    go (DD.RewriteTerm' lhs rhs) = PP.hang <$> sub "term" lhs <*> goNormal 0 rhs
-                    go (DD.RewriteCase' lhs rhs) = PP.hang <$> sub "case" lhs <*> goNormal 0 rhs
+                    sub kw lhs = PP.sep " " <$> sequence [pure $ control kw, goNormal Annotation lhs, pure arr]
+                    go (DD.RewriteTerm' lhs rhs) = PP.hang <$> sub "term" lhs <*> goNormal Annotation rhs
+                    go (DD.RewriteCase' lhs rhs) = PP.hang <$> sub "case" lhs <*> goNormal Annotation rhs
                     go (DD.RewriteSignature' vs lhs rhs) = do
                       lhs <- TypePrinter.pretty0 im 0 lhs
                       PP.hang (PP.sep " " (stuff lhs)) <$> TypePrinter.pretty0 im 0 rhs
@@ -456,17 +479,32 @@ pretty0
                             <> [fmt S.Var (PP.text (Var.name v)) | v <- vs]
                             <> (if null vs then [] else [fmt S.TypeOperator "."])
                             <> [lhs, arr]
-                    go tm = goNormal 10 tm
+                    go tm = goNormal Application tm
                 PP.hang kw <$> fmap PP.lines (traverse go rs)
               (Bytes' bs, _) ->
                 pure $ PP.group $ fmt S.BytesLiteral "0xs" <> PP.shown (Bytes.fromWord8s (map fromIntegral bs))
-              BinaryAppsPred' apps lastArg -> do
-                prettyLast <- pretty0 (ac 3 Normal im doc) lastArg
-                prettyApps <- binaryApps apps prettyLast
-                pure $ paren (p >= 3) prettyApps
-              -- Note that && and || are at the same precedence, which can cause
-              -- confusion, so for clarity we do not want to elide the parentheses in a
-              -- case like `(x || y) && z`.
+              BinaryAppPred' f a b -> do
+                let prec = termPrecedence f
+                prettyF <- pretty0 (AmbientContext Application Normal Infix im doc False) f
+                prettyA <- pretty0 (ac (fromMaybe (InfixOp Lowest) prec) Normal im doc) a
+                prettyB <- pretty0 (ac (fromMaybe (InfixOp Highest) prec) Normal im doc) b
+                pure . parenNoGroup (p > fromMaybe (InfixOp Lowest) prec) $
+                  (prettyA <> " " <> prettyF <> " " <> prettyB) `PP.orElse` (prettyA `PP.hangUngrouped` (PP.column2 [(prettyF, prettyB)]))
+              (And' a b, _) -> do
+                let prec = operatorPrecedence "&&"
+                    prettyF = fmt S.ControlKeyword "&&"
+                prettyA <- pretty0 (ac (fromMaybe (InfixOp Lowest) prec) Normal im doc) a
+                prettyB <- pretty0 (ac (fromMaybe (InfixOp Highest) prec) Normal im doc) b
+                pure . parenNoGroup (p > fromMaybe (InfixOp Lowest) prec) $
+                  (prettyA <> " " <> prettyF <> " " <> prettyB) `PP.orElse` (prettyA `PP.hangUngrouped` (PP.column2 [(prettyF, prettyB)]))
+              (Or' a b, _) -> do
+                let prec = operatorPrecedence "||"
+                    prettyF = fmt S.ControlKeyword "||"
+                prettyA <- pretty0 (ac (fromMaybe (InfixOp Lowest) prec) Normal im doc) a
+                prettyB <- pretty0 (ac (fromMaybe (InfixOp Highest) prec) Normal im doc) b
+                pure . parenNoGroup (p > fromMaybe (InfixOp Lowest) prec) $
+                  PP.group (prettyA <> " " <> prettyF <> " " <> prettyB)
+                    `PP.orElse` (prettyA `PP.hangUngrouped` prettyF <> " " <> prettyB)
               {-
               When a delayed computation block is passed to a function as the last argument
               in a context where the ambient precedence is low enough, we can elide parentheses
@@ -488,52 +526,36 @@ pretty0
                     ...)
               -}
               (App' x (Constructor' (ConstructorReference DD.UnitRef 0)), _) | isLeaf x -> do
-                px <- pretty0 (ac (if isBlock x then 0 else 9) Normal im doc) x
-                pure . paren (p >= 11 || isBlock x && p >= 3) $
+                px <- pretty0 (ac (if isBlock x then Annotation else InfixOp Highest) Normal im doc) x
+                pure . paren (p >= Prefix || isBlock x && p >= (InfixOp Lowest)) $
                   px <> fmt S.Unit (l "()")
               (Apps' f (unsnoc -> Just (args, lastArg)), _)
                 | isSoftHangable lastArg -> do
-                    fun <- goNormal 9 f
-                    args' <- traverse (goNormal 10) args
-                    lastArg' <- goNormal 0 lastArg
+                    fun <- goNormal (InfixOp Highest) f
+                    args' <- traverse (goNormal Application) args
+                    lastArg' <- goNormal Annotation lastArg
                     let softTab = PP.softbreak <> ("" `PP.orElse` "  ")
-                    pure . paren (p >= 3) $
+                    pure . paren (p >= (InfixOp Lowest)) $
                       PP.group (PP.group (PP.group (PP.sep softTab (fun : args') <> softTab)) <> lastArg')
-              (Ands' xs lastArg, _) ->
-                paren (p >= 10) <$> do
-                  lastArg' <- pretty0 (ac 10 Normal im doc) lastArg
-                  booleanOps (fmt S.ControlKeyword "&&") xs lastArg'
-              (Ors' xs lastArg, _) ->
-                paren (p >= 10) <$> do
-                  lastArg' <- pretty0 (ac 10 Normal im doc) lastArg
-                  booleanOps (fmt S.ControlKeyword "||") xs lastArg'
               _other -> case (term, nonForcePred) of
-                OverappliedBinaryAppPred' f a b r
-                  | binaryOpsPred f ->
-                      -- Special case for overapplied binary op
-                      do
-                        prettyB <- pretty0 (ac 3 Normal im doc) b
-                        prettyR <- PP.spacedTraverse (pretty0 (ac 10 Normal im doc)) r
-                        prettyA <- binaryApps [(f, a)] prettyB
-                        pure $ paren True $ PP.hang prettyA prettyR
                 AppsPred' f args ->
-                  paren (p >= 10) <$> do
-                    f' <- pretty0 (ac 10 Normal im doc) f
-                    args' <- PP.spacedTraverse (pretty0 (ac 10 Normal im doc)) args
+                  paren (p >= Application) <$> do
+                    f' <- pretty0 (ac Application Normal im doc) f
+                    args' <- PP.spacedTraverse (pretty0 (ac Application Normal im doc)) args
                     pure $ f' `PP.hang` args'
                 _other -> case (term, \v -> nonUnitArgPred v && not (isDelay term)) of
                   (LamsNamedMatch' [] branches, _) -> do
                     pbs <- printCase im doc branches
-                    pure . paren (p >= 3) $
+                    pure . paren (p >= InfixOp Lowest) $
                       PP.group (fmt S.ControlKeyword "cases") `PP.hang` pbs
                   LamsNamedPred' vs body -> do
-                    prettyBody <- pretty0 (ac 2 Normal im doc) body
+                    prettyBody <- pretty0 (ac Control Normal im doc) body
                     let hang = case body of
                           Delay' (Lets' _ _) -> PP.softHang
                           Lets' _ _ -> PP.softHang
                           Match' _ _ -> PP.softHang
                           _ -> PP.hang
-                    pure . paren (p >= 3) $
+                    pure . paren (p >= InfixOp Lowest) $
                       PP.group (varList vs <> fmt S.ControlKeyword " ->") `hang` prettyBody
                   _other -> go term
 
@@ -553,14 +575,14 @@ pretty0
       printLet elideUnit sc bs e im uses = do
         bs <- traverse printBinding bs
         body <- body e
-        pure . paren (sc /= Block && p >= 12) . letIntro $ PP.lines (uses <> bs <> body)
+        pure . paren (sc /= Block && p >= Top) . letIntro $ PP.lines (uses <> bs <> body)
         where
           body (Constructor' (ConstructorReference DD.UnitRef 0)) | elideUnit = pure []
-          body e = (: []) <$> pretty0 (ac 0 Normal im doc) e
+          body e = (: []) <$> pretty0 (ac Annotation Normal im doc) e
           printBinding (v, binding) =
             if Var.isAction v
-              then pretty0 (ac (-1) Normal im doc) binding
-              else renderPrettyBinding <$> prettyBinding0' (ac (-1) Normal im doc) (HQ.unsafeFromVar v) binding
+              then pretty0 (ac Bottom Normal im doc) binding
+              else renderPrettyBinding <$> prettyBinding0' (ac Bottom Normal im doc) (HQ.unsafeFromVar v) binding
           letIntro = case sc of
             Block -> id
             Normal -> \x -> fmt S.ControlKeyword "let" `PP.hang` x
@@ -573,64 +595,12 @@ pretty0
       nonUnitArgPred :: (Var v) => v -> Bool
       nonUnitArgPred v = Var.name v /= "()"
 
-      -- Render a binary infix operator sequence, like [(a2, f2), (a1, f1)],
-      -- meaning (a1 `f1` a2) `f2` (a3 rendered by the caller), producing
-      -- "a1 `f1` a2 `f2`".  Except the operators are all symbolic, so we won't
-      -- produce any backticks.  We build the result out from the right,
-      -- starting at `f2`.
-      binaryApps ::
-        [(Term3 v PrintAnnotation, Term3 v PrintAnnotation)] ->
-        Pretty SyntaxText ->
-        m (Pretty SyntaxText)
-      binaryApps xs last =
-        do
-          ps <- join <$> traverse (uncurry r) (reverse xs)
-          let unbroken = PP.spaced (ps <> [last])
-              broken = PP.hang (head ps) . PP.column2 . psCols $ tail ps <> [last]
-          pure (unbroken `PP.orElse` broken)
-        where
-          psCols ps = case take 2 ps of
-            [x, y] -> (x, y) : psCols (drop 2 ps)
-            [x] -> [(x, "")]
-            [] -> []
-            _ -> undefined
-          r a f =
-            sequenceA
-              [ pretty0 (ac (if isBlock a then 12 else 3) Normal im doc) a,
-                pretty0 (AmbientContext 10 Normal Infix im doc False) f
-              ]
-
-      -- Render sequence of infix &&s or ||s, like [x2, x1],
-      -- meaning (x1 && x2) && (x3 rendered by the caller), producing
-      -- "x1 && x2 &&". The result is built from the right.
-      booleanOps ::
-        Pretty SyntaxText ->
-        [Term3 v PrintAnnotation] ->
-        Pretty SyntaxText ->
-        m (Pretty SyntaxText)
-      booleanOps op xs last = do
-        ps <- join <$> traverse r (reverse xs)
-        let unbroken = PP.spaced (ps <> [last])
-            broken = PP.hang (head ps) . PP.column2 . psCols $ tail ps <> [last]
-        pure (unbroken `PP.orElse` broken)
-        where
-          psCols ps = case take 2 ps of
-            [x, y] -> (x, y) : psCols (drop 2 ps)
-            [x] -> [(x, "")]
-            [] -> []
-            _ -> undefined
-          r a =
-            sequence
-              [ pretty0 (ac (if isBlock a then 12 else 10) Normal im doc) a,
-                pure op
-              ]
-
 prettyPattern ::
   forall v loc.
   (Var v) =>
   PrettyPrintEnv ->
   AmbientContext ->
-  Int ->
+  Precedence ->
   [v] ->
   Pattern loc ->
   (Pretty SyntaxText, [v])
@@ -657,7 +627,7 @@ prettyPattern n c@AmbientContext {imports = im} p vs patt = case patt of
   Pattern.Text _ t -> (fmt S.TextLiteral $ l $ show t, vs)
   TuplePattern pats
     | length pats /= 1 ->
-        let (pats_printed, tail_vs) = patterns (-1) vs pats
+        let (pats_printed, tail_vs) = patterns Bottom vs pats
          in (PP.parenthesizeCommas pats_printed, tail_vs)
   Pattern.Constructor _ ref [] ->
     (styleHashQualified'' (fmt $ S.TermReference conRef) name, vs)
@@ -665,10 +635,10 @@ prettyPattern n c@AmbientContext {imports = im} p vs patt = case patt of
       name = elideFQN im $ PrettyPrintEnv.termName n conRef
       conRef = Referent.Con ref CT.Data
   Pattern.Constructor _ ref pats ->
-    let (pats_printed, tail_vs) = patternsSep 10 PP.softbreak vs pats
+    let (pats_printed, tail_vs) = patternsSep Application PP.softbreak vs pats
         name = elideFQN im $ PrettyPrintEnv.termName n conRef
         conRef = Referent.Con ref CT.Data
-     in ( paren (p >= 10) $
+     in ( paren (p >= Application) $
             styleHashQualified'' (fmt $ S.TermReference conRef) name
               `PP.hang` pats_printed,
           tail_vs
@@ -676,15 +646,15 @@ prettyPattern n c@AmbientContext {imports = im} p vs patt = case patt of
   Pattern.As _ pat ->
     case vs of
       (v : tail_vs) ->
-        let (printed, eventual_tail) = prettyPattern n c 11 tail_vs pat
-         in (paren (p >= 11) (fmt S.Var (l $ Var.nameStr v) <> fmt S.DelimiterChar (l "@") <> printed), eventual_tail)
+        let (printed, eventual_tail) = prettyPattern n c Prefix tail_vs pat
+         in (paren (p >= Prefix) (fmt S.Var (l $ Var.nameStr v) <> fmt S.DelimiterChar (l "@") <> printed), eventual_tail)
       _ -> error "prettyPattern: Expected at least one var"
   Pattern.EffectPure _ pat ->
-    let (printed, eventual_tail) = prettyPattern n c (-1) vs pat
+    let (printed, eventual_tail) = prettyPattern n c Bottom vs pat
      in (PP.sep " " [fmt S.DelimiterChar "{", printed, fmt S.DelimiterChar "}"], eventual_tail)
   Pattern.EffectBind _ ref pats k_pat ->
-    let (pats_printed, tail_vs) = patternsSep 10 PP.softbreak vs pats
-        (k_pat_printed, eventual_tail) = prettyPattern n c 0 tail_vs k_pat
+    let (pats_printed, tail_vs) = patternsSep Application PP.softbreak vs pats
+        (k_pat_printed, eventual_tail) = prettyPattern n c Annotation tail_vs k_pat
         name = elideFQN im $ PrettyPrintEnv.termName n conRef
         conRef = Referent.Con ref CT.Effect
      in ( PP.group
@@ -700,16 +670,16 @@ prettyPattern n c@AmbientContext {imports = im} p vs patt = case patt of
           eventual_tail
         )
   Pattern.SequenceLiteral _ pats ->
-    let (pats_printed, tail_vs) = patternsSep (-1) (fmt S.DelimiterChar ", ") vs pats
+    let (pats_printed, tail_vs) = patternsSep Bottom (fmt S.DelimiterChar ", ") vs pats
      in (fmt S.DelimiterChar "[" <> pats_printed <> fmt S.DelimiterChar "]", tail_vs)
   Pattern.SequenceOp _ l op r ->
     let (pl, lvs) = prettyPattern n c p vs l
-        (pr, rvs) = prettyPattern n c (p + 1) lvs r
+        (pr, rvs) = prettyPattern n c (increment p) lvs r
         f i s = (paren (p >= i) (pl <> " " <> fmt (S.Op op) s <> " " <> pr), rvs)
      in case op of
-          Pattern.Cons -> f 0 "+:"
-          Pattern.Snoc -> f 0 ":+"
-          Pattern.Concat -> f 0 "++"
+          Pattern.Cons -> f Annotation "+:"
+          Pattern.Snoc -> f Annotation ":+"
+          Pattern.Concat -> f Annotation "++"
   where
     l :: (IsString s) => String -> s
     l = fromString
@@ -792,14 +762,14 @@ printCase im doc ms0 =
     grid = traverse go ms
     patLhs env vs pats =
       case pats of
-        [pat] -> PP.group (fst (prettyPattern env (ac 0 Block im doc) (-1) vs pat))
+        [pat] -> PP.group (fst (prettyPattern env (ac Annotation Block im doc) Bottom vs pat))
         pats -> PP.group
           . PP.sep (PP.indentAfterNewline "  " $ "," <> PP.softbreak)
           . (`evalState` vs)
           . for pats
           $ \pat -> do
             vs <- State.get
-            let (p, rem) = prettyPattern env (ac 0 Block im doc) (-1) vs pat
+            let (p, rem) = prettyPattern env (ac Annotation Block im doc) Bottom vs pat
             State.put rem
             pure p
     arrow = fmt S.ControlKeyword "->"
@@ -822,8 +792,8 @@ printCase im doc ms0 =
           -- strip off any Abs-chain around the guard, guard variables are rendered
           -- like any other variable, ex: case Foo x y | x < y -> ...
           PP.spaceIfNeeded (fmt S.DelimiterChar "|")
-            <$> pretty0 (ac 2 Normal im doc) g
-        printBody = pretty0 (ac 0 Block im doc)
+            <$> pretty0 (ac Control Normal im doc) g
+        printBody = pretty0 (ac Annotation Block im doc)
 
 -- A pretty term binding, split into the type signature (possibly empty) and the term.
 data PrettyBinding = PrettyBinding
@@ -882,7 +852,7 @@ prettyBinding_ ::
   Term2 v at ap v a ->
   Pretty SyntaxText
 prettyBinding_ go ppe n tm =
-  runPretty (avoidShadowing tm ppe) . fmap go $ prettyBinding0 (ac (-2) Block Map.empty MaybeDoc) n tm
+  runPretty (avoidShadowing tm ppe) . fmap go $ prettyBinding0 (ac Basement Block Map.empty MaybeDoc) n tm
 
 prettyBinding' ::
   (Var v) =>
@@ -1062,8 +1032,11 @@ prettyDoc n im term =
     spaceUnlessBroken = PP.orElse " " ""
 
 paren :: Bool -> Pretty SyntaxText -> Pretty SyntaxText
-paren True s = PP.group $ fmt S.Parenthesis "(" <> s <> fmt S.Parenthesis ")"
-paren False s = PP.group s
+paren b s = PP.group $ parenNoGroup b s
+
+parenNoGroup :: Bool -> Pretty SyntaxText -> Pretty SyntaxText
+parenNoGroup True s = fmt S.Parenthesis "(" <> s <> fmt S.Parenthesis ")"
+parenNoGroup False s = s
 
 parenIfInfix ::
   HQ.HashQualified Name ->
@@ -1080,12 +1053,12 @@ isSymbolic =
   maybe False Name.isSymboly . HQ.toName
 
 emptyAc :: AmbientContext
-emptyAc = ac (-1) Normal Map.empty MaybeDoc
+emptyAc = ac Bottom Normal Map.empty MaybeDoc
 
 emptyBlockAc :: AmbientContext
-emptyBlockAc = ac (-1) Block Map.empty MaybeDoc
+emptyBlockAc = ac Bottom Block Map.empty MaybeDoc
 
-ac :: Int -> BlockContext -> Imports -> DocLiteralContext -> AmbientContext
+ac :: Precedence -> BlockContext -> Imports -> DocLiteralContext -> AmbientContext
 ac prec bc im doc = AmbientContext prec bc NonInfix im doc False
 
 fmt :: S.Element r -> Pretty (S.SyntaxText' r) -> Pretty (S.SyntaxText' r)
@@ -1578,13 +1551,15 @@ isDestructuringBind scrutinee [MatchCase pat _ (ABT.AbsN' vs _)] =
       Pattern.Unbound _ -> False
 isDestructuringBind _ _ = False
 
-isBlock :: (Ord v) => Term2 vt at ap v a -> Bool
+isBlock :: (Var v, Ord v) => Term2 vt at ap v a -> Bool
 isBlock tm =
   case tm of
     If' {} -> True
     Handle' _ _ -> True
     Match' _ _ -> True
     LetBlock _ _ -> True
+    DDelay' _ -> True
+    Delay' _ -> True
     _ -> False
 
 pattern LetBlock ::
@@ -2169,7 +2144,3 @@ isLeaf (Constructor' {}) = True
 isLeaf (Request' {}) = True
 isLeaf (Ref' {}) = True
 isLeaf _ = False
-
--- | Indicates this is the RHS of a top-level definition.
-isTopLevelPrecedence :: Int -> Bool
-isTopLevelPrecedence i = i == -2
diff --git a/unison-core/src/Unison/Term.hs b/unison-core/src/Unison/Term.hs
index 92cb5ccf31..1c74cb6d1c 100644
--- a/unison-core/src/Unison/Term.hs
+++ b/unison-core/src/Unison/Term.hs
@@ -602,6 +602,13 @@ pattern BinaryAppsPred' ::
   (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
 pattern BinaryAppsPred' apps lastArg <- (unBinaryAppsPred -> Just (apps, lastArg))
 
+pattern BinaryAppPred' ::
+  Term2 vt at ap v a ->
+  Term2 vt at ap v a ->
+  Term2 vt at ap v a ->
+  (Term2 vt at ap v a, Term2 vt at ap v a -> Bool)
+pattern BinaryAppPred' f arg1 arg2 <- (unBinaryAppPred -> Just (f, arg1, arg2))
+
 pattern OverappliedBinaryAppPred' ::
   Term2 vt at ap v a ->
   Term2 vt at ap v a ->
@@ -1168,12 +1175,23 @@ unBinaryAppsPred ::
       ],
       Term2 vt at ap v a
     )
-unBinaryAppsPred (t, pred) = case unBinaryApp t of
-  Just (f, x, y) | pred f -> case unBinaryAppsPred (x, pred) of
+unBinaryAppsPred (t, pred) = case unBinaryAppPred (t, pred) of
+  Just (f, x, y) -> case unBinaryAppsPred (x, pred) of
     Just (as, xLast) -> Just ((xLast, f) : as, y)
     Nothing -> Just ([(x, f)], y)
   _ -> Nothing
 
+unBinaryAppPred ::
+  (Term2 vt at ap v a, Term2 vt at ap v a -> Bool) ->
+  Maybe
+    ( Term2 vt at ap v a,
+      Term2 vt at ap v a,
+      Term2 vt at ap v a
+    )
+unBinaryAppPred (t, pred) = case unBinaryApp t of
+  Just (f, x, y) | pred f -> Just (f, x, y)
+  _ -> Nothing
+
 unLams' ::
   Term2 vt at ap v a -> Maybe ([v], Term2 vt at ap v a)
 unLams' t = unLamsPred' (t, const True)
diff --git a/unison-src/transcripts-round-trip/main.output.md b/unison-src/transcripts-round-trip/main.output.md
index def5266331..a2624eaf9d 100644
--- a/unison-src/transcripts-round-trip/main.output.md
+++ b/unison-src/transcripts-round-trip/main.output.md
@@ -24,7 +24,7 @@ scratch/a1> edit 1-1000
 
   ☝️
   
-  I added 110 definitions to the top of scratch.u
+  I added 111 definitions to the top of scratch.u
   
   You can edit them there, then run `update` to replace the
   definitions currently in this namespace.
@@ -122,11 +122,48 @@ ex3a =
   a = do qux3 + qux3
   ()
 
+fixity : '('())
+fixity =
+  do
+    use Nat * +
+    (===) = (==)
+    f <| x = f x
+    (<<) f g x = f (g x)
+    (>>) f g x = g (f x)
+    id x = x
+    (do
+      (%) = Nat.mod
+      ($) = (+)
+      c = 1 * (2 + 3) * 4
+      d = true && (false || true)
+      z = true || false && true
+      e = 1 + 2 >= 3 + 4
+      f = 9 % 2 === 0
+      g = 0 == 9 % 2
+      h = 2 * (10 $ 20)
+      i1 = 1 * 2 $ (3 * 4) $ 5
+      i2 = (1 * 2 $ 3) * 4 $ 5
+      oo = (2 * 10 $ 20) * 30 $ 40
+      ffffffffffffffffffff x = x + 1
+      gg x = x * 2
+      j = 10 |> ffffffffffffffffffff |> gg |> gg |> gg |> gg |> gg
+      k = ffffffffffffffffffff << gg << ffffffffffffffffffff <| 10
+      l = 10 |> (ffffffffffffffffffff >> gg >> ffffffffffffffffffff)
+      zzz = 1 + 2 * 3 < 4 + 5 * 6 && 7 + 8 * 9 > 10 + 11 * 12
+      zz =
+        (1 * 2 + 3 * 3 < 4 + 5 * 6 && 7 + 8 * 9 > 10 + 11 * 12)
+          === (1 + 3 * 3 < 4 + 5 * 6 && 7 + 8 * 9 > 10 + 11 * 12)
+      zzzz =
+        1 * 2 + 3 * 3 < 4 + 5 * 6
+          && 7 + 8 * 9 > 10 + 11 * 12 === 1 + 3 * 3 < 4 + 5 * 6
+          && 7 + 8 * 9 > 10 + 11 * 12
+      ())
+      |> id
+
 fix_1035 : Text
 fix_1035 =
   use Text ++
-  "aaaaaaaaaaaaaaaaaaaaaa"
-    ++ "bbbbbbbbbbbbbbbbbbbbbb"
+  "aaaaaaaaaaaaaaaaaaaaaa" ++ "bbbbbbbbbbbbbbbbbbbbbb"
     ++ "cccccccccccccccccccccc"
     ++ "dddddddddddddddddddddd"
 
@@ -590,8 +627,8 @@ softhang22 = softhang2 [0, 1, 2, 3, 4, 5] cases
 
 softhang23 : 'Nat
 softhang23 = do
-  use Nat +
   catchAll do
+    use Nat +
     x = 1
     y = 2
     x + y
@@ -627,15 +664,7 @@ softhang28 =
     n ->
       forkAt
         0
-        (n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
-          Nat.+ n
+        (n Nat.+ n Nat.+ n Nat.+ n Nat.+ n Nat.+ n Nat.+ n Nat.+ n Nat.+ n
           Nat.+ n
           Nat.+ n)
 
@@ -655,18 +684,7 @@ softhang_b x =
     a = 1
     b = 2
     softhang
-      (100
-      + 200
-      + 300
-      + 400
-      + 500
-      + 600
-      + 700
-      + 800
-      + 900
-      + 1000
-      + 1100
-      + 1200
+      (100 + 200 + 300 + 400 + 500 + 600 + 700 + 800 + 900 + 1000 + 1100 + 1200
       + 1300
       + 1400
       + 1500)
diff --git a/unison-src/transcripts-round-trip/reparses-with-same-hash.u b/unison-src/transcripts-round-trip/reparses-with-same-hash.u
index 5d75eff442..8aac55c727 100644
--- a/unison-src/transcripts-round-trip/reparses-with-same-hash.u
+++ b/unison-src/transcripts-round-trip/reparses-with-same-hash.u
@@ -594,3 +594,33 @@ fix_4729c = {{
       }}) {{ This is a callout with a title }}
   ```
 }}
+
+fixity = do 
+  (===) = (##Universal.==)
+  (<|) f x = f x
+  (<<) f g x = f (g x)
+  (>>) f g x = g (f x)
+  id x = x
+  (do
+    (%) = Nat.mod
+    ($) = (Nat.+)
+    c = 1 * (2 + 3) * 4
+    d = true && let false || true
+    z = true || false && true
+    e = 1 + 2 >= (3 + 4)
+    f = 9 % 2 === 0
+    g = 0 == (9 % 2)
+    h = 2 * (10 $ 20)
+    i1 = 1 * 2 $ (3 * 4) $ 5
+    i2 = 1 * 2 $ 3 * 4 $ 5
+    oo = (((2 * 10) $ 20) * 30) $ 40
+    ffffffffffffffffffff x = x + 1
+    gg x = x * 2
+    j = 10 |> ffffffffffffffffffff |> gg |> gg |> gg |> gg |> gg
+    k = ffffffffffffffffffff << gg << ffffffffffffffffffff <| 10
+    l = 10 |> (ffffffffffffffffffff >> gg >> ffffffffffffffffffff)
+    zzz = ((1 + (2 * 3)) < (4 + (5 * 6))) && ((((7 + (8 * 9)) > ((10 + (11 * 12))))))
+    zz = (1 * 2 + 3 * 3 < (4 + 5 * 6) && ((7 + 8 * 9) > (10 + 11 * 12))) === (1 + 3 * 3 < (4 + 5 * 6) && (7 + 8 * 9 > (10 + 11 * 12)))
+    zzzz = 1 * 2 + 3 * 3 < 4 + 5 * 6 && 7 + 8 * 9 > 10 + 11 * 12 === 1 + 3 * 3 < 4 + 5 * 6 && 7 + 8 * 9 > 10 + 11 * 12
+    ()
+    ) |> id
diff --git a/unison-src/transcripts/boolean-op-pretty-print-2819.output.md b/unison-src/transcripts/boolean-op-pretty-print-2819.output.md
index b840f4bbc0..1609f89a39 100644
--- a/unison-src/transcripts/boolean-op-pretty-print-2819.output.md
+++ b/unison-src/transcripts/boolean-op-pretty-print-2819.output.md
@@ -31,7 +31,7 @@ scratch/main> view hangExample
 
   hangExample : Boolean
   hangExample =
-    ("a long piece of text to hang the line" == "")
-      && ("a long piece of text to hang the line" == "")
+    "a long piece of text to hang the line" == ""
+      && "a long piece of text to hang the line" == ""
 
 ```
diff --git a/unison-src/transcripts/builtins.md b/unison-src/transcripts/builtins.md
index 6834b85eb1..5f6a154fac 100644
--- a/unison-src/transcripts/builtins.md
+++ b/unison-src/transcripts/builtins.md
@@ -170,17 +170,17 @@ scratch/main> add
 ```unison:hide
 test> Boolean.tests.orTable =
       checks [
-        true || true == true,
-        true || false == true,
-        false || true == true,
-        false || false == false
+        (true || true) == true,
+        (true || false) == true,
+        (false || true) == true,
+        (false || false) == false
       ]
 test> Boolean.tests.andTable =
       checks [
-        true && true == true,
-        false && true == false,
-        true && false == false,
-        false && false == false
+        (true && true) == true,
+        (false && true) == false,
+        (true && false) == false,
+        (false && false) == false
       ]
 test> Boolean.tests.notTable =
       checks [
diff --git a/unison-src/transcripts/builtins.output.md b/unison-src/transcripts/builtins.output.md
index 3a4538f30a..efa1f53afa 100644
--- a/unison-src/transcripts/builtins.output.md
+++ b/unison-src/transcripts/builtins.output.md
@@ -157,17 +157,17 @@ test> Nat.tests.conversions =
 ``` unison
 test> Boolean.tests.orTable =
       checks [
-        true || true == true,
-        true || false == true,
-        false || true == true,
-        false || false == false
+        (true || true) == true,
+        (true || false) == true,
+        (false || true) == true,
+        (false || false) == false
       ]
 test> Boolean.tests.andTable =
       checks [
-        true && true == true,
-        false && true == false,
-        true && false == false,
-        false && false == false
+        (true && true) == true,
+        (false && true) == false,
+        (true && false) == false,
+        (false && false) == false
       ]
 test> Boolean.tests.notTable =
       checks [
diff --git a/unison-src/transcripts/dependents-dependencies-debugfile.output.md b/unison-src/transcripts/dependents-dependencies-debugfile.output.md
index a02c491694..f7398fd480 100644
--- a/unison-src/transcripts/dependents-dependencies-debugfile.output.md
+++ b/unison-src/transcripts/dependents-dependencies-debugfile.output.md
@@ -23,7 +23,7 @@ scratch/main> debug.file
   type outside.A#6l6krl7n4l
   type outside.B#eo6rj0lj1b
   inside.p#htoo5rnb54
-  inside.q#vtdbqaojv6
+  inside.q#1mqcoh3tnk
   inside.r#nkgohbke6n
   outside.c#f3lgjvjqoo
   outside.d#ukd7tu6kds
diff --git a/unison-syntax/src/Unison/Syntax/Parser.hs b/unison-syntax/src/Unison/Syntax/Parser.hs
index 822fc46fcb..dd9eb974ec 100644
--- a/unison-syntax/src/Unison/Syntax/Parser.hs
+++ b/unison-syntax/src/Unison/Syntax/Parser.hs
@@ -15,6 +15,7 @@ module Unison.Syntax.Parser
     bytesToken,
     chainl1,
     chainr1,
+    chainl1Accum,
     character,
     closeBlock,
     optionalCloseBlock,
@@ -450,6 +451,27 @@ chainr1 p op = go1
 chainl1 :: (Ord v) => P v m a -> P v m (a -> a -> a) -> P v m a
 chainl1 p op = foldl (flip ($)) <$> p <*> P.many (flip <$> op <*> p)
 
+-- chainl1Accum is like chainl1, but it accumulates intermediate results
+-- instead of applying them immediately. It's used to implement infix
+-- operators that may or may not have precedence rules.
+chainl1Accum ::
+  (P.Stream u, Ord s) =>
+  P.ParsecT s u m a ->
+  P.ParsecT s u m (a -> a -> a) ->
+  P.ParsecT s u m (a, [a -> a])
+chainl1Accum p op = do
+  x <- p
+  fs <- rest []
+  pure (x, fs)
+  where
+    rest fs =
+      ( do
+          f <- op
+          y <- p
+          rest (fs ++ [flip f y])
+      )
+        <|> return fs
+
 -- | If `p` would succeed, this fails uncommitted.
 --   Otherwise, `failIfOk` used to produce the output
 failureIf :: (Ord v) => P v m (P v m b) -> P v m a -> P v m b