Infix style with large expressions

[HarrisonGrodin]

Currently, this is produced by the autoformatter:

val _ =
  f x + case g x of
          nil => 0
        | x :: xs => x + List.length xs

I'm not sure if it should change, though.

One principle I'm thinking we might want to adopt is:

Modifying code should not move independent code.

This would help modification to formatted code maintain a diff primarily relevant to the code which was actually modified.

Using the current style, modifying the expression f x (e.g., turning it into (f x * 2), or separately renaming f to fLongerName) would move the entire case expression forward, which seems somewhat undesirable since the case branches haven't changed at all.
One idea would be to have the style be

e1
+ e2

which may be grouped if possible; this is consistent with how other infix operators are used (such as |>), and it makes sure the infix operator doesn't get lost at the end of a line.

One downside to this style is that renaming the infix operator itself could move blocks of code; not sure if there's a good fix to this aside from

e1
+
e2

which seems a bit verbose.

[shwestrick]

Revisiting this now that smlfmt is quite a bit more mature.

Re: don't move independent code? I think in practice this is really really difficult to accomplish without making huge sacrifices to average code readability.

As for our current handling of infix expressions, I think it's generally pretty good, but could use some improvements. Here's the current output for the above example:

val _ =
  f x
  +
  case g x of
    nil => 0
  | x :: xs => x + List.length xs

Here's also a real-world example from the smlfmt source, showing a fairly complex expression with multiple occurrences of an infix operator <&>:

smlfmt/src/ast/CompareAst.sml

Lines 78 to 83 in ee6a59d

	val checker =
	at #left equal_tok <&> at #right equal_tok
	<&> at #delims (Seq.equal equal_tok)
	<&>
	at #elems (Seq.equal
	(at #lab equal_tok <&> at #colon equal_tok <&> at #ty equal_ty))

This generally seems pretty good, but I think it could be improved. For example, here's an instance I find tricky to parse because it's easy to miss the <&> at #delims ... buried in the middle:

smlfmt/src/ast/CompareAst.sml

Lines 375 to 381 in ee6a59d

	val checker =
	at #exp equal_exp <&> at #handlee equal_tok
	<&>
	at #elems (Seq.equal
	(at #pat equal_pat <&> at #arrow equal_tok
	<&> at #exp equal_exp)) <&> at #delims (Seq.equal equal_tok)
	<&> at #optbar (equal_op equal_tok)

I would prefer for it to be formatted like this.

val checker =
  at #exp equal_exp <&> at #handlee equal_tok
  <&>
  at #elems (Seq.equal
    (at #pat equal_pat <&> at #arrow equal_tok
     <&> at #exp equal_exp))
  <&> at #delims (Seq.equal equal_tok)  (* on its own line *)
  <&> at #optbar (equal_op equal_tok)

This seems doable. One idea to try: ensure that, as soon as an element of an infix-chain requires a new-line to align, then all later <op> <exp> ... elements of the chain will be put on their own new-line as well.