Horizontal vs vertical piping


In the Elixir codebase most wide-adopted pipe operator usage style is vertical piping:

|> transform1(:another_option)
|> transform2

but horizontal piping is also present, though it’s rarer

variable |> transform1(:another_option) |> transform2

What are your thoughts about horizontal vs vertical piping? When use which? What’s your opinion about passing variable directly to the first function call vs piping it, i.e. transform1(variable, :another_option) vs variable |> transform1(:another_option)?


I have nothing against horizontal piping as long at it doesn’t generate too long lines (my limit is about 80 characters).
If the line gets too long I would break it to use vertical piping.

I have stronger opinions about directly passing the variable to the first function call though. Consider the following example:

transform1(variable, :option)
|> transform2(:another_option)

The variable that gets passed to transform1() is the beginning of the piping, but I have to read the code carefully to notice that. The thing gets aggravated when using horizontal piping or functions with long names and multiple arguments.

transform1(variable, :option) |> transform2(:another_option)

On the other side, piping the variable to the first function call makes it explicit and I can recognise the actual data flow and transformations while quickly scanning the code.

|> transform1(:option)
|> transform2(:another_option)


variable |> transform1(:option) |> transform2(:another_option)

EDIT: I’ve been taking a look at Credo’s style guide and found this:

It is preferred to start pipe chains with a “pure” value rather than a function call.

# preferred way - this is very readable due to the clear flow of data
|> String.strip
|> String.downcase

# also okay - but often slightly less readable
|> String.downcase

I think this is much of a personal style or habbit.

I do prefer vertical pipes, but I do use horizontals in single-line assignments if there are not more than 2 pipe operators.

The main reason for prefering vertical pipes is, that you can spot them on a glance even when you are not in a highlighting editor, just because the aligned pipe operators set a very bold statement.


The only uses for horizontal piping are either very trivial (i.e. short) sequences, or in IEx, as it will end a statement as soon as you hit return, even if you actually wanted to place a |> on the next line.

In most code, I (and I believe most of the other people in the community) agree that it is better to use vertical pipes, because they remain readable even when the amount of nested statements increases at a later time.