-module(outcome).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new_defect/1, new_failure/1, error_with_defect/1, error_with_failure/1, into_defect/1, into_failure/1, map_into_defect/2, map_into_failure/2, replace_with_defect/2, replace_with_failure/2, map_error/2, map_defect/2, map_failure/2, tap/2, tap_error/2, tap_defect/2, tap_failure/2, context/2, unwrap_failure/2, extract_error/1, pretty_print/2, print_line/2]).
-export_type([severity/0, problem/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type severity() :: defect | failure.

-type problem(FWT) :: {problem, FWT, severity(), list(binary())}.

-file("src/outcome.gleam", 59).
-spec new_problem(FXE, severity()) -> problem(FXE).
new_problem(Error, Severity) ->
    {problem, Error, Severity, []}.

-file("src/outcome.gleam", 41).
?DOC(
    " Create a Defect\n"
    " If you need the `Problem` type only.\n"
    " Usually you will use `into_defect` instead.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " new_defect(\"Something went wrong\")\n"
    " ```\n"
).
-spec new_defect(FXA) -> problem(FXA).
new_defect(Error) ->
    new_problem(Error, defect).

-file("src/outcome.gleam", 55).
?DOC(
    " Create a Failure\n"
    " If you need the `Problem` type only.\n"
    " Usually you will use `into_failure` instead.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " new_failure(\"Something went wrong\")\n"
    " ```\n"
).
-spec new_failure(FXC) -> problem(FXC).
new_failure(Error) ->
    new_problem(Error, failure).

-file("src/outcome.gleam", 74).
?DOC(
    " Create a Defect wrapped in an Error\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " case something {\n"
    "   True -> Ok(\"Yay\")\n"
    "   False -> error_with_defect(\"Something went wrong\")\n"
    " }\n"
    " ```\n"
).
-spec error_with_defect(FXG) -> {ok, any()} | {error, problem(FXG)}.
error_with_defect(Defect) ->
    {error, new_defect(Defect)}.

-file("src/outcome.gleam", 89).
?DOC(
    " Create Failure wrapped in an Error\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " case something {\n"
    "   True -> Ok(\"Yay\")\n"
    "   False -> error_with_failure(\"Invalid input\")\n"
    " }\n"
    " ```\n"
).
-spec error_with_failure(FXK) -> {ok, any()} | {error, problem(FXK)}.
error_with_failure(Failure) ->
    {error, new_failure(Failure)}.

-file("src/outcome.gleam", 103).
?DOC(
    " Convert an `Error(String)` into an `Error(Defect)`\n"
    " This is useful when you have a `Result(t, String)` and\n"
    " want to convert it into a `Result(t, Problem)`\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(\"Something went wrong\")\n"
    " |> into_defect\n"
    " ```\n"
).
-spec into_defect({ok, FXO} | {error, FXP}) -> {ok, FXO} | {error, problem(FXP)}.
into_defect(Result) ->
    gleam@result:map_error(Result, fun new_defect/1).

-file("src/outcome.gleam", 117).
?DOC(
    " Convert an `Error(String)` into an `Error(Failure)`\n"
    " This is useful when you have a `Result(t, String)` and\n"
    " want to convert it into a `Result(t, Problem)`\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(\"Invalid input\")\n"
    " |> into_failure\n"
    " ```\n"
).
-spec into_failure({ok, FXU} | {error, FXV}) -> {ok, FXU} |
    {error, problem(FXV)}.
into_failure(Result) ->
    gleam@result:map_error(Result, fun new_failure/1).

-file("src/outcome.gleam", 123).
?DOC(
    " Convert an `Error(t)` into a wrapped Defect, by using a mapping function\n"
    " Similar to into_defect, but takes a function to map the error value to a string\n"
).
-spec map_into_defect({ok, FYA} | {error, FYB}, fun((FYB) -> FYE)) -> {ok, FYA} |
    {error, problem(FYE)}.
map_into_defect(Result, Mapper) ->
    _pipe = Result,
    _pipe@1 = gleam@result:map_error(_pipe, Mapper),
    into_defect(_pipe@1).

-file("src/outcome.gleam", 134).
?DOC(
    " Convert an `Error(t)` into a wrapped Failure, by using a mapping function\n"
    " Similar to into_defect, but takes a function to map the error value to a string\n"
).
-spec map_into_failure({ok, FYH} | {error, FYI}, fun((FYI) -> FYL)) -> {ok, FYH} |
    {error, problem(FYL)}.
map_into_failure(Result, Mapper) ->
    _pipe = Result,
    _pipe@1 = gleam@result:map_error(_pipe, Mapper),
    into_failure(_pipe@1).

-file("src/outcome.gleam", 151).
?DOC(
    " Replaces an `Error(t)` with an `Error(Defect)`\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(Nil)\n"
    " |> replace_with_defect(\"Something went wrong\")\n"
    " ```\n"
).
-spec replace_with_defect({ok, FYO} | {error, any()}, FYS) -> {ok, FYO} |
    {error, problem(FYS)}.
replace_with_defect(Result, E) ->
    gleam@result:replace_error(Result, new_defect(E)).

-file("src/outcome.gleam", 163).
?DOC(
    " Replaces any Error(t) with an Error(Failure)\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(Nil)\n"
    " |> replace_with_failure(\"Invalid input\")\n"
    " ```\n"
).
-spec replace_with_failure({ok, FYV} | {error, any()}, FYZ) -> {ok, FYV} |
    {error, problem(FYZ)}.
replace_with_failure(Result, E) ->
    gleam@result:replace_error(Result, new_failure(E)).

-file("src/outcome.gleam", 171).
-spec map_error_in_problem(problem(FZC), fun((FZC) -> FZC)) -> problem(FZC).
map_error_in_problem(Problem, Mapper) ->
    _record = Problem,
    {problem,
        Mapper(erlang:element(2, Problem)),
        erlang:element(3, _record),
        erlang:element(4, _record)}.

-file("src/outcome.gleam", 178).
-spec map_defect_in_problem(problem(FZF), fun((FZF) -> FZF)) -> problem(FZF).
map_defect_in_problem(Problem, Mapper) ->
    case erlang:element(3, Problem) of
        defect ->
            _record = Problem,
            {problem,
                Mapper(erlang:element(2, Problem)),
                erlang:element(3, _record),
                erlang:element(4, _record)};

        _ ->
            Problem
    end.

-file("src/outcome.gleam", 188).
-spec map_failure_in_problem(problem(FZI), fun((FZI) -> FZI)) -> problem(FZI).
map_failure_in_problem(Problem, Mapper) ->
    case erlang:element(3, Problem) of
        failure ->
            _record = Problem,
            {problem,
                Mapper(erlang:element(2, Problem)),
                erlang:element(3, _record),
                erlang:element(4, _record)};

        _ ->
            Problem
    end.

-file("src/outcome.gleam", 199).
?DOC(" Map the error value inside a Problem\n").
-spec map_error({ok, FZL} | {error, problem(FZM)}, fun((FZM) -> FZM)) -> {ok,
        FZL} |
    {error, problem(FZM)}.
map_error(Outcome, Mapper) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> map_error_in_problem(_capture, Mapper) end
    ).

-file("src/outcome.gleam", 206).
-spec map_defect({ok, FZR} | {error, problem(FZS)}, fun((FZS) -> FZS)) -> {ok,
        FZR} |
    {error, problem(FZS)}.
map_defect(Outcome, Mapper) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> map_defect_in_problem(_capture, Mapper) end
    ).

-file("src/outcome.gleam", 210).
-spec map_failure({ok, FZW} | {error, problem(FZX)}, fun((FZX) -> FZX)) -> {ok,
        FZW} |
    {error, problem(FZX)}.
map_failure(Outcome, Mapper) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> map_failure_in_problem(_capture, Mapper) end
    ).

-file("src/outcome.gleam", 218).
-spec tap_error_in_problem(problem(GAB), fun((GAB) -> any())) -> problem(GAB).
tap_error_in_problem(Problem, Fun) ->
    Fun(erlang:element(2, Problem)),
    Problem.

-file("src/outcome.gleam", 226).
-spec tap_defect_in_problem(problem(GAF), fun((GAF) -> any())) -> problem(GAF).
tap_defect_in_problem(Problem, Fun) ->
    case erlang:element(3, Problem) of
        defect ->
            Fun(erlang:element(2, Problem)),
            Problem;

        _ ->
            Problem
    end.

-file("src/outcome.gleam", 239).
-spec tap_failure_in_problem(problem(GAJ), fun((GAJ) -> any())) -> problem(GAJ).
tap_failure_in_problem(Problem, Fun) ->
    case erlang:element(3, Problem) of
        failure ->
            Fun(erlang:element(2, Problem)),
            Problem;

        _ ->
            Problem
    end.

-file("src/outcome.gleam", 253).
?DOC(" Use tap functions to log the errors\n").
-spec tap({ok, GAN} | {error, problem(GAO)}, fun((problem(GAO)) -> any())) -> {ok,
        GAN} |
    {error, problem(GAO)}.
tap(Outcome, Fun) ->
    gleam@result:map_error(
        Outcome,
        fun(Problem) ->
            Fun(Problem),
            Problem
        end
    ).

-file("src/outcome.gleam", 263).
-spec tap_error({ok, GAV} | {error, problem(GAW)}, fun((GAW) -> any())) -> {ok,
        GAV} |
    {error, problem(GAW)}.
tap_error(Outcome, Fun) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> tap_error_in_problem(_capture, Fun) end
    ).

-file("src/outcome.gleam", 270).
-spec tap_defect({ok, GBC} | {error, problem(GBD)}, fun((GBD) -> any())) -> {ok,
        GBC} |
    {error, problem(GBD)}.
tap_defect(Outcome, Fun) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> tap_defect_in_problem(_capture, Fun) end
    ).

-file("src/outcome.gleam", 277).
-spec tap_failure({ok, GBJ} | {error, problem(GBK)}, fun((GBK) -> any())) -> {ok,
        GBJ} |
    {error, problem(GBK)}.
tap_failure(Outcome, Fun) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> tap_failure_in_problem(_capture, Fun) end
    ).

-file("src/outcome.gleam", 306).
-spec push_to_stack(list(binary()), binary()) -> list(binary()).
push_to_stack(Stack, Entry) ->
    [Entry | Stack].

-file("src/outcome.gleam", 310).
-spec add_context_to_problem(problem(GBX), binary()) -> problem(GBX).
add_context_to_problem(Problem, Value) ->
    _record = Problem,
    {problem,
        erlang:element(2, _record),
        erlang:element(3, _record),
        push_to_stack(erlang:element(4, Problem), Value)}.

-file("src/outcome.gleam", 299).
?DOC(
    " Add context to an Outcome\n"
    " This will add a Context entry to the stack\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(\"Something went wrong\")\n"
    " |> into_defect\n"
    " |> context(\"In find user function\")\n"
    " ```\n"
).
-spec context({ok, GBQ} | {error, problem(GBR)}, binary()) -> {ok, GBQ} |
    {error, problem(GBR)}.
context(Outcome, Context) ->
    gleam@result:map_error(
        Outcome,
        fun(_capture) -> add_context_to_problem(_capture, Context) end
    ).

-file("src/outcome.gleam", 327).
?DOC(
    " Use this to show a failure to a user.\n"
    " If the Problem is a failure, it will show that\n"
    " otherwise it will show the default message given.\n"
    " We don't want to show defect messages to users.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " case result {\n"
    "  Ok(value) -> io.debug(\"Success\")\n"
    "  Error(problem) -> io.error(unwrap_failure(problem, \"Something went wrong\"))\n"
    " }\n"
    " ```\n"
).
-spec unwrap_failure(problem(GCA), GCA) -> GCA.
unwrap_failure(Problem, Default_value) ->
    case erlang:element(3, Problem) of
        defect ->
            Default_value;

        failure ->
            erlang:element(2, Problem)
    end.

-file("src/outcome.gleam", 339).
-spec problem_to_error(problem(GCI)) -> GCI.
problem_to_error(Problem) ->
    erlang:element(2, Problem).

-file("src/outcome.gleam", 335).
?DOC(" Remove the Problem wrapping, returning just your error.\n").
-spec extract_error({ok, GCC} | {error, problem(GCD)}) -> {ok, GCC} |
    {error, GCD}.
extract_error(Outcome) ->
    _pipe = Outcome,
    gleam@result:map_error(_pipe, fun problem_to_error/1).

-file("src/outcome.gleam", 417).
-spec long_suffix(severity()) -> binary().
long_suffix(Severity) ->
    case Severity of
        defect ->
            <<"Defect: "/utf8>>;

        failure ->
            <<"Failure: "/utf8>>
    end.

-file("src/outcome.gleam", 413).
-spec prettry_print_problem_error(severity(), binary()) -> binary().
prettry_print_problem_error(Severity, Error) ->
    <<(long_suffix(Severity))/binary, Error/binary>>.

-file("src/outcome.gleam", 424).
-spec pretty_print_stack_entry(binary()) -> binary().
pretty_print_stack_entry(Value) ->
    Value.

-file("src/outcome.gleam", 343).
-spec stack_to_lines(list(binary())) -> list(binary()).
stack_to_lines(Stack) ->
    _pipe = Stack,
    gleam@list:map(_pipe, fun pretty_print_stack_entry/1).

-file("src/outcome.gleam", 390).
-spec pretty_print_with_joins(
    problem(GCP),
    binary(),
    binary(),
    fun((GCP) -> binary())
) -> binary().
pretty_print_with_joins(Problem, Join_current, Join_stack, To_s) ->
    Current = prettry_print_problem_error(
        erlang:element(3, Problem),
        To_s(erlang:element(2, Problem))
    ),
    Stack = <<Join_current/binary,
        (begin
            _pipe = erlang:element(4, Problem),
            _pipe@1 = stack_to_lines(_pipe),
            gleam@string:join(_pipe@1, Join_stack)
        end)/binary>>,
    Stack@1 = case erlang:element(4, Problem) of
        [] ->
            <<""/utf8>>;

        _ ->
            Stack
    end,
    <<Current/binary, Stack@1/binary>>.

-file("src/outcome.gleam", 368).
?DOC(
    " Pretty print a Problem, including the stack.\n"
    " The latest problem appears at the top of the stack.\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(\"Something went wrong\")\n"
    " |> into_defect\n"
    " |> context(\"In find user function\")\n"
    " |> context(\"More context\")\n"
    " |> pretty_print(function.identity)\n"
    " ```\n"
    "\n"
    " ```\n"
    " Defect: Something went wrong\n"
    "\n"
    " stack:\n"
    "  More context\n"
    "  In find user function\n"
    " ```\n"
).
-spec pretty_print(problem(GCL), fun((GCL) -> binary())) -> binary().
pretty_print(Problem, To_s) ->
    pretty_print_with_joins(
        Problem,
        <<"\n\nstack:\n  "/utf8>>,
        <<"\n  "/utf8>>,
        To_s
    ).

-file("src/outcome.gleam", 386).
?DOC(
    " Print problem in one line\n"
    "\n"
    " ## Example\n"
    "\n"
    " ```gleam\n"
    " Error(\"Something went wrong\")\n"
    " |> into_defect\n"
    " |> context(\"In find user function\")\n"
    " |> print_line(function.identity)\n"
    " ```\n"
    "\n"
    " ```\n"
    " Defect: Something went wrong << In find user function\n"
    " ```\n"
).
-spec print_line(problem(GCN), fun((GCN) -> binary())) -> binary().
print_line(Problem, To_s) ->
    pretty_print_with_joins(Problem, <<" << "/utf8>>, <<" < "/utf8>>, To_s).