Well, for example: I built this library largely out of necessity in refactoring an existing codebase. It’s definitely easier to retrofit ok_then into existing code that returns :ok/:error, because for the happy codepath the data format doesn’t actually change. If I introduce an additional wrapper for :some/:none, then all the code that touches the refactored functions would need to be adjusted to handle the new data format (unwrapping {:some, value}), which makes it tougher to make incremental changes.
The good news, though, is that it’s really easy to get ok_then to work with :some/:none, because all the generic tools are readily available (and documented):
@spec some_unwrap!(Result.result_input()) :: any()
def some_unwrap!(result) do
Result.tagged_unwrap!(result, :some)
end
{:some, "hello"} |> some_unwrap!() # "hello"
:none |> some_unwrap!() # **(ArgumentError) Value is not tagged some: :none.
@spec default_some(input, (() -> out) | out) :: input | {:some, out}
when input: Result.result_input(), out: any()
def default_some(result, func_or_value) do
Result.default_as(result, :some, func_or_value)
end
{:some, "hello"} |> Result.default_some("default") # {:some, "hello"}
:none |> Result.default_some("default") # {:some, "default"}
There’s a Result.ok_or(t, e) type defined that excludes :none, if you want to use that in typespecs, and you can build your own functions pretty easily to simplify the double wrapping and unwrapping, if you like:
"hello"
|> Result.from_as(:some) # {:some, "hello"}
|> Result.from() # {:ok, {:some, "hello"}}
|> Result.unwrap!() # {:some, "hello"}
|> Result.tagged_unwrap!(:some) # "hello"
nil
|> Result.from_as(:some) # :none
|> Result.from() # {:ok, :none}
|> Result.unwrap!() # :none
|> Result.tagged_unwrap!(:some) # **(ArgumentError) Value is not tagged some: :none.
I’d actually be open to adding a module in ok_then to support this paradigm further.
