Packages
gleamgen

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

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

-file("src/gleamgen/function.gleam", 40).
-spec new1(
    gleamgen@parameter:parameter(OFA),
    gleamgen@type_:generated_type(OFC),
    fun((gleamgen@expression:expression(OFA)) -> gleamgen@expression:expression(OFC))
) -> function_(fun((OFA) -> OFC), OFC).
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(OFI),
    gleamgen@parameter:parameter(OFK),
    gleamgen@type_:generated_type(OFM),
    fun((gleamgen@expression:expression(OFI), gleamgen@expression:expression(OFK)) -> gleamgen@expression:expression(OFM))
) -> function_(fun((OFI, OFK) -> OFM), OFM).
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(OFT),
    gleamgen@parameter:parameter(OFV),
    gleamgen@parameter:parameter(OFX),
    gleamgen@type_:generated_type(OFZ),
    fun((gleamgen@expression:expression(OFT), gleamgen@expression:expression(OFV), gleamgen@expression:expression(OFX)) -> gleamgen@expression:expression(OFZ))
) -> function_(fun((OFT, OFV, OFX) -> OFZ), OFZ).
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(OGH),
    gleamgen@parameter:parameter(OGJ),
    gleamgen@parameter:parameter(OGL),
    gleamgen@parameter:parameter(OGN),
    gleamgen@type_:generated_type(OGP),
    fun((gleamgen@expression:expression(OGH), gleamgen@expression:expression(OGJ), gleamgen@expression:expression(OGL), gleamgen@expression:expression(OGN)) -> gleamgen@expression:expression(OGP))
) -> function_(fun((OGH, OGJ, OGL, OGN) -> OGP), OGP).
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(OGY),
    gleamgen@parameter:parameter(OHA),
    gleamgen@parameter:parameter(OHC),
    gleamgen@parameter:parameter(OHE),
    gleamgen@parameter:parameter(OHG),
    gleamgen@type_:generated_type(OHI),
    fun((gleamgen@expression:expression(OGY), gleamgen@expression:expression(OHA), gleamgen@expression:expression(OHC), gleamgen@expression:expression(OHE), gleamgen@expression:expression(OHG)) -> gleamgen@expression:expression(OHI))
) -> function_(fun((OGY, OHA, OHC, OHE, OHG) -> OHI), OHI).
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(OHS),
    gleamgen@parameter:parameter(OHU),
    gleamgen@parameter:parameter(OHW),
    gleamgen@parameter:parameter(OHY),
    gleamgen@parameter:parameter(OIA),
    gleamgen@parameter:parameter(OIC),
    gleamgen@type_:generated_type(OIE),
    fun((gleamgen@expression:expression(OHS), gleamgen@expression:expression(OHU), gleamgen@expression:expression(OHW), gleamgen@expression:expression(OHY), gleamgen@expression:expression(OIA), gleamgen@expression:expression(OIC)) -> gleamgen@expression:expression(OIE))
) -> function_(fun((OHS, OHU, OHW, OHY, OIA, OIC) -> OIE), OIE).
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(OIP),
    gleamgen@parameter:parameter(OIR),
    gleamgen@parameter:parameter(OIT),
    gleamgen@parameter:parameter(OIV),
    gleamgen@parameter:parameter(OIX),
    gleamgen@parameter:parameter(OIZ),
    gleamgen@parameter:parameter(OJB),
    gleamgen@type_:generated_type(OJD),
    fun((gleamgen@expression:expression(OIP), gleamgen@expression:expression(OIR), gleamgen@expression:expression(OIT), gleamgen@expression:expression(OIV), gleamgen@expression:expression(OIX), gleamgen@expression:expression(OIZ), gleamgen@expression:expression(OJB)) -> gleamgen@expression:expression(OJD))
) -> function_(fun((OIP, OIR, OIT, OIV, OIX, OIZ, OJB) -> OJD), OJD).
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(OJP),
    gleamgen@parameter:parameter(OJR),
    gleamgen@parameter:parameter(OJT),
    gleamgen@parameter:parameter(OJV),
    gleamgen@parameter:parameter(OJX),
    gleamgen@parameter:parameter(OJZ),
    gleamgen@parameter:parameter(OKB),
    gleamgen@parameter:parameter(OKD),
    gleamgen@type_:generated_type(OKF),
    fun((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), gleamgen@expression:expression(OKD)) -> gleamgen@expression:expression(OKF))
) -> function_(fun((OJP, OJR, OJT, OJV, OJX, OJZ, OKB, OKD) -> OKF), OKF).
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(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@parameter:parameter(OLG),
    gleamgen@parameter:parameter(OLI),
    gleamgen@type_:generated_type(OLK),
    fun((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), gleamgen@expression:expression(OLI)) -> gleamgen@expression:expression(OLK))
) -> function_(fun((OKS, OKU, OKW, OKY, OLA, OLC, OLE, OLG, OLI) -> OLK), OLK).
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_(OMF, any())) -> gleamgen@expression:expression(OMF).
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