Elixir has become one of the most loved languages. Elixir applications are scalable, very reliable, and the syntax is also quite nice. In this article, we will discuss about how elixir pipe operator (|>) works
When we use functional programming languages, sometimes code becomes messy. Let's take a look at this code, this function returns the average height of the adults in Delhi state
calculate_avg_height(adults(state('New Delhi')))
We can rewrite this code using the pipe operator
'New Delhi' |> state |> adults |> calculate_avg_height
Pipe operator makes our lives easier and makes our code looks beautiful. In this section, we build our own pipe operator with <|> this symbol. Rules of pipe operator are simple, the result of one function passes as an argument to the next function.
Let's say we need to perform a series of addition and multiplication operations. we can simply use a pipe operator
1 |> add(2) |> multiply(5) |> div(15)
In the first stage, 1 will be passed as an argument to add function
In second stage 1 and 2 are added and pass 3 as an argument to multiply the function
Multiply function performs 3 * 5 and pass 15 to div function and return 1 as result
Before we jump into building pipe operator. We need to have knowledge about elixir macros. You can learn about Elixir macros in this article
We use macros to build pipe operator. This basic difference between functions and macros is macros accept representation of code but functions accepts evaluation of code
We use 1 |> add(2) |> multiply(5) |> div(15) expression as reference to build pipe operator
Let's define a pipe macro. It will do pattern matching on the left and right arguments
defmodule Pipe do
defmacro left <|> right do
end
end
Define the unpipe function to pluck and store all the functions in array. You noticed that we store all the functions in AbstractSyntaxTree (AST) format
def unpipe(expr) do
Enum.reverse(unpipe(expr, []))
end
defp unpipe({:<|>, _, [left, right]}, acc) do
unpipe(right, unpipe(left, acc))
end
defp unpipe(other, acc) do
[{other, 0} | acc]
end
We need to define more function to pipe all the functions into a single function. You can picture the process by observing the following diagram
In the first stage we will add 1 as an argument to quoted expression {: add,_, [2]} In next stage we add {:add,_, [1, 2]} as an argument to {:multiply _, [3]} and so on
We use elixir inbuilt function List.foldl function to perform pipe operation and return the expression {:div, _, [{:multiply, _, [{:add, _, [1,2],3]},15]} to the caller
[{h, _} | t] = unpipe({:<|>, [], [left, right]})
value = List.foldl(t,h , fn {x,pos},acc -> pipe(acc,x,pos) end)
def pipe(expr, {call, line, _}, integer) do
{call, line, List.insert_at([], integer, expr)}
end
The resulting module will look like this.
# pipe.ex
defmodule Pipe do
defmacro left <|> right do
[{h, _} | t] = unpipe({:<|>, [], [left, right]})
List.foldl(t,h , fn {x,pos},acc -> pipe(acc,x,pos) end)
end
def unpipe(expr) do
Enum.reverse(unpipe(expr, []))
end
defp unpipe({:<|>, _, [left, right]}, acc) do
unpipe(right, unpipe(left, acc))
end
defp unpipe(other, acc) do
[{other, 0} | acc]
end
def pipe(expr, {call, line, atom}, integer) when is_atom(atom) do
{call, line, List.insert_at([], integer, expr)}
end
def pipe(expr, {op, line, args} = op_args, integer) when is_list(args) do
{op, line, List.insert_at(args, integer, expr)}
end
end
You can test this operator in iex terminal.
iex(2)> require Pipe
iex(3)> import Pipe
iex(5)> 2 <|> div(1) <|> IO.puts
2
:ok
I hope you understand how pipe operator works . If you want to learn more interesting topics in elixir.
