Simplify pipelined accessor call into access

[Janiczek]

What the rule should do: Replace things like foo |> .x with foo.x, except for when the foo is a function call or operator call (eg. a pipeline).

What problems does it solve: Makes things simpler?

Example of things the rule would report:

foo |> .x
--> foo.x

1 |> .x
--> 1.x, wouldn't typecheck but is valid syntax

{ x = 3 } |> .x
--> { x = 3 }.x, to be picked up by another rule later and simplify to 3

Example of things the rule would not report:

foo 1 |> .x

foo |> fn |> .x

Should this be part of the Simplify rule or should it be a new rule? Simplify

I am looking for:

• Someone to implement it for me

[Janiczek]

I guess it might be related to a rule where .x foo is rewritten into foo.x, which could be thought of as a simpler variant of the above. If we had some RuleAstPred -> RuleAstPred combinator way of making rules that work on fn calls also work on pipelined fn calls, then that simpler rule + that combinator would give you the rule I'm proposing above.

[lue-bird]

Similar to .x foo I think this is pretty much just a style issue which is better suited to rules with fine control like SiriusStarr/elm-review-pipeline-styles.

For example, in some cases, it might just be more readable to not use the record access shortcut

generalizableListElement
    |> .toGeneral
    |> expressionParenthesize
    |> ...

and I think simplify reporting such cases could be annoying for users.

[jfmengels]

Right. I feel like we often have this discussion and I keep forgetting :sweat_smile: Yeah, use SiriusStarr/elm-review-pipeline-styles instead, and if it doesn't support this, then open an issue there.

[Janiczek]

fair, thanks