Generates definitions to assist working with tagged value tuples, such as the ubiquitous {:ok, value} and {:error, reason}.

Examples

defmodule Status
  use Tagged

  deftagged ok(value :: term())
  deftagged error(reason :: term())
end

Construct and Destructure

iex> require Status
iex> Status.ok(:computer)
{:ok, :computer}
iex> with Status.error(reason) <- {:ok, :computer}, do: raise reason
{:ok, :computer}

See Tagged.Constructor for further details.

Type definitions

_iex> t Status.error
@type error() :: {:error, reason :: term()}

Tagged value tuple, containing reason :: term()

See Tagged.Typedef for further details.

Pipe selective execution

iex> require Status
iex> import Status, only: [ok: 1, with_ok: 2]
iex> ok(:computer) |> with_ok(& "OK, #{&1}")
"OK, computer"

See Tagged.PipeWith for further details.

Sum Algebraic Data Type: Binary Tree

A module that defines some tagged values, a composit type, and guard of those, forms a Sum Algebraic Data Type, also known as a Tagged Union.

defmodule BinTree do
  use Tagged

  deftagged tree(left :: t(), right :: t())
  deftagged leaf(value :: term())
  deftagged nil, as: empty()

  @type t() :: tree() | leaf() | empty()

  defguard is_t(x) when is_tree(x) or is_leaf(x) or is_empty(x)

  @spec leaves(tree()) :: [term()]
  def leaves(empty()), do: []
  def leaves(leaf(v)), do: [v]
  def leaves(tree(l, r)), do: leaves(l) ++ leaves(r)
end

iex> require BinTree
iex> import BinTree
iex> t = tree(leaf(1),
...>          tree(leaf(2),
...>               empty()))
{:tree, {:leaf, 1}, {:tree, {:leaf, 2}, nil}}
iex> is_t(t)
true
iex> leaves(t)
[1, 2]