Do you think Kernel.++ has readability?

Hello. I’m developing a server program with elixir with a coworker.
I found a code which he wrote uses Kernel.++ in a pipeline chain.

I agree with that pipeline helps to write readable codes, but I’m not sure whether we should use Kernel.++ there.
I’d like to hear your opinion.
Thank you :grinning:

1 Like

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

1 Like

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! :yum: :yum: :yum:

1 Like

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 :slight_smile:

I’m sure lots of people here would argue against pipelining into the Kernel module. Programmers are a finicky lot :slight_smile: 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.

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

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

1 Like

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 :slight_smile:

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

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