Do you think Kernel.++ has readability?

When I started out in Elixir it seemed freaky. Now, I find it handy. I used Kernel.<> just the other day.

Thank you for replying!
I feel it is freaky… Do you often use the way of using Kernel?
I hope you would show me a sample code of you if it’s possible!

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!

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

It’s useful when passing it around as a higher-order function.
Ex.

iex(1)> Enum.reduce ['u','o','i','e','a'], &Kernel.++/2 
'aeiou'

Kernel. is not required, &++/2 works fine.

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).

Also when :++/2 is redefined locally

defmodule M do
  import Kernel, except: [{:++, 2}]
  def unquote(:++)(p1, p2), do: {p1, p2}
  def test(p1, p2), do: p1 ++ p2
end

M.test 1, 2
#⇒ {1, 2}