Elegant error/exception handling in Elixir, with result monads.

• Install from Hex
• Documentation available on hexdoc

The OK module works with result tuples by treating them as a result monad.

{:ok, value} | {:error, reason}

See Handling Errors in Elixir for a more detailed explanation.

See FAQ at end of README for a few common question.

OK.for/1 combines several functions that may fail.

• Use the <- operator to match & extract a value for an :ok tuple.
• Use the = operator as you normally would for pattern matching an untagged result.

require OK

OK.for do
  user <- fetch_user(1)             # `<-` operator means func returns {:ok, user}
  cart <- fetch_cart(1)             # `<-` again, {:ok, cart}
  order = checkout(cart, user)      # `=` allows pattern matching on non-tagged funcs
  saved_order <- save_order(order)
after
  saved_order                       # Value will be wrapped if not already a result tuple
end

OK.for/1 guarantees that it's return value is also in the structure of a result tuple.

OK.try/1 combines several functions that may fail, and handles errors.

This is useful when writing code that has it's own representation of errors. e.g. HTTP Responses.

For example when using raxx to build responses the following code will always return a response.

require OK
import Raxx

OK.try do
  user <- fetch_user(1)             # `<-` operator means func returns {:ok, user}
  cart <- fetch_cart(1)             # `<-` again, {:ok, cart}
  order = checkout(cart, user)      # `=` allows pattern matching on non-tagged funcs
  saved_order <- save_order(order)
after
  response(:created)                # Value will be returned unwrapped
rescue
  :user_not_found ->
    response(:not_found)
  :could_not_save ->
    response(:internal_server_error)
end

The pipe (~>>) is equivalent to bind/flat_map. The pipe (~>) is equivalent to map.

These macros allows pipelining result tuples through multiple functions for an extremely concise happy path.

use OK.Pipe

def get_employee_data(file, name) do
  {:ok, file}
  ~>> File.read
  ~> String.upcase
end

Use ~>> for File.read because it returns a result tuple. Use ~> for String.upcase because it returns a bare value that should be wrapped in an ok tuple.

OK provides macros for matching on success and failure cases. This allows for code to check if a result returned from a function was a success or failure while hiding implementation details about how that result is structured.

import OK, only: [success: 1, failure: 1]

case fetch_user(id) do
  success(user) ->
    user
  failure(:not_found) ->
    create_guest_user()
end

For the main rational behind this decision see the article Errors are not exceptional

Two other reasons:

• Exceptional input and errors are not the same thing, OK leaves raising exceptions as a way to handle errors that should never happen.
• Calls inside try/1 are not tail recursive since the VM needs to keep the stacktrace in case an exception happens. see source.

• Accepting any extra forms is a slippery slope, and they are not always unambiguous. If a library is not returning errors as you like it is very easy to wrap in a custom function.

  def fetch_foo(map) do
    case Map.fetch(map, :foo) do
      {:ok, foo} -> {:ok, foo}
      :error -> {:error, :no_foo}
    end
  end

• OK.with was deprecated.
• use OK.Pipe was added.
• OK.bind was renamed OK.flat_map.

• Elixir Forum
  • OK v1 library
• Railway programming
• Similar Libraries
  • exceptional
  • elixir-monad
  • happy_with
  • monad
  • ok_jose
  • towel