The pipe operator in Elixir

In part 10 of my Elixir journey I'll be sharing a brief introduction to the pipe operator.

Pipe Operator

If my procedural upbringing has taught me anything it's that you can chain one function call after another to accomplish just about everything.

    defmodule Math do
      defp add(a, b), do: a + b
      defp multiply(a, b), do: a * b
      defp divide(a, b), do: a / b
      def magic() do
        two = add(1, 1)
        six = multiply(two, 3)
        result = divide(six, 2)
        IO.puts result
      end
    end
  

In this example I'm using a handful of private functions to do `magic` and print out the result. This style of programming makes it clear what each function recieves as input and returns as output. One less verbose alternative is function chaining, but in most languages this requires the reader to work inside out which feels unintuitive.

    result = divide(multiply(add(1, 1), 3), 2)
  

Elixir offers the best of both worlds with the fabulous pipe operator. You work left to right, instead of inside out, so the flow of information is more natural for the reader. Also, the output of each function in the chain becomes the first parameter of the function that follows.

    defmodule Math do
      defp add(a, b), do: a + b
      defp multiply(a, b), do: a * b
      defp divide(a, b), do: a / b
      def magic() do
        result = add(1, 1)
          |> multiply(3)
          |> divide(2)
        IO.puts result
      end
    end
  

The pipe operator works well multi-line as shown above but it also supports single line chaining if you prefer.

    defmodule Math do
      defp add(a, b), do: a + b
      defp multiply(a, b), do: a * b
      defp divide(a, b), do: a / b
      def magic() do
        result = add(1, 1) |> multiply(3) |> divide(2)
        IO.puts result
      end
    end
  

This syntax in particular has encouraged me to embrace a more functional way of thinking in the language.