Smart linebreak printer for pipe chains

[fhammerschmidt]

This is an old issue from the syntax repo. Would be still nice to have.

amiralies commented on Feb 4, 2021

They are currently being formatted based on line width.
it would be good to allow user decide whether to break line on pipes or not.

for example this code gets formatted to a single line with default line width

let bazz = foo.bars->OptionEx.arrayValues->Map.String.fromArray

I found this more readable

let bazz =
foo.bars
  ->OptionEx.arrayValue
  ->Map.String.fromArray

Ref: rescript-lang/syntax#257

[zth]

This would be great indeed.

[zth]

Who wants to work on exploring this? Any volunteers? We'll provide the coaching needed of course.

[aspeddro]

Hi @zth, see #6387. It was something I did some time ago

[fhammerschmidt]

Thanks for the PR, but telling from the tests that are changed it is probably not "smart"? Smart printing means that it will be preserved on one line iff the user wrote it on a single line (except of course it is above the max length). Otherwise it should be multiline.

Essentially it would be the same behaviour as with records or variants.

[DZakh]

Personally, I don't like the concept of smart formatting. I think it's good that the code is always formatted the same way.

[fhammerschmidt]

It's a huge bikeshedding topic and ppl. complained about being forced to have their records multiline before so ofc it is a compromise. The formatter is not perfect and finding good enough heuristics that work every time without making your code inconsistent is very hard.

Alternatively, there is also the suggestion from TheSpyder in the old thread to just break when you hit the third pipe (rescript-lang/syntax#257 (comment)). That won't produce as many diffs I think.

[DZakh]

Alternatively, there is also the suggestion from TheSpyder in the old thread to just break when you hit the third pipe (rescript-lang/syntax#257 (comment)). That won't produce as many diffs I think.

I like the suggestion. But still should remember about the line length. So if you have a very nested function call with two pipes, I think it also needs to be split into multiple lines.

[fhammerschmidt]

Yes, but that is already the case so I did not mention it explicitly.

[aspeddro]

I think we should break when it exceeds 80 columns and not three pipes. Also adding a space around the pipe improves readability.

Yes that's not "smart", I just copied the title.

(*example ocamlformat*)
let baz = [1; 2; 3] |> List.map (fun x -> x + 1) |> List.map (fun x -> x + 1)

[DZakh]

Also adding a space around the pipe improves readability.

I think that's more relevant to OCaml, than ReScript.

[DZakh]

I think we should break when it exceeds 80 columns and not three pipes.

This is how prettier works 👍 Also, we might have both 80 columns and three pipes.

[aspeddro]

Also adding a space around the pipe improves readability.

I think that's more relevant to OCaml, than ReScript.

Why? Some languages that use pipe add a space around it (elixir, R, julia). I always thought the glued pipe operators were weird.

[DZakh]

But not Js (if we consider the method call as the closest relative to pipes)

[fhammerschmidt]

They are glued to resemble something like PHP-style method calls. It triggers autocomplete, so I think having to write 3 or 4 chars instead of 2 is worse. As for the 80 chars to break, why would we want to break anything below the maximum line width of 100?

I just realised there may be value in breaking all of them if we want this. However, smart printing would be just as feasible.

As you can see, it definitely is a huge bikeshedding topic... 😅

[aspeddro]

Note that PR breaks pipe when there are three pipes.

So the code below is not formatted

let bazz = foo.bars->OptionEx.arrayValues

But

let bazz = foo.bars->OptionEx.arrayValues->Map.String.fromArray

Is formmated to:

let bazz =
  foo.bars
  ->OptionEx.arrayValues
  ->Map.String.fromArray