EMPEX HALLOWEEN Railway Programming in Elixir with with Chris Bell • @cjbell_

<3 |>

Allows us to easily express a set of combined steps and operations on data

def process_checkout(order) do order |> update_order() |> capture_payment() |> send_notification_email() |> update_stock_levels()
 end

But what about errors?

We use tagged tuples to represent success and error states.

{:ok, _} | {:error, _}

How do we stop the execution of these functions if one fails?

Update Order Capture Payment Send Email Update Stock process_checkout Order {:ok, order} {:error, reason}

On success we pass through to the next function, on error we switch.

Scott Wlaschin’s Railway Orientated Programming http://fsharpforfunandprofit.com/rop/

So how do we implement this in Elixir?

defp update_order({:ok, order}) do # Do logic
 {:ok, order} end
 defp update_order({:error, reason}) do
 # Pass through {:error, reason} end
 # Repeat for every method

Lets do this a different way…

This is Haskell the dog and Monad the bear

defmodule Result do def bind({:ok, value}, func) do func.(value) end def bind({:error, _} = failure,_) do 
 failure
 end end

import Result
 
 def process_checkout(order) do order |> bind(&update_order/1) |> bind(&capture_payment/1) |> bind(&send_notification_email/1) |> bind(&update_stock_levels/1)
 end

import Result
 
 def process_checkout(order) do order |> bind(&update_order/1) |> bind(&capture_payment/1) |> bind(&send_notification_email/1) |> bind(&update_stock_levels/1)
 end Put down that Monad, theres another way.

with

Allows us to execute a set of clauses only if the previous clause matches

def process_checkout(order) do with {:ok, order} <- update_order(order), {:ok, order} <- capture_payment(order), {:ok, order} <- send_notification_email(order), {:ok, order} <- update_stock_levels(order), do: {:ok, order}
 end

If the clause doesn’t match, the non matching value is returned and all subsequent steps are skipped.

Update Order Capture Payment Send Email Update Stock process_checkout Order {:ok, order} {:error, reason}

As of Elixir 1.3 we can also use an else block to handle non- matching clauses

def process_checkout(order) do with {:ok, order} <- update_order(order), {:ok, order} <- capture_payment(order), {:ok, order} <- send_notification_email(order), {:ok, order} <- update_stock_levels(order) do 
 {:ok, order} else {:error, %Changeset{} = cs} -> handle_error(cs) {:error, reason} -> handle_other_error(reason) end
 end

Ensign Bell’s top tip: 
 Usage with Ecto.Repo.transaction

def process_checkout(order) do Repo.transaction(fn ->
 do_process_checkout(order)
 |> case do
 {:ok, order} -> order
 {:error, cs} -> Repo.rollback(cs)
 end
 end)
 end
 
 def do_process_checkout(order) do
 # Everything here returns a Ecto.Changeset with {:ok, order} <- update_order(order), {:ok, order} <- capture_payment(order), {:ok, order} <- send_notification_email(order), {:ok, order} <- update_stock_levels(order),
 do: {:ok, order}
 end

Thank you. Questions? chris@madebymany.com