fp

-module(fp).
-compile([no_auto_import, nowarn_unused_vars]).

-export([fmap/3, new_functor_instance/1, list_functor_instance/0, option_functor_instance/0, result_functor_instance/0, function_functor_instance/0, fmap_list/2, fmap_option/2, fmap_result/2, fmap_function/2, pure/2, ap/3, list_applicative_instance/0, option_applicative_instance/0, result_applicative_instance/0, pure_list/1, pure_option/1, pure_result/1, ap_list/2, ap_option/2, ap_result/2]).
-export_type([functor_instance/4, applicative_instance/5]).

-type functor_instance(EUG, EUH, EUI, EUJ) :: {functor_instance,
        fun((fun((EUG) -> EUH), EUI) -> EUJ)}.

-type applicative_instance(EUK, EUL, EUM, EUN, EUO) :: {applicative_instance,
        fun(() -> functor_instance(EUK, EUL, EUM, EUN)),
        fun((EUK) -> EUM),
        fun((EUO, EUM) -> EUN)}.

-spec fmap(
    fun((EUP) -> EUQ),
    EUR,
    fun(() -> functor_instance(EUP, EUQ, EUR, EUS))
) -> EUS.
fmap(Lhs, Rhs, Instance) ->
    (erlang:element(2, Instance()))(Lhs, Rhs).

-spec new_functor_instance(fun((EUX, fun((EUY) -> EUZ)) -> EVA)) -> functor_instance(EUY, EUZ, EUX, EVA).
new_functor_instance(Fmapper) ->
    {functor_instance, gleam@function:flip(Fmapper)}.

-spec list_functor_instance() -> functor_instance(EVF, EVG, list(EVF), list(EVG)).
list_functor_instance() ->
    new_functor_instance(fun gleam@list:map/2).

-spec option_functor_instance() -> functor_instance(EVN, EVO, gleam@option:option(EVN), gleam@option:option(EVO)).
option_functor_instance() ->
    new_functor_instance(fun gleam@option:map/2).

-spec result_functor_instance() -> functor_instance(EVV, EVW, {ok, EVV} |
    {error, EVX}, {ok, EVW} | {error, EVX}).
result_functor_instance() ->
    new_functor_instance(fun gleam@result:map/2).

-spec function_functor_instance() -> functor_instance(EWG, EWH, fun((EWI) -> EWG), fun((EWI) -> EWH)).
function_functor_instance() ->
    new_functor_instance(fun gleam@function:compose/2).

-spec fmap_list(fun((EWN) -> EWO), list(EWN)) -> list(EWO).
fmap_list(Lhs, Rhs) ->
    fmap(Lhs, Rhs, fun list_functor_instance/0).

-spec fmap_option(fun((EWR) -> EWS), gleam@option:option(EWR)) -> gleam@option:option(EWS).
fmap_option(Lhs, Rhs) ->
    fmap(Lhs, Rhs, fun option_functor_instance/0).

-spec fmap_result(fun((EWV) -> EWW), {ok, EWV} | {error, EWX}) -> {ok, EWW} |
    {error, EWX}.
fmap_result(Lhs, Rhs) ->
    fmap(Lhs, Rhs, fun result_functor_instance/0).

-spec fmap_function(fun((EXC) -> EXD), fun((EXE) -> EXC)) -> fun((EXE) -> EXD).
fmap_function(Lhs, Rhs) ->
    fmap(Lhs, Rhs, fun function_functor_instance/0).

-spec pure(EXF, fun(() -> applicative_instance(EXF, any(), EXH, any(), any()))) -> EXH.
pure(X, Instance) ->
    (erlang:element(3, Instance()))(X).

-spec ap(EXP, EXQ, fun(() -> applicative_instance(any(), any(), EXQ, EXT, EXP))) -> EXT.
ap(Lhs, Rhs, Instance) ->
    (erlang:element(4, Instance()))(Lhs, Rhs).

-spec list_applicative_instance() -> applicative_instance(EXZ, EYA, list(EXZ), list(EYA), list(fun((EXZ) -> EYA))).
list_applicative_instance() ->
    {applicative_instance,
        fun list_functor_instance/0,
        fun(X) -> [X] end,
        fun(Lhs, Rhs) ->
            _pipe = Lhs,
            gleam@list:flat_map(
                _pipe,
                fun(F) -> fmap(F, Rhs, fun list_functor_instance/0) end
            )
        end}.

-spec option_applicative_instance() -> applicative_instance(EYJ, EYK, gleam@option:option(EYJ), gleam@option:option(EYK), gleam@option:option(fun((EYJ) -> EYK))).
option_applicative_instance() ->
    {applicative_instance,
        fun option_functor_instance/0,
        fun(Field@0) -> {some, Field@0} end,
        fun(Lhs, Rhs) ->
            _pipe = Lhs,
            gleam@option:then(
                _pipe,
                fun(F) -> fmap(F, Rhs, fun option_functor_instance/0) end
            )
        end}.

-spec result_applicative_instance() -> applicative_instance(EYT, EYU, {ok, EYT} |
    {error, EYV}, {ok, EYU} | {error, EYV}, {ok, fun((EYT) -> EYU)} |
    {error, EYV}).
result_applicative_instance() ->
    {applicative_instance,
        fun result_functor_instance/0,
        fun(Field@0) -> {ok, Field@0} end,
        fun(Lhs, Rhs) ->
            _pipe = Lhs,
            gleam@result:then(
                _pipe,
                fun(F) -> fmap(F, Rhs, fun result_functor_instance/0) end
            )
        end}.

-spec pure_list(EZH) -> list(EZH).
pure_list(X) ->
    pure(X, fun list_applicative_instance/0).

-spec pure_option(EZJ) -> gleam@option:option(EZJ).
pure_option(X) ->
    pure(X, fun option_applicative_instance/0).

-spec pure_result(EZL) -> {ok, EZL} | {error, any()}.
pure_result(X) ->
    pure(X, fun result_applicative_instance/0).

-spec ap_list(list(fun((EZP) -> EZQ)), list(EZP)) -> list(EZQ).
ap_list(Lhs, Rhs) ->
    ap(Lhs, Rhs, fun list_applicative_instance/0).

-spec ap_option(
    gleam@option:option(fun((EZU) -> EZV)),
    gleam@option:option(EZU)
) -> gleam@option:option(EZV).
ap_option(Lhs, Rhs) ->
    ap(Lhs, Rhs, fun option_applicative_instance/0).

-spec ap_result(
    {ok, fun((EZZ) -> FAA)} | {error, FAB},
    {ok, EZZ} | {error, FAB}
) -> {ok, FAA} | {error, FAB}.
ap_result(Lhs, Rhs) ->
    ap(Lhs, Rhs, fun result_applicative_instance/0).