Converts a matching error to :ok An error matches if the reason is equal to the supplied atom or the reason passes the predicate. Leaves success and other errors unchanged.

Examples:

iex> {:error, :already_completed}
...> |> convert_error(:already_completed)
:ok

iex> {:error, :already_completed}
...> |> convert_error(fn r -> r == :already_completed end)
:ok

Converts a matching error to a success with the given value or function. An error matches if the reason is equal to the supplied atom or the reason passes the predicate. Leaves success and other errors unchanged. Lazy. Only evaluates the second argument if necessary.

Examples:

iex> {:error, :already_completed}
...> |> convert_error(:already_completed, "submitted")
{:ok, "submitted"}

iex> {:error, "test"}
...> |> convert_error(&(&1 == "test"), fn r -> {:ok, r <> "ed"} end)
{:ok, "tested"}

Typespec:

convert_error(t(), (any -> boolean) | any, b | (any -> t(b))) :: t(b) when b: var

Lifts a value into a success tuple unless: 1) the value matches the second argument 2) when applied to the value, the second argument function returns true

In those cases an error tuple is returned with either 1) the third argument as the reason 2) the third argument function applied to the value, as the reason

lift/3 is lazy, this means third argument will only be evaluated when necessary.

Examples:

iex> nil
...> |> lift(nil, :not_found)
{:error, :not_found}

iex> 2
...> |> lift(nil, :not_found)
{:ok, 2}

iex> "test"
...> |> lift(&(&1 == "test"), fn x -> {:oops, x <> "ed"} end)
{:error, {:oops, "tested"}}

Typespec:

lift(a | b, b | (a | b -> boolean), c | (a | b -> c)) :: s(a) when a: var, b: var, c: var

Logs on error, does nothing on success.

Example:

{:error, :not_found}
|> log_error("There was an error", level: :info, metadata: "some meta")

Applies the function to the reason in an error tuple. Leaves success unchanged.

Example:

iex> account_name = "test"
...> {:error, :not_found}
...> |> map_error(fn r -> {r, account_name} end)
{:error, {:not_found, "test"}}

Replaces the reason in an error tuple. Leaves success unchanged. Lazy. Only evaluates the second argument if necessary.

Example:

iex> account_name = "test"
...> {:error, :not_found}
...> |> mask_error({:nonexistent_account, account_name})
{:error, {:nonexistent_account, "test"}}

Typespec:

mask_error(t(a), any) :: t(a) when a: var

Wraps a naked :error atom in a tuple with the given reason. Leaves success values and error tuples unchanged.

Examples:

iex> :error
...> |> normalize_error(:parsing_failure)
{:error, :parsing_failure}

iex> {:ok, 2}
...> |> normalize_error()
{:ok, 2}