defmodule Hike.Either do
alias __MODULE__, as: Either
@moduledoc """
`Hike.Either` represents a value that can be one of two possibilities: either a `Left` state or a `Right` state.
It is commonly used in error handling or when a function can return different types of
results.
Creating an Either
To create an Either instance,
you can use the `Hike.Either.right/1` and `Hike.Either.left/1` function to wrap a value in
`right` and `left` state respectively :
```elixir
iex> Hike.Either.right(5)
%Hike.Either{l_value: nil, r_value: 5, is_left?: false}
iex> Hike.Either.left("Hello")
%Hike.Either{l_value: "Hello", r_value: nil, is_left?: true}
```
```elixir
# Example can be written with `Either`
# Define a User struct
defmodule User do
@derive Jason.Encoder
defstruct [:id, :age, :name]
end
defmodule TestHike do
# Import the Hike.Either module
import Hike.Either
# Simulating a database fetch function
@spec fetch_user(number) :: Hike.Either.either(%User{}) | Hike.Either.either()
def fetch_user(id) do
# Simulating a database query to fetch a user by ID
# Returns an Either<User, string> with left(user) if the user is found
# Returns an Either<User, string> with right("User not found") if the user is not found
case id do
1 -> left(%User{id: 1, age: 30, name: "Vineet Sharma"})
2 -> left(%User{id: 2, age: 20, name: "Jane Smith"})
_ -> right("User not found")
end
end
# Function to update the user's name to uppercase if possible
# This function takes a User struct and returns an Either<User, string>
def update_name_to_uppercase(user) do
case user.name do
nil -> right("User name is missing")
name -> left(%User{user | name: String.upcase(name)})
end
end
# Function to increase the user's age by one
# This function takes a User struct and returns a real data type User with updated values.
def increase_age_by_1(user) do
%User{user | age: user.age + 1}
end
# Function to print a user struct as a JSON-represented string
def print_user_as_json(user) do
user
|> Jason.encode!()
|> IO.puts()
end
# Example: Fetching a user from the database, updating the name, and matching the result
def test_user() do
user_id = 1
# Fetch the user from the database
fetch_user(user_id)
# Update the name to uppercase using bind
|> bind_left(&update_name_to_uppercase/1)
# Increase the age by one using map
|> map_left(&increase_age_by_1/1)
# Print the user as a JSON string using map
|> map_left(&print_user_as_json/1)
# finally match the respective result with a appropriate function.
|> match(fn x -> x end, fn err ->err end)
user_id = 3
# Fetch the user from the database
fetch_user(user_id)
# Update the name to uppercase using bind
|> bind_left(&update_name_to_uppercase/1)
# Increase the age by one using map
|> map_left(&increase_age_by_1/1)
# Print the user as a JSON string using map
|> map_left(&print_user_as_json/1)
# finally match the respective result with a appropriate function.
|> match(fn x -> x end, fn err -> err end)
end
end
```
```shell
#output
iex> TestHike.test_user
#user_id = 1
{"age":31,"id":1,"name":"VINEET SHARMA"}
#user_id = 3
"User not found"
```
"""
@typedoc """
generic input type `<T>`.
"""
@type t :: any()
@typedoc """
generic return type `<TR>`.
"""
@type tr :: any()
@typedoc """
`func()` represent a function which take no parameter and return value of type `<TR>`.
## Example
@spec add_one(number) :: number
def add_one(x), do: x + 1
"""
@type func :: (() -> tr)
@typedoc """
`func(t)` represent a function which take a parameter of type `<T>`
and return a value of type `<TR>`.
## Example
@spec add_one(number) :: number
def add_one(x), do: x + 1
"""
@type func(t) :: (t -> tr)
@typedoc """
`mapper()` represent a mapping function which take no parameter and return
a value of type `<TR>`.
## Example
@spec whatever() :: atom
def whatever(), do: :ok
"""
@type mapper :: (() -> tr)
@typedoc """
`mapper(t)` represent a mapping function which take a parameter of type `<T>`
and return a value of type `<TR>`.
## Example
@spec square(number) :: number
def square(x), do: x * x
"""
@type mapper(t) :: (t -> tr)
@typedoc """
`binder()` represent a binding(mapping) function which take no parameter and
return an Either of type `<TR>`.
## Example
@spec whatever() :: Hike.Either.either_right(atom)
def whatever(), do: right(:ok)
@spec whatever() :: Hike.Either.either_left(:error)
def whatever(), do: left(:error)
"""
@type binder :: (() -> either_left(tr) | either_right(tr))
@typedoc """
`binder(t)` represent a binding(mapping) function which take a parameter of type `<T>`
and return an `Either` of type `<TR>`.
## Example
@spec square(pos_number) :: Hike.Either.either_right(number)
def square(x) when x > 0, do: x * x |> right()
@spec square(number) :: Hike.Either.either_left(:error) | Hike.Either.either_right(number)
def square(x) do
case x when x < 0 do
true -> left({:error, "negative number"})
false -> square(x)
end
end
"""
@type binder(t) :: (t -> either_left(tr) | either_right(tr))
@typedoc """
generic input type `<T_Left>` represent a type of value on `Left`state.
"""
@type t_left :: any()
@typedoc """
generic input type `<T_Right>`represent a type of value on `Right`state.
"""
@type t_right :: any()
@typedoc """
represent a type of `Either` that could be in either `Left` or `Right` state
with a value of given type.
"""
@type either(t_left, t_right) :: %__MODULE__{
l_value: t_left,
r_value: t_right,
is_left?: boolean()
}
@typedoc """
represent a type of `Either` that could be in either `Left` or `Right` state
"""
@opaque either() :: %__MODULE__{
l_value: t_left(),
r_value: t_right(),
is_left?: boolean()
}
@typedoc """
Elevated data type of `Either` struct that represents `Right` state.
"""
@type either_right :: %__MODULE__{
l_value: nil,
r_value: t_right(),
is_left?: false
}
@typedoc """
Elevated data type of `Either` struct that represents `Right` state and have a value of type `<T>`.
"""
@type either_right(t) :: %__MODULE__{
l_value: nil,
r_value: t,
is_left?: false
}
@typedoc """
represent a type of `Either` in `Left` state.
"""
@type either_left :: %__MODULE__{
l_value: t_left(),
r_value: nil,
is_left?: true
}
@typedoc """
represent a type of `Either` in `Left` state.
"""
@type either_left(t) :: %__MODULE__{
l_value: t,
r_value: nil,
is_left?: true
}
@doc """
`%Hike.Either{l_value: t_left(), r_value: t_right(), is_left?:boolean()}` is a struct that represents an "either/or" value.
It can contain either a `left` value or a `right` value, but not both.
* `l_value`: the left value (if `is_left?` is true)
* `r_value`: the right value (if `is_left?` is false)
* `is_left?`: a boolean flag indicating whether the value is a left value (`true`) or a right value (`false`)
"""
defstruct [:l_value, :r_value, :is_left?]
defmacro is_not_nil(value) do
quote do
unquote(value) !== nil
end
end
@doc """
Creates a new Left Either object with a given value for the left side.
## Examples
iex> left("foo bar")
%Hike.Either{l_value: "foo bar", r_value: nil, is_left?: true}
"""
@spec left(t_left) :: Either.either_left(t_left)
def left(value) when is_not_nil(value),
do: %__MODULE__{l_value: value, r_value: nil, is_left?: true}
def left(nil), do: raise(ArgumentError, message: "Left value cannot be nil")
@doc """
Creates a new `Either` in `Right` state with a given value.
## Examples
iex> right("foo bar")
%Hike.Either{l_value: nil, r_value: "foo bar", is_left?: false}
"""
@spec right(t_right()) :: Either.either_right(t_right)
def right(value) when is_not_nil(value),
do: %__MODULE__{l_value: nil, r_value: value, is_left?: false}
def right(nil), do: raise(ArgumentError, message: "Right value cannot be nil")
@doc """
Check whether an`either` is in `Left` state or not .
## Examples
iex> right("foo bar") |> Either.is_left?()
false
iex> left("foo bar") |> Either.is_left?()
true
"""
@spec is_left?(Either.either()) :: boolean()
def is_left?(%__MODULE__{is_left?: true} = _either), do: true
def is_left?(_), do: false
@doc """
Check whether an`either` is in `Right` state or not .
## Examples
iex> right("foo bar") |> Either.is_right?()
true
iex> left("foo bar") |> Either.is_right?()
false
"""
@spec is_right?(Either.either()) :: boolean()
def is_right?(%__MODULE__{is_left?: false} = _either), do: true
def is_right?(_), do: false
@doc """
`apply_left` applies a given function to a given `Either` if `Either` is in left state and
return a new `Either` with new transformed value in `Left` state
else return new `Either` in `Right` state with existing right value.
## Examples
iex> (Either.left 5) |> Either.apply_left(fn num -> num + num end)
%Hike.Either{l_value: 10, r_value: nil, is_left?: true}
iex> (Either.right 5) |> Either.apply_left(fn num -> num + num end)
%Hike.Either{l_value: nil, r_value: 5, is_left?: false}
"""
@spec apply_left(Either.either_left(t_left()), (t_left() -> tr())) :: Either.either_left(tr())
def apply_left(%__MODULE__{l_value: l_value, is_left?: true} = _either, func)
when is_function(func, 1),
do: func.(l_value) |> left
@spec apply_left(Either.either_right(t_right), (t_left() -> tr())) ::
Either.either_right(t_right())
def apply_left(%__MODULE__{r_value: r_value, is_left?: false} = _either, _func),
do: r_value |> right
@doc """
Applies the provided function `func` to the left value of `Either` wrapped in a `Task` and
returns a new task with the result.
## Examples
iex> task = Task.async(fn -> Hike.Either.left("Hello") end)
...> applied_task = apply_left_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right(10) end)
...> applied_task = apply_left_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{l_value: nil, r_value: "Hello", is_left?: false}
"""
@spec apply_left_async(Task.t(), func(t())) :: Task.t()
def apply_left_async(wrapped_task, func) when is_function(func, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
apply_left(eth, func)
end)
end
end
@doc """
`apply_right` applies a given function to a given `Either` if `Either` is in right state and
return a new `Either` with new transformed value in `Right` state
else return new `Either` in `Left` state with existing left value.
## Examples
iex> (Either.right "hello") |> Either.apply_right(fn str -> String.upcase(str) end)
%Hike.Either{l_value: nil, r_value: "HELLO", is_left?: false}
iex> (Either.left "hello") |> Either.apply_right(fn str -> String.upcase(str) end)
%Hike.Either{l_value: "hello", r_value: nil, is_left?: true}
"""
@spec apply_right(Either.either_left(t_left), (t_right() -> tr())) ::
Either.either_left(t_left())
def apply_right(%__MODULE__{l_value: l_value, is_left?: true} = _either, func)
when is_function(func, 1),
do: l_value |> left
@spec apply_right(Either.either_right(t_right()), (t_right() -> tr)) ::
Either.either_right(tr())
def apply_right(%__MODULE__{r_value: r_value, is_left?: false} = _either, func)
when is_function(func, 1),
do: func.(r_value) |> right
@doc """
Applies the provided function `func` to the right value of `Either` wrapped in a `Task` and returns
a new task with the result.
## Examples
iex> task = Task.async(fn -> %Hike.Either{right: "Hello"} end)
...> applied_task = apply_right_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{left: nil, right: "HELLO", is_left?: false}
iex> task = Task.async(fn -> %Hike.Either{left: 10} end)
...> applied_task = apply_right_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{left: 10, right: nil, is_left?: true}
"""
@spec apply_right_async(Task.t(), func(t())) :: Task.t()
def apply_right_async(wrapped_task, func) when is_function(func, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
apply_right(eth, func)
end)
end
end
@doc """
Maps the value of the `Either` from left state using the given function.
If the `Either` is in the right state, the function returns the `Either`
unchanged. If the `Either` is in the left state, the function applies the
given function to the value of the left state, and returns a new `Either`
with the transformed value.
## Examples
iex> (Either.left 5) |> Either.map_left(fn num -> num + num end)
%Hike.Either{l_value: 10, r_value: nil, is_left?: true}
iex> (Either.right 5) |> Either.map_left(fn num -> num + num end)
%Hike.Either{l_value: nil, r_value: 5, is_left?: false}
iex> either = %Either{l_value: "hello", is_left?: true}
...> new_either = Either.map_left(either, &String.upcase/1)
%Hike.Either{l_value: "HELLO", is_left?: true}
iex> either = %Either{r_value: 10, is_left?: false}
...> new_either = Either.map_left(either, &String.downcase/1)
%Hike.Either{r_value: 10, is_left?: false}
"""
@spec map_left(Either.either_left(t_left()), (t_left() -> tr())) :: Either.either_left(tr())
def map_left(%__MODULE__{l_value: l, r_value: _r, is_left?: true} = _e, func)
when is_function(func, 1) do
left(func.(l))
end
@spec map_left(Either.either_right(t_right()), (t_left() -> tr())) ::
Either.either_right(t_right())
def map_left(%__MODULE__{l_value: _l, r_value: r, is_left?: false} = _e, _f) do
right(r)
end
@doc """
Applies the provided function `mapper` to the left value of `Either` wrapped in a `Task` and
returns a new task with the result.
## Examples
iex> task = Task.async(fn -> Hike.Either.left("Hello") end)
...> applied_task =map_left_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right(10) end)
...> applied_task = map_left_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{l_value: nil, r_value: "Hello", is_left?: false}
"""
@spec map_left_async(Task.t(), mapper(t())) :: Task.t()
def map_left_async(wrapped_task, mapper) when is_function(mapper, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
map_left(eth, mapper)
end)
end
end
@doc """
Maps the value of the`Either` from right state using the given function.
If the `Either` is in the left state, the function returns the `Either`
unchanged. If the `Either` is in the right state, the function applies the
given function to the value of the right state, and returns a new `Either`
with the transformed value.
## Examples
iex> (Either.right "hello") |> Either.map_right(fn str -> String.upcase(str) end)
%Hike.Either{l_value: nil, r_value: "HELLO", is_left?: false}
iex> (Either.left "hello") |> Either.map_right(fn str -> String.upcase(str) end)
%Hike.Either{l_value: "hello", r_value: nil, is_left?: true}
"""
@spec map_right(Either.either_right(t_right()), (t_right -> tr())) :: Either.either_right(tr())
def map_right(%__MODULE__{l_value: _l, r_value: r, is_left?: false} = _either, func)
when is_function(func, 1),
do: func.(r) |> right
@spec map_right(Either.either_left(t_left()), (t_right -> tr())) :: Either.either_left(t_left())
def map_right(%__MODULE__{l_value: l, r_value: _r, is_left?: true} = _either, _func),
do: left(l)
@doc """
Applies the provided function `mapper` to the right value of `Either` wrapped in a `Task` and
returns a new task with the result.
## Examples
iex> task = Task.async(fn -> %Hike.Either{right: "Hello"} end)
...> applied_task = map_right_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{left: nil, right: "HELLO", is_left?: false}
iex> task = Task.async(fn -> %Hike.Either{left: 10} end)
...> applied_task = map_right_async(task, &String.upcase/1)
...> Task.await(applied_task)
%Hike.Either{left: 10, right: nil, is_left?: true}
"""
@spec map_right_async(Task.t(), Either.mapper(t())) :: Task.t()
def map_right_async(wrapped_task, mapper) when is_function(mapper, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
map_right(eth, mapper)
end)
end
end
@doc """
Binds a function that returns an `Either` value for an `Either` in the left state.
If the input Either is in the right state,
the function is not executed and the input Either is returned as is.
## Examples
iex> (Either.left "hello") |> Either.bind_left(fn str -> Either.left(String.upcase(str)) end)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> (Either.left "hello") |> Either.bind_left(fn str -> Either.right(String.upcase(str)) end)
%Hike.Either{l_value: nil, r_value: "HELLO", is_left?: false}
iex> (Either.right "hello") |> Either.bind_left(fn str -> Either.left(String.upcase(str)) end)
%Hike.Either{l_value: nil, r_value: "hello", is_left?: false}
"""
@spec bind_left(Either.either_left(t_left), binder(t_left)) ::
Either.either_left(tr) | Either.either_right(tr)
def bind_left(%__MODULE__{l_value: l_val, is_left?: true} = _either, func)
when is_function(func, 1),
do: func.(l_val)
@spec bind_left(Either.either_right(t_right()), binder(t_left)) ::
Either.either_right(t_right())
def bind_left(%__MODULE__{l_value: _l_val, r_value: r_val, is_left?: false} = _either, _func),
do: right(r_val)
@doc """
Applies the provided function `binder` to the left value of `Either` wrapped in a `Task` and
returns a new task with the result.
## Examples
iex> task = Task.async(fn -> Hike.Either.left("Hello") end)
...> applied_task =bind_left_async(task, fn str -> Either.left(String.upcase(str)) end)
...> Task.await(applied_task)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right("Hello") end)
...> applied_task =bind_left_async(task, fn str -> Either.left(String.upcase(str)) end)
...> Task.await(applied_task)
%Hike.Either{l_value: nil, r_value: "Hello", is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right(10) end)
...> applied_task = bind_left_async(task, fn num -> num * num end)
...> Task.await(applied_task)
%Hike.Either{l_value: nil, r_value: 10, is_left?: false}
"""
@spec bind_left_async(Task.t(), binder(t())) :: Task.t()
def bind_left_async(wrapped_task, binder) when is_function(binder, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
bind_left(eth, binder)
end)
end
end
@doc """
Binds a function that returns an Either value to an Either in the right state.
If the input Either is in the left state,
the function is not executed and the input Either is returned as is.
## Examples
iex> (Either.right "hello") |> Either.bind_right(fn str -> Either.right(String.upcase(str)) end)
%Hike.Either{l_value: nil, r_value: "HELLO", is_left?: false}
iex> (Either.right "hello") |> Either.bind_right(fn str -> Either.left(String.upcase(str)) end)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> (Either.left "hello") |> Either.bind_right(fn str -> Either.right(String.upcase(str)) end)
%Hike.Either{l_value: "hello", r_value: nil, is_left?: true}
"""
@spec bind_right(Either.either_right(t_right), binder(t_right)) ::
Either.either_right(tr) | Either.either_left(tr)
def bind_right(%__MODULE__{r_value: r_val, is_left?: false} = _either, func)
when is_function(func, 1),
do: func.(r_val)
@spec bind_right(Either.either_left(t_left()), binder(t_right())) ::
Either.either_left(t_left())
def bind_right(%__MODULE__{l_value: l_val, r_value: _r_val, is_left?: true}, _func),
do: left(l_val)
@doc """
Applies the provided function `binder` to the right value of `Either` wrapped in a `Task` and
returns a new task with the result.
## Examples
iex> task = Task.async(fn -> Hike.Either.left("Hello") end)
...> applied_task =bind_right_async(task, fn str -> Either.left(String.upcase(str)) end)
...> Task.await(applied_task)
%Hike.Either{l_value: "Hello", r_value: nil, is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right("Hello") end)
...> applied_task =bind_right_async(task, fn str -> Either.left(String.upcase(str)) end)
...> Task.await(applied_task)
%Hike.Either{l_value: "HELLO", r_value: nil, is_left?: true}
iex> task = Task.async(fn -> Hike.Either.right(10) end)
...> applied_task = bind_right_async(task, fn num -> num * num end)
...> Task.await(applied_task)
%Hike.Either{l_value: nil, r_value: 100, is_left?: false}
"""
@spec bind_right_async(Task.t(), binder(t())) :: Task.t()
def bind_right_async(wrapped_task, binder) when is_function(binder, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
Task.async(fn ->
bind_right(eth, binder)
end)
end
end
@doc """
Matches an `Either` value and applies the corresponding function.
## Examples
iex> (Either.left "hello") |> Either.match(fn str -> String.upcase(str) end, fn ()-> "NOT FOUND" end)
"HELLO"
iex> (Either.right 4) |> Either.match(fn num-> num * num end, fn num-> num + num end)
8
"""
@spec match(Either.either(t_left, t_right), (t_left -> tr), (t_right -> tr)) :: tr
def match(%__MODULE__{l_value: x, is_left?: true} = _either, left_fn, _)
when is_function(left_fn, 1),
do: left_fn.(x)
def match(%__MODULE__{r_value: x, is_left?: false} = _either, _, right_fn)
when is_function(right_fn, 1),
do: right_fn.(x)
@doc """
Matches an `Either` value wrapped in a `Task` and applies the corresponding function asynchronously.
## Examples
iex> task = Task.async(fn -> Hike.Either.left("Hello") end)
...> applied_task =bind_left_async(task, fn str -> Either.left(String.upcase(str)) end)
...> match_async(applied_task , fn x -> "value is : " <> x <> "." end, fn (_)-> "No Result Found." end)
"value is : HELLO."
iex> task = Task.async(fn -> Hike.Either.right("Hello") end)
...> applied_task = map_left_async(task, &String.upcase/1)
...> match_async(applied_task , fn x -> x end, fn (y)-> "value is : " <> y <> "." end)
"value is : Hello."
"""
@spec match_async(Task.t(), (t() -> term()), (t() -> term())) :: Task.t()
def match_async(wrapped_task, left_fn, right_fn)
when is_function(left_fn, 1) and is_function(right_fn, 1) do
case Task.await(wrapped_task) do
%Hike.Either{} = eth ->
match(eth, left_fn, right_fn)
end
end
@doc """
Create new Either from result. if result is `{:ok, val}` `Either` will be in
right state. else if result is `{:error, val}` `Either` will be in left state.
with respective value `val` in respective side.
"""
@spec from_result({:ok, t()}) :: either_right(t())
@spec from_result({:error, t()}) :: either_left(t())
def from_result({:error, val}), do: left(val)
def from_result({:ok, val}), do: right(val)
@doc """
convert `Either` from `Right` state to `Option` `Some` state and `Either` from `Left` state to `Option` `None` state.
## Example
iex> Hike.right(9) |> Hike.Either.to_option()
%Hike.Option{value: 9}
iex> Hike.left(":error") |> Hike.Either.to_option()
%Hike.Option{value: nil}
"""
@spec to_option(Either.either_right(t())) :: Hike.Option.option(t())
def to_option(%Either{l_value: _l_val, r_value: r_val, is_left?: false}),
do: Hike.Option.some(r_val)
@spec to_option(Either.either_left(t())) :: Hike.Option.option()
def to_option(%Either{l_value: _l_val, r_value: _r_val, is_left?: true}), do: Hike.Option.none()
@doc """
convert `Either` form `Right` state to `MayFail` `Success` state and `Either` from `Left` state to `MayFail` `Failure` state.
## Example
iex> Hike.left(":error") |> Hike.Either.to_mayfail()
%Hike.MayFail{failure: ":error", success: nil, is_success?: false}
iex> Hike.right(9) |> Hike.Either.to_mayfail
%Hike.MayFail{failure: nil, success: 9, is_success?: true}
"""
@spec to_mayfail(Either.either_right(t())) :: Hike.MayFail.mayfail_success(t())
def to_mayfail(%Either{l_value: _l_val, r_value: r_val, is_left?: false}),
do: Hike.MayFail.success(r_val)
@spec to_mayfail(Either.either_left(t())) :: Hike.MayFail.mayfail_failure(t())
def to_mayfail(%Either{l_value: l_val, r_value: _r_val, is_left?: true}),
do: Hike.MayFail.failure(l_val)
end
