gleamgen

-module(gleamgen@function).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new0/2, new1/3, new2/4, new3/5, new4/6, new5/7, new6/8, new7/9, new8/10, new9/11, to_unchecked/1, get_function_name/1, render/3, anonymous/1]).
-export_type([function_/2]).

-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 function_(MWA, MWB) :: {function,
        list({binary(),
            gleamgen@types:generated_type(gleamgen@types:unchecked())}),
        gleamgen@types:generated_type(MWB),
        gleamgen@expression:expression(MWB)} |
    {gleam_phantom, MWA}.

-file("src/gleamgen/function.gleam", 18).
-spec new0(
    gleamgen@types:generated_type(MWC),
    fun(() -> gleamgen@expression:expression(MWC))
) -> function_(fun((any()) -> MWC), MWC).
new0(Returns, Handler) ->
    Body = Handler(),
    {function, [], Returns, Body}.

-file("src/gleamgen/function.gleam", 26).
-spec new1(
    {binary(), gleamgen@types:generated_type(MWI)},
    gleamgen@types:generated_type(MWK),
    fun((gleamgen@expression:expression(MWI)) -> gleamgen@expression:expression(MWK))
) -> function_(fun((MWI) -> MWK), MWK).
new1(Arg1, Returns, Handler) ->
    Body = Handler(gleamgen@expression:unchecked_ident(erlang:element(1, Arg1))),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 38).
-spec new2(
    {binary(), gleamgen@types:generated_type(MWQ)},
    {binary(), gleamgen@types:generated_type(MWS)},
    gleamgen@types:generated_type(MWU),
    fun((gleamgen@expression:expression(MWQ), gleamgen@expression:expression(MWS)) -> gleamgen@expression:expression(MWU))
) -> function_(fun((MWQ, MWS) -> MWU), MWU).
new2(Arg1, Arg2, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 60).
-spec new3(
    {binary(), gleamgen@types:generated_type(MXB)},
    {binary(), gleamgen@types:generated_type(MXD)},
    {binary(), gleamgen@types:generated_type(MXF)},
    gleamgen@types:generated_type(MXH),
    fun((gleamgen@expression:expression(MXB), gleamgen@expression:expression(MXD), gleamgen@expression:expression(MXF)) -> gleamgen@expression:expression(MXH))
) -> function_(fun((MXB, MXD, MXF) -> MXH), MXH).
new3(Arg1, Arg2, Arg3, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 89).
-spec new4(
    {binary(), gleamgen@types:generated_type(MXP)},
    {binary(), gleamgen@types:generated_type(MXR)},
    {binary(), gleamgen@types:generated_type(MXT)},
    {binary(), gleamgen@types:generated_type(MXV)},
    gleamgen@types:generated_type(MXX),
    fun((gleamgen@expression:expression(MXP), gleamgen@expression:expression(MXR), gleamgen@expression:expression(MXT), gleamgen@expression:expression(MXV)) -> gleamgen@expression:expression(MXX))
) -> function_(fun((MXP, MXR, MXT, MXV) -> MXX), MXX).
new4(Arg1, Arg2, Arg3, Arg4, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 122).
-spec new5(
    {binary(), gleamgen@types:generated_type(MYG)},
    {binary(), gleamgen@types:generated_type(MYI)},
    {binary(), gleamgen@types:generated_type(MYK)},
    {binary(), gleamgen@types:generated_type(MYM)},
    {binary(), gleamgen@types:generated_type(MYO)},
    gleamgen@types:generated_type(MYQ),
    fun((gleamgen@expression:expression(MYG), gleamgen@expression:expression(MYI), gleamgen@expression:expression(MYK), gleamgen@expression:expression(MYM), gleamgen@expression:expression(MYO)) -> gleamgen@expression:expression(MYQ))
) -> function_(fun((MYG, MYI, MYK, MYM, MYO) -> MYQ), MYQ).
new5(Arg1, Arg2, Arg3, Arg4, Arg5, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg5))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end},
            {erlang:element(1, Arg5),
                begin
                    _pipe@4 = erlang:element(2, Arg5),
                    gleamgen_ffi:identity(_pipe@4)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 159).
-spec new6(
    {binary(), gleamgen@types:generated_type(MZA)},
    {binary(), gleamgen@types:generated_type(MZC)},
    {binary(), gleamgen@types:generated_type(MZE)},
    {binary(), gleamgen@types:generated_type(MZG)},
    {binary(), gleamgen@types:generated_type(MZI)},
    {binary(), gleamgen@types:generated_type(MZK)},
    gleamgen@types:generated_type(MZM),
    fun((gleamgen@expression:expression(MZA), gleamgen@expression:expression(MZC), gleamgen@expression:expression(MZE), gleamgen@expression:expression(MZG), gleamgen@expression:expression(MZI), gleamgen@expression:expression(MZK)) -> gleamgen@expression:expression(MZM))
) -> function_(fun((MZA, MZC, MZE, MZG, MZI, MZK) -> MZM), MZM).
new6(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg5)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg6))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end},
            {erlang:element(1, Arg5),
                begin
                    _pipe@4 = erlang:element(2, Arg5),
                    gleamgen_ffi:identity(_pipe@4)
                end},
            {erlang:element(1, Arg6),
                begin
                    _pipe@5 = erlang:element(2, Arg6),
                    gleamgen_ffi:identity(_pipe@5)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 200).
-spec new7(
    {binary(), gleamgen@types:generated_type(MZX)},
    {binary(), gleamgen@types:generated_type(MZZ)},
    {binary(), gleamgen@types:generated_type(NAB)},
    {binary(), gleamgen@types:generated_type(NAD)},
    {binary(), gleamgen@types:generated_type(NAF)},
    {binary(), gleamgen@types:generated_type(NAH)},
    {binary(), gleamgen@types:generated_type(NAJ)},
    gleamgen@types:generated_type(NAL),
    fun((gleamgen@expression:expression(MZX), gleamgen@expression:expression(MZZ), gleamgen@expression:expression(NAB), gleamgen@expression:expression(NAD), gleamgen@expression:expression(NAF), gleamgen@expression:expression(NAH), gleamgen@expression:expression(NAJ)) -> gleamgen@expression:expression(NAL))
) -> function_(fun((MZX, MZZ, NAB, NAD, NAF, NAH, NAJ) -> NAL), NAL).
new7(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg5)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg6)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg7))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end},
            {erlang:element(1, Arg5),
                begin
                    _pipe@4 = erlang:element(2, Arg5),
                    gleamgen_ffi:identity(_pipe@4)
                end},
            {erlang:element(1, Arg6),
                begin
                    _pipe@5 = erlang:element(2, Arg6),
                    gleamgen_ffi:identity(_pipe@5)
                end},
            {erlang:element(1, Arg7),
                begin
                    _pipe@6 = erlang:element(2, Arg7),
                    gleamgen_ffi:identity(_pipe@6)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 245).
-spec new8(
    {binary(), gleamgen@types:generated_type(NAX)},
    {binary(), gleamgen@types:generated_type(NAZ)},
    {binary(), gleamgen@types:generated_type(NBB)},
    {binary(), gleamgen@types:generated_type(NBD)},
    {binary(), gleamgen@types:generated_type(NBF)},
    {binary(), gleamgen@types:generated_type(NBH)},
    {binary(), gleamgen@types:generated_type(NBJ)},
    {binary(), gleamgen@types:generated_type(NBL)},
    gleamgen@types:generated_type(NBN),
    fun((gleamgen@expression:expression(NAX), gleamgen@expression:expression(NAZ), gleamgen@expression:expression(NBB), gleamgen@expression:expression(NBD), gleamgen@expression:expression(NBF), gleamgen@expression:expression(NBH), gleamgen@expression:expression(NBJ), gleamgen@expression:expression(NBL)) -> gleamgen@expression:expression(NBN))
) -> function_(fun((NAX, NAZ, NBB, NBD, NBF, NBH, NBJ, NBL) -> NBN), NBN).
new8(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg5)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg6)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg7)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg8))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end},
            {erlang:element(1, Arg5),
                begin
                    _pipe@4 = erlang:element(2, Arg5),
                    gleamgen_ffi:identity(_pipe@4)
                end},
            {erlang:element(1, Arg6),
                begin
                    _pipe@5 = erlang:element(2, Arg6),
                    gleamgen_ffi:identity(_pipe@5)
                end},
            {erlang:element(1, Arg7),
                begin
                    _pipe@6 = erlang:element(2, Arg7),
                    gleamgen_ffi:identity(_pipe@6)
                end},
            {erlang:element(1, Arg8),
                begin
                    _pipe@7 = erlang:element(2, Arg8),
                    gleamgen_ffi:identity(_pipe@7)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 294).
-spec new9(
    {binary(), gleamgen@types:generated_type(NCA)},
    {binary(), gleamgen@types:generated_type(NCC)},
    {binary(), gleamgen@types:generated_type(NCE)},
    {binary(), gleamgen@types:generated_type(NCG)},
    {binary(), gleamgen@types:generated_type(NCI)},
    {binary(), gleamgen@types:generated_type(NCK)},
    {binary(), gleamgen@types:generated_type(NCM)},
    {binary(), gleamgen@types:generated_type(NCO)},
    {binary(), gleamgen@types:generated_type(NCQ)},
    gleamgen@types:generated_type(NCS),
    fun((gleamgen@expression:expression(NCA), gleamgen@expression:expression(NCC), gleamgen@expression:expression(NCE), gleamgen@expression:expression(NCG), gleamgen@expression:expression(NCI), gleamgen@expression:expression(NCK), gleamgen@expression:expression(NCM), gleamgen@expression:expression(NCO), gleamgen@expression:expression(NCQ)) -> gleamgen@expression:expression(NCS))
) -> function_(fun((NCA, NCC, NCE, NCG, NCI, NCK, NCM, NCO, NCQ) -> NCS), NCS).
new9(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg1)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg2)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg3)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg4)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg5)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg6)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg7)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg8)),
        gleamgen@expression:unchecked_ident(erlang:element(1, Arg9))
    ),
    {function,
        [{erlang:element(1, Arg1),
                begin
                    _pipe = erlang:element(2, Arg1),
                    gleamgen_ffi:identity(_pipe)
                end},
            {erlang:element(1, Arg2),
                begin
                    _pipe@1 = erlang:element(2, Arg2),
                    gleamgen_ffi:identity(_pipe@1)
                end},
            {erlang:element(1, Arg3),
                begin
                    _pipe@2 = erlang:element(2, Arg3),
                    gleamgen_ffi:identity(_pipe@2)
                end},
            {erlang:element(1, Arg4),
                begin
                    _pipe@3 = erlang:element(2, Arg4),
                    gleamgen_ffi:identity(_pipe@3)
                end},
            {erlang:element(1, Arg5),
                begin
                    _pipe@4 = erlang:element(2, Arg5),
                    gleamgen_ffi:identity(_pipe@4)
                end},
            {erlang:element(1, Arg6),
                begin
                    _pipe@5 = erlang:element(2, Arg6),
                    gleamgen_ffi:identity(_pipe@5)
                end},
            {erlang:element(1, Arg7),
                begin
                    _pipe@6 = erlang:element(2, Arg7),
                    gleamgen_ffi:identity(_pipe@6)
                end},
            {erlang:element(1, Arg8),
                begin
                    _pipe@7 = erlang:element(2, Arg8),
                    gleamgen_ffi:identity(_pipe@7)
                end},
            {erlang:element(1, Arg9),
                begin
                    _pipe@8 = erlang:element(2, Arg9),
                    gleamgen_ffi:identity(_pipe@8)
                end}],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 354).
-spec to_unchecked(function_(any(), any())) -> function_(gleamgen@types:unchecked(), gleamgen@types:unchecked()).
to_unchecked(Type_) ->
    gleamgen_ffi:identity(Type_).

-file("src/gleamgen/function.gleam", 361).
?DOC(false).
-spec get_function_name(any()) -> binary().
get_function_name(Type_) ->
    gleamgen_ffi:get_function_name(Type_).

-file("src/gleamgen/function.gleam", 374).
-spec render(
    function_(any(), any()),
    gleamgen@render:context(),
    gleam@option:option(binary())
) -> gleamgen@render:rendered().
render(Func, Context, Name) ->
    Rendered_args = begin
        _pipe = erlang:element(2, Func),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) ->
                gleamgen@expression:render_attribute(_capture, Context)
            end
        ),
        gleamgen@render:pretty_list(_pipe@1)
    end,
    Rendered_type = gleamgen@types:render_type(erlang:element(3, Func)),
    Rendered_body = gleamgen@expression:render(
        erlang:element(4, Func),
        begin
            _record = Context,
            {context, erlang:element(2, _record), false}
        end
    ),
    {Rendered_name, Force_newlines} = case Name of
        {some, Name@1} ->
            {glam@doc:from_string(<<" "/utf8, Name@1/binary>>), true};

        none ->
            {{concat, []}, false}
    end,
    _pipe@2 = glam@doc:concat(
        [glam@doc:from_string(<<"fn"/utf8>>),
            Rendered_name,
            Rendered_args,
            {break, <<" "/utf8>>, <<""/utf8>>},
            case Rendered_type of
                {ok, Returned} ->
                    glam@doc:concat(
                        [glam@doc:from_string(<<"->"/utf8>>),
                            {break, <<" "/utf8>>, <<""/utf8>>},
                            erlang:element(2, Returned),
                            {break, <<" "/utf8>>, <<""/utf8>>}]
                    );

                {error, _} ->
                    {concat, []}
            end,
            gleamgen@render:body(
                erlang:element(2, Rendered_body),
                Force_newlines
            )]
    ),
    {render,
        _pipe@2,
        gleamgen@render:merge_details(
            begin
                _pipe@3 = Rendered_type,
                _pipe@4 = gleam@result:map(
                    _pipe@3,
                    fun(T) -> erlang:element(3, T) end
                ),
                gleam@result:unwrap(_pipe@4, {rendered_details, []})
            end,
            erlang:element(3, Rendered_body)
        )}.

-file("src/gleamgen/function.gleam", 363).
-spec anonymous(function_(NDN, any())) -> gleamgen@expression:expression(NDN).
anonymous(Function) ->
    Type_ = begin
        _pipe = erlang:element(2, Function),
        _pipe@1 = gleam@list:map(_pipe, fun gleam@pair:second/1),
        gleamgen@types:unchecked_function(
            _pipe@1,
            begin
                _pipe@2 = erlang:element(3, Function),
                gleamgen_ffi:identity(_pipe@2)
            end
        )
    end,
    Renderer = fun(Context) -> render(Function, Context, none) end,
    gleamgen@expression:new_anonymous_function(Renderer, Type_).