Packages
gleamgen

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

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

-file("src/gleamgen/function.gleam", 40).
-spec new1(
    gleamgen@parameter:parameter(OEV),
    gleamgen@type_:generated_type(OEX),
    fun((gleamgen@expression:expression(OEV)) -> gleamgen@expression:expression(OEX))
) -> function_(fun((OEV) -> OEX), OEX).
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(OFD),
    gleamgen@parameter:parameter(OFF),
    gleamgen@type_:generated_type(OFH),
    fun((gleamgen@expression:expression(OFD), gleamgen@expression:expression(OFF)) -> gleamgen@expression:expression(OFH))
) -> function_(fun((OFD, OFF) -> OFH), OFH).
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(OFO),
    gleamgen@parameter:parameter(OFQ),
    gleamgen@parameter:parameter(OFS),
    gleamgen@type_:generated_type(OFU),
    fun((gleamgen@expression:expression(OFO), gleamgen@expression:expression(OFQ), gleamgen@expression:expression(OFS)) -> gleamgen@expression:expression(OFU))
) -> function_(fun((OFO, OFQ, OFS) -> OFU), OFU).
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(OGC),
    gleamgen@parameter:parameter(OGE),
    gleamgen@parameter:parameter(OGG),
    gleamgen@parameter:parameter(OGI),
    gleamgen@type_:generated_type(OGK),
    fun((gleamgen@expression:expression(OGC), gleamgen@expression:expression(OGE), gleamgen@expression:expression(OGG), gleamgen@expression:expression(OGI)) -> gleamgen@expression:expression(OGK))
) -> function_(fun((OGC, OGE, OGG, OGI) -> OGK), OGK).
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(OGT),
    gleamgen@parameter:parameter(OGV),
    gleamgen@parameter:parameter(OGX),
    gleamgen@parameter:parameter(OGZ),
    gleamgen@parameter:parameter(OHB),
    gleamgen@type_:generated_type(OHD),
    fun((gleamgen@expression:expression(OGT), gleamgen@expression:expression(OGV), gleamgen@expression:expression(OGX), gleamgen@expression:expression(OGZ), gleamgen@expression:expression(OHB)) -> gleamgen@expression:expression(OHD))
) -> function_(fun((OGT, OGV, OGX, OGZ, OHB) -> OHD), OHD).
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(OHN),
    gleamgen@parameter:parameter(OHP),
    gleamgen@parameter:parameter(OHR),
    gleamgen@parameter:parameter(OHT),
    gleamgen@parameter:parameter(OHV),
    gleamgen@parameter:parameter(OHX),
    gleamgen@type_:generated_type(OHZ),
    fun((gleamgen@expression:expression(OHN), gleamgen@expression:expression(OHP), gleamgen@expression:expression(OHR), gleamgen@expression:expression(OHT), gleamgen@expression:expression(OHV), gleamgen@expression:expression(OHX)) -> gleamgen@expression:expression(OHZ))
) -> function_(fun((OHN, OHP, OHR, OHT, OHV, OHX) -> OHZ), OHZ).
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(OIK),
    gleamgen@parameter:parameter(OIM),
    gleamgen@parameter:parameter(OIO),
    gleamgen@parameter:parameter(OIQ),
    gleamgen@parameter:parameter(OIS),
    gleamgen@parameter:parameter(OIU),
    gleamgen@parameter:parameter(OIW),
    gleamgen@type_:generated_type(OIY),
    fun((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)) -> gleamgen@expression:expression(OIY))
) -> function_(fun((OIK, OIM, OIO, OIQ, OIS, OIU, OIW) -> OIY), OIY).
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(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@parameter:parameter(OJY),
    gleamgen@type_:generated_type(OKA),
    fun((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)) -> gleamgen@expression:expression(OKA))
) -> function_(fun((OJK, OJM, OJO, OJQ, OJS, OJU, OJW, OJY) -> OKA), OKA).
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(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@parameter:parameter(OLD),
    gleamgen@type_:generated_type(OLF),
    fun((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)) -> gleamgen@expression:expression(OLF))
) -> function_(fun((OKN, OKP, OKR, OKT, OKV, OKX, OKZ, OLB, OLD) -> OLF), OLF).
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_(OMA, any())) -> gleamgen@expression:expression(OMA).
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