Rusult

Installation

The package can be installed by adding rusult to your list of dependencies in mix.exs:

def deps do
  [
    {:rusult, "~> 1.0.0"}
  ]
end

Description

Result struct based on the Rust Result object.

>> Rust Result << -> Rusult

Implemented Rust Result stable functions (1.46):

• and ✔️ if_err/2
• and_then ✔️ and_then/2
• err ✔️ error_or_nil/1
• expect ✔️ expect!/2
• expect_err ✔️ expect_err!/2
• is_err ✔️ error?/0
• is_ok ✔️ ok?/0
• iter ✔️ ok_or_nil/1
• map ✔️ map/2
• map_err ✔️ map_err/2
• map_or ✔️ map_or/3
• map_or_else ✔️ map_or_else/3
• ok ✔️ ok_or_nil/1
• or ✔️ if_ok/2
• or_else ✔️ or_else/2
• unwrap ✔️ unwrap!/1
• unwrap_err ✔️ unwrap_err!/1
• unwrap_or ✔️ unwrap_or/2
• unwrap_or_else ✔️ unwrap_or_else/2

Extra functions:

• map_err_or/3
• unwrap_err_or/2
• unwrap_err_or_else/2
• wrap/1

Implemented Rust Result unstable functions (1.46):

• contains ❌
• contains_err ❌
• flatten ❌
• into_ok ❌

Examples

iex> {:ok, 123} |> Rusult.from() |> Rusult.unwrap!()
123

iex> {:ok, 1, 2}  
...> |> Rusult.from()
...> |> Rusult.and_then(fn {a, b} -> Rusult.ok(a + b) end)
...> |> Rusult.to_tuple()
{:ok, 3}

iex> defmodule MyModule do
...>     def transform_value(%Rusult{ok?: true}) do
...>         {:ok, 123}
...>     end
...>     def transform_value(%Rusult{error?: true}) do
...>         {:error, :found_error}
...>     end
...> end
...>
...> "ERROR!"
...> |> Rusult.error()
...> |> MyModule.transform_value()
...> |> Rusult.from()
...> |> Rusult.expect_err!("this is ok?")
:found_error

Use your own Rusult module.

iex> defmodule MyRusult do
...>     @type t :: %__MODULE__{error: binary, ok: map, error?: boolean, ok?: boolean}
...>     @enforce_keys [:error?, :ok?]
...>     defstruct [:error, :ok, :error?, :ok?] 
...>
...>     def from(%Rusult{error: _error, ok: ok, error?: false, ok?: true}) do
...>        from(ok)
...>     end
...>     
...>     def from(%Rusult{error: error, ok: _ok, error?: true, ok?: false}) do
...>        %MyRusult{ok?: false, error?: true, error: error}
...>     end
...>
...>     def from(%MyRusult{} = my_result) do
...>        my_result
...>     end
...>     
...>     def from(data) when is_map(data) do
...>        %MyRusult{ok?: true, error?: false, ok: data}
...>     end
...>
...>     def from(_data) do
...>        %MyRusult{ok?: false, error?: true, error: "invalid data"}
...>     end
...> end
iex> %{data: [1,2,3,4]}
...> |> MyRusult.from()
...> |> Rusult.map(fn %{data: data} -> %{data: Enum.sum(data)} end)
...> |> MyRusult.from()
...> |> Map.from_struct()
%{ok?: true, error?: false, ok: %{data: 10}, error: nil}
iex> "testing"
...> |> MyRusult.from()
...> |> Rusult.map(fn %{data: data} -> Enum.sum(data) end)
...> |> MyRusult.from()
...> |> Map.from_struct()
%{ok?: false, error?: true, error: "invalid data", ok: nil}