-module(gleamgen@function).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/function.gleam").
-export([new_dynamic/3, new0/2, new1/3, new2/4, new3/5, new4/6, new5/7, new6/8, new7/9, new8/10, new9/11, to_dynamic/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_(OEG, OEH) :: {function,
        list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_())),
        gleamgen@type_:generated_type(OEH),
        gleamgen@expression:expression(OEH)} |
    {gleam_phantom, OEG}.

-file("src/gleamgen/function.gleam", 18).
-spec new_dynamic(
    list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_())),
    gleamgen@type_:generated_type(OEK),
    fun((list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))) -> gleamgen@expression:expression(OEK))
) -> function_(gleamgen@type_:dynamic_(), OEK).
new_dynamic(Parameters, Returns, Handler) ->
    Body = Handler(
        begin
            _pipe = Parameters,
            gleam@list:map(
                _pipe,
                fun(Param) ->
                    gleamgen@expression:raw(gleamgen@parameter:name(Param))
                end
            )
        end
    ),
    {function, Parameters, Returns, Body}.

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

-file("src/gleamgen/function.gleam", 40).
-spec new1(
    gleamgen@parameter:parameter(OEW),
    gleamgen@type_:generated_type(OEY),
    fun((gleamgen@expression:expression(OEW)) -> gleamgen@expression:expression(OEY))
) -> function_(fun((OEW) -> OEY), OEY).
new1(Param1, Returns, Handler) ->
    Body = Handler(gleamgen@expression:raw(gleamgen@parameter:name(Param1))),
    {function, [gleamgen_ffi:identity(Param1)], Returns, Body}.

-file("src/gleamgen/function.gleam", 53).
-spec new2(
    gleamgen@parameter:parameter(OFE),
    gleamgen@parameter:parameter(OFG),
    gleamgen@type_:generated_type(OFI),
    fun((gleamgen@expression:expression(OFE), gleamgen@expression:expression(OFG)) -> gleamgen@expression:expression(OFI))
) -> function_(fun((OFE, OFG) -> OFI), OFI).
new2(Param1, Param2, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2))
    ),
    {function,
        [gleamgen_ffi:identity(Param1), gleamgen_ffi:identity(Param2)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 77).
-spec new3(
    gleamgen@parameter:parameter(OFP),
    gleamgen@parameter:parameter(OFR),
    gleamgen@parameter:parameter(OFT),
    gleamgen@type_:generated_type(OFV),
    fun((gleamgen@expression:expression(OFP), gleamgen@expression:expression(OFR), gleamgen@expression:expression(OFT)) -> gleamgen@expression:expression(OFV))
) -> function_(fun((OFP, OFR, OFT) -> OFV), OFV).
new3(Param1, Param2, Param3, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 105).
-spec new4(
    gleamgen@parameter:parameter(OGD),
    gleamgen@parameter:parameter(OGF),
    gleamgen@parameter:parameter(OGH),
    gleamgen@parameter:parameter(OGJ),
    gleamgen@type_:generated_type(OGL),
    fun((gleamgen@expression:expression(OGD), gleamgen@expression:expression(OGF), gleamgen@expression:expression(OGH), gleamgen@expression:expression(OGJ)) -> gleamgen@expression:expression(OGL))
) -> function_(fun((OGD, OGF, OGH, OGJ) -> OGL), OGL).
new4(Param1, Param2, Param3, Param4, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 137).
-spec new5(
    gleamgen@parameter:parameter(OGU),
    gleamgen@parameter:parameter(OGW),
    gleamgen@parameter:parameter(OGY),
    gleamgen@parameter:parameter(OHA),
    gleamgen@parameter:parameter(OHC),
    gleamgen@type_:generated_type(OHE),
    fun((gleamgen@expression:expression(OGU), gleamgen@expression:expression(OGW), gleamgen@expression:expression(OGY), gleamgen@expression:expression(OHA), gleamgen@expression:expression(OHC)) -> gleamgen@expression:expression(OHE))
) -> function_(fun((OGU, OGW, OGY, OHA, OHC) -> OHE), OHE).
new5(Param1, Param2, Param3, Param4, Param5, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param5))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4),
            gleamgen_ffi:identity(Param5)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 173).
-spec new6(
    gleamgen@parameter:parameter(OHO),
    gleamgen@parameter:parameter(OHQ),
    gleamgen@parameter:parameter(OHS),
    gleamgen@parameter:parameter(OHU),
    gleamgen@parameter:parameter(OHW),
    gleamgen@parameter:parameter(OHY),
    gleamgen@type_:generated_type(OIA),
    fun((gleamgen@expression:expression(OHO), gleamgen@expression:expression(OHQ), gleamgen@expression:expression(OHS), gleamgen@expression:expression(OHU), gleamgen@expression:expression(OHW), gleamgen@expression:expression(OHY)) -> gleamgen@expression:expression(OIA))
) -> function_(fun((OHO, OHQ, OHS, OHU, OHW, OHY) -> OIA), OIA).
new6(Param1, Param2, Param3, Param4, Param5, Param6, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param5)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param6))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4),
            gleamgen_ffi:identity(Param5),
            gleamgen_ffi:identity(Param6)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 213).
-spec new7(
    gleamgen@parameter:parameter(OIL),
    gleamgen@parameter:parameter(OIN),
    gleamgen@parameter:parameter(OIP),
    gleamgen@parameter:parameter(OIR),
    gleamgen@parameter:parameter(OIT),
    gleamgen@parameter:parameter(OIV),
    gleamgen@parameter:parameter(OIX),
    gleamgen@type_:generated_type(OIZ),
    fun((gleamgen@expression:expression(OIL), gleamgen@expression:expression(OIN), gleamgen@expression:expression(OIP), gleamgen@expression:expression(OIR), gleamgen@expression:expression(OIT), gleamgen@expression:expression(OIV), gleamgen@expression:expression(OIX)) -> gleamgen@expression:expression(OIZ))
) -> function_(fun((OIL, OIN, OIP, OIR, OIT, OIV, OIX) -> OIZ), OIZ).
new7(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Returns, Handler) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param5)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param6)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param7))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4),
            gleamgen_ffi:identity(Param5),
            gleamgen_ffi:identity(Param6),
            gleamgen_ffi:identity(Param7)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 260).
-spec new8(
    gleamgen@parameter:parameter(OJL),
    gleamgen@parameter:parameter(OJN),
    gleamgen@parameter:parameter(OJP),
    gleamgen@parameter:parameter(OJR),
    gleamgen@parameter:parameter(OJT),
    gleamgen@parameter:parameter(OJV),
    gleamgen@parameter:parameter(OJX),
    gleamgen@parameter:parameter(OJZ),
    gleamgen@type_:generated_type(OKB),
    fun((gleamgen@expression:expression(OJL), gleamgen@expression:expression(OJN), gleamgen@expression:expression(OJP), gleamgen@expression:expression(OJR), gleamgen@expression:expression(OJT), gleamgen@expression:expression(OJV), gleamgen@expression:expression(OJX), gleamgen@expression:expression(OJZ)) -> gleamgen@expression:expression(OKB))
) -> function_(fun((OJL, OJN, OJP, OJR, OJT, OJV, OJX, OJZ) -> OKB), OKB).
new8(
    Param1,
    Param2,
    Param3,
    Param4,
    Param5,
    Param6,
    Param7,
    Param8,
    Returns,
    Handler
) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param5)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param6)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param7)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param8))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4),
            gleamgen_ffi:identity(Param5),
            gleamgen_ffi:identity(Param6),
            gleamgen_ffi:identity(Param7),
            gleamgen_ffi:identity(Param8)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 311).
-spec new9(
    gleamgen@parameter:parameter(OKO),
    gleamgen@parameter:parameter(OKQ),
    gleamgen@parameter:parameter(OKS),
    gleamgen@parameter:parameter(OKU),
    gleamgen@parameter:parameter(OKW),
    gleamgen@parameter:parameter(OKY),
    gleamgen@parameter:parameter(OLA),
    gleamgen@parameter:parameter(OLC),
    gleamgen@parameter:parameter(OLE),
    gleamgen@type_:generated_type(OLG),
    fun((gleamgen@expression:expression(OKO), gleamgen@expression:expression(OKQ), gleamgen@expression:expression(OKS), gleamgen@expression:expression(OKU), gleamgen@expression:expression(OKW), gleamgen@expression:expression(OKY), gleamgen@expression:expression(OLA), gleamgen@expression:expression(OLC), gleamgen@expression:expression(OLE)) -> gleamgen@expression:expression(OLG))
) -> function_(fun((OKO, OKQ, OKS, OKU, OKW, OKY, OLA, OLC, OLE) -> OLG), OLG).
new9(
    Param1,
    Param2,
    Param3,
    Param4,
    Param5,
    Param6,
    Param7,
    Param8,
    Param9,
    Returns,
    Handler
) ->
    Body = Handler(
        gleamgen@expression:raw(gleamgen@parameter:name(Param1)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param2)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param3)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param4)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param5)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param6)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param7)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param8)),
        gleamgen@expression:raw(gleamgen@parameter:name(Param9))
    ),
    {function,
        [gleamgen_ffi:identity(Param1),
            gleamgen_ffi:identity(Param2),
            gleamgen_ffi:identity(Param3),
            gleamgen_ffi:identity(Param4),
            gleamgen_ffi:identity(Param5),
            gleamgen_ffi:identity(Param6),
            gleamgen_ffi:identity(Param7),
            gleamgen_ffi:identity(Param8),
            gleamgen_ffi:identity(Param9)],
        Returns,
        Body}.

-file("src/gleamgen/function.gleam", 371).
-spec to_dynamic(function_(any(), any())) -> function_(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()).
to_dynamic(Type_) ->
    gleamgen_ffi:identity(Type_).

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

-file("src/gleamgen/function.gleam", 399).
-spec render(
    function_(any(), any()),
    gleamgen@internal@render:context(),
    gleam@option:option(binary())
) -> gleamgen@internal@render:rendered().
render(Func, Context, Name) ->
    Is_anonymous = gleam@option:is_none(Name),
    Rendered_params = gleamgen@parameter:render_parameters(
        erlang:element(2, Func),
        not Is_anonymous,
        Context
    ),
    Rendered_type = gleamgen@type_:render_type(erlang:element(3, Func), Context),
    Rendered_body = gleamgen@expression:render(
        erlang:element(4, Func),
        {context, erlang:element(2, Context), erlang:element(3, Context), false}
    ),
    {Rendered_name, Force_newlines} = case Name of
        {some, Name@1} ->
            {glam@doc:from_string(<<" "/utf8, Name@1/binary>>), true};

        none ->
            {{concat, []}, false}
    end,
    _pipe = glam@doc:concat(
        [glam@doc:from_string(<<"fn"/utf8>>),
            Rendered_name,
            erlang:element(2, Rendered_params),
            {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@internal@render:body(
                erlang:element(2, Rendered_body),
                Force_newlines
            )]
    ),
    {render,
        _pipe,
        gleamgen@internal@render:merge_details_many(
            [erlang:element(3, Rendered_params),
                begin
                    _pipe@1 = Rendered_type,
                    _pipe@2 = gleam@result:map(
                        _pipe@1,
                        fun(T) -> erlang:element(3, T) end
                    ),
                    gleam@result:unwrap(
                        _pipe@2,
                        {rendered_details, [], [], {report, [], []}}
                    )
                end,
                erlang:element(3, Rendered_body)]
        )}.

-file("src/gleamgen/function.gleam", 380).
-spec anonymous(function_(OMB, any())) -> gleamgen@expression:expression(OMB).
anonymous(Function) ->
    Type_ = begin
        _pipe = erlang:element(2, Function),
        _pipe@1 = gleam@list:map(_pipe, fun gleamgen@parameter:type_/1),
        _pipe@3 = gleamgen@type_:dynamic_function(
            _pipe@1,
            begin
                _pipe@2 = erlang:element(3, Function),
                gleamgen_ffi:identity(_pipe@2)
            end
        ),
        gleamgen_ffi:identity(_pipe@3)
    end,
    Renderer = fun(Context) -> render(Function, Context, none) end,
    gleamgen@expression:new_anonymous_function(
        Renderer,
        gleamgen_ffi:identity(erlang:element(4, Function)),
        erlang:element(2, Function),
        Type_
    ).