In pipelines I prefer to use Enum.concat/2 that is delegating to Kernel.++/2 when both arguments are lists.

I think that readability is somewhat dependent on one’s audience. Code that is highly readable to someone who’s been using a language for 5 years might seem completely foreign to someone six months in.

Personally, I really prefer pipelining where possible. Taking it a step further, I’ve recently started making heavy use of the with macro. It can also seem somewhat inscrutable at first, but it permits a style of railway-oriented programming that’s both efficient and compact.

The example I was mentioning above was a long pipeline that I ended up needing to append a newline onto the result. Rather than create an intermediate variable just to add a character, it was easier for me to just extend the pipeline with one last command like |> Kernel.<> ("\n")

It’s not something I do often, but I will use it without feeling too much guilt these days

I’m sure lots of people here would argue against pipelining into the Kernel module. Programmers are a finicky lot I would just suggest adopting a set of style guidelines, perhaps enforced using Credo or such.

Whichever style you agree on together will be the real right answer!

It’s still useful to use &Kernel.++/2, as this captures a “fully qualified function” instead of a local one. The latter is sometimes problematic when encoded or somehow stored between compile time and runtime (e.g. in config or plugs).