Packages
gleamgen

1.0.1
1.0.4 1.0.3 1.0.2 1.0.1 1.0.0 0.4.0 0.3.6 0.3.5 0.3.4 0.3.3 0.3.2 0.3.1 0.3.0 0.2.1 0.2.0 0.1.0
Type-safe gleam codegen (in gleam!)
HexDocs
Current section
Files
Jump to
Readme 16 Versions 3 Dependencies Dependants Files Activity
gleamgen src gleamgen@function.erl
Raw
src/gleamgen@function.erl

-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_(OED, OEE) :: {function,
        list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_())),
        gleamgen@type_:generated_type(OEE),
        gleamgen@expression:expression(OEE)} |
    {gleam_phantom, OED}.

-file("src/gleamgen/function.gleam", 18).
-spec new_dynamic(
    list(gleamgen@parameter:parameter(gleamgen@type_:dynamic_())),
    gleamgen@type_:generated_type(OEH),
    fun((list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))) -> gleamgen@expression:expression(OEH))
) -> function_(gleamgen@type_:dynamic_(), OEH).
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(OEO),
    fun(() -> gleamgen@expression:expression(OEO))
) -> function_(fun(() -> OEO), OEO).
new0(Returns, Handler) ->
    Body = Handler(),
    {function, [], Returns, Body}.

-file("src/gleamgen/function.gleam", 40).
-spec new1(
    gleamgen@parameter:parameter(OET),
    gleamgen@type_:generated_type(OEV),
    fun((gleamgen@expression:expression(OET)) -> gleamgen@expression:expression(OEV))
) -> function_(fun((OET) -> OEV), OEV).
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(OFB),
    gleamgen@parameter:parameter(OFD),
    gleamgen@type_:generated_type(OFF),
    fun((gleamgen@expression:expression(OFB), gleamgen@expression:expression(OFD)) -> gleamgen@expression:expression(OFF))
) -> function_(fun((OFB, OFD) -> OFF), OFF).
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", 78).
-spec new3(
    gleamgen@parameter:parameter(OFM),
    gleamgen@parameter:parameter(OFO),
    gleamgen@parameter:parameter(OFQ),
    gleamgen@type_:generated_type(OFS),
    fun((gleamgen@expression:expression(OFM), gleamgen@expression:expression(OFO), gleamgen@expression:expression(OFQ)) -> gleamgen@expression:expression(OFS))
) -> function_(fun((OFM, OFO, OFQ) -> OFS), OFS).
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", 107).
-spec new4(
    gleamgen@parameter:parameter(OGA),
    gleamgen@parameter:parameter(OGC),
    gleamgen@parameter:parameter(OGE),
    gleamgen@parameter:parameter(OGG),
    gleamgen@type_:generated_type(OGI),
    fun((gleamgen@expression:expression(OGA), gleamgen@expression:expression(OGC), gleamgen@expression:expression(OGE), gleamgen@expression:expression(OGG)) -> gleamgen@expression:expression(OGI))
) -> function_(fun((OGA, OGC, OGE, OGG) -> OGI), OGI).
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", 140).
-spec new5(
    gleamgen@parameter:parameter(OGR),
    gleamgen@parameter:parameter(OGT),
    gleamgen@parameter:parameter(OGV),
    gleamgen@parameter:parameter(OGX),
    gleamgen@parameter:parameter(OGZ),
    gleamgen@type_:generated_type(OHB),
    fun((gleamgen@expression:expression(OGR), gleamgen@expression:expression(OGT), gleamgen@expression:expression(OGV), gleamgen@expression:expression(OGX), gleamgen@expression:expression(OGZ)) -> gleamgen@expression:expression(OHB))
) -> function_(fun((OGR, OGT, OGV, OGX, OGZ) -> OHB), OHB).
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", 177).
-spec new6(
    gleamgen@parameter:parameter(OHL),
    gleamgen@parameter:parameter(OHN),
    gleamgen@parameter:parameter(OHP),
    gleamgen@parameter:parameter(OHR),
    gleamgen@parameter:parameter(OHT),
    gleamgen@parameter:parameter(OHV),
    gleamgen@type_:generated_type(OHX),
    fun((gleamgen@expression:expression(OHL), gleamgen@expression:expression(OHN), gleamgen@expression:expression(OHP), gleamgen@expression:expression(OHR), gleamgen@expression:expression(OHT), gleamgen@expression:expression(OHV)) -> gleamgen@expression:expression(OHX))
) -> function_(fun((OHL, OHN, OHP, OHR, OHT, OHV) -> OHX), OHX).
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", 218).
-spec new7(
    gleamgen@parameter:parameter(OII),
    gleamgen@parameter:parameter(OIK),
    gleamgen@parameter:parameter(OIM),
    gleamgen@parameter:parameter(OIO),
    gleamgen@parameter:parameter(OIQ),
    gleamgen@parameter:parameter(OIS),
    gleamgen@parameter:parameter(OIU),
    gleamgen@type_:generated_type(OIW),
    fun((gleamgen@expression:expression(OII), gleamgen@expression:expression(OIK), gleamgen@expression:expression(OIM), gleamgen@expression:expression(OIO), gleamgen@expression:expression(OIQ), gleamgen@expression:expression(OIS), gleamgen@expression:expression(OIU)) -> gleamgen@expression:expression(OIW))
) -> function_(fun((OII, OIK, OIM, OIO, OIQ, OIS, OIU) -> OIW), OIW).
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", 266).
-spec new8(
    gleamgen@parameter:parameter(OJI),
    gleamgen@parameter:parameter(OJK),
    gleamgen@parameter:parameter(OJM),
    gleamgen@parameter:parameter(OJO),
    gleamgen@parameter:parameter(OJQ),
    gleamgen@parameter:parameter(OJS),
    gleamgen@parameter:parameter(OJU),
    gleamgen@parameter:parameter(OJW),
    gleamgen@type_:generated_type(OJY),
    fun((gleamgen@expression:expression(OJI), gleamgen@expression:expression(OJK), gleamgen@expression:expression(OJM), gleamgen@expression:expression(OJO), gleamgen@expression:expression(OJQ), gleamgen@expression:expression(OJS), gleamgen@expression:expression(OJU), gleamgen@expression:expression(OJW)) -> gleamgen@expression:expression(OJY))
) -> function_(fun((OJI, OJK, OJM, OJO, OJQ, OJS, OJU, OJW) -> OJY), OJY).
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", 318).
-spec new9(
    gleamgen@parameter:parameter(OKL),
    gleamgen@parameter:parameter(OKN),
    gleamgen@parameter:parameter(OKP),
    gleamgen@parameter:parameter(OKR),
    gleamgen@parameter:parameter(OKT),
    gleamgen@parameter:parameter(OKV),
    gleamgen@parameter:parameter(OKX),
    gleamgen@parameter:parameter(OKZ),
    gleamgen@parameter:parameter(OLB),
    gleamgen@type_:generated_type(OLD),
    fun((gleamgen@expression:expression(OKL), gleamgen@expression:expression(OKN), gleamgen@expression:expression(OKP), gleamgen@expression:expression(OKR), gleamgen@expression:expression(OKT), gleamgen@expression:expression(OKV), gleamgen@expression:expression(OKX), gleamgen@expression:expression(OKZ), gleamgen@expression:expression(OLB)) -> gleamgen@expression:expression(OLD))
) -> function_(fun((OKL, OKN, OKP, OKR, OKT, OKV, OKX, OKZ, OLB) -> OLD), OLD).
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", 379).
-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", 386).
?DOC(false).
-spec get_function_name(any()) -> binary().
get_function_name(Type_) ->
    gleamgen_ffi:get_function_name(Type_).

-file("src/gleamgen/function.gleam", 405).
-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", 388).
-spec anonymous(function_(OLY, any())) -> gleamgen@expression:expression(OLY).
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_
    ).
Operator	Description	Example
name:	Match package name. Supports * wildcards and repo/package form	name:phx* or name:hexpm/phoenix
description:	Full-text search of package descriptions	description:auth
depends:	Packages depending on a given package. Supports repo:package form	depends:ecto or depends:hexpm:ecto
build_tool:	Filter by build tool	build_tool:mix
updated_after:	Packages updated after an ISO8601 datetime	updated_after:2025-01-01T00:00:00Z
extra:	Match custom metadata (key,value). Nested keys are separated by commas	extra:license,MIT