Packages
gleamgen

0.4.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_raw/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_(NMA, NMB) :: {function,
        list(gleamgen@parameter:parameter(gleamgen@types:dynamic_())),
        gleamgen@types:generated_type(NMB),
        gleamgen@expression:expression(NMB)} |
    {gleam_phantom, NMA}.

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

-file("src/gleamgen/function.gleam", 40).
-spec new1(
    gleamgen@parameter:parameter(NMR),
    gleamgen@types:generated_type(NMT),
    fun((gleamgen@expression:expression(NMR)) -> gleamgen@expression:expression(NMT))
) -> function_(fun((NMR) -> NMT), NMT).
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(NMZ),
    gleamgen@parameter:parameter(NNB),
    gleamgen@types:generated_type(NND),
    fun((gleamgen@expression:expression(NMZ), gleamgen@expression:expression(NNB)) -> gleamgen@expression:expression(NND))
) -> function_(fun((NMZ, NNB) -> NND), NND).
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(NNK),
    gleamgen@parameter:parameter(NNM),
    gleamgen@parameter:parameter(NNO),
    gleamgen@types:generated_type(NNQ),
    fun((gleamgen@expression:expression(NNK), gleamgen@expression:expression(NNM), gleamgen@expression:expression(NNO)) -> gleamgen@expression:expression(NNQ))
) -> function_(fun((NNK, NNM, NNO) -> NNQ), NNQ).
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(NNY),
    gleamgen@parameter:parameter(NOA),
    gleamgen@parameter:parameter(NOC),
    gleamgen@parameter:parameter(NOE),
    gleamgen@types:generated_type(NOG),
    fun((gleamgen@expression:expression(NNY), gleamgen@expression:expression(NOA), gleamgen@expression:expression(NOC), gleamgen@expression:expression(NOE)) -> gleamgen@expression:expression(NOG))
) -> function_(fun((NNY, NOA, NOC, NOE) -> NOG), NOG).
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(NOP),
    gleamgen@parameter:parameter(NOR),
    gleamgen@parameter:parameter(NOT),
    gleamgen@parameter:parameter(NOV),
    gleamgen@parameter:parameter(NOX),
    gleamgen@types:generated_type(NOZ),
    fun((gleamgen@expression:expression(NOP), gleamgen@expression:expression(NOR), gleamgen@expression:expression(NOT), gleamgen@expression:expression(NOV), gleamgen@expression:expression(NOX)) -> gleamgen@expression:expression(NOZ))
) -> function_(fun((NOP, NOR, NOT, NOV, NOX) -> NOZ), NOZ).
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(NPJ),
    gleamgen@parameter:parameter(NPL),
    gleamgen@parameter:parameter(NPN),
    gleamgen@parameter:parameter(NPP),
    gleamgen@parameter:parameter(NPR),
    gleamgen@parameter:parameter(NPT),
    gleamgen@types:generated_type(NPV),
    fun((gleamgen@expression:expression(NPJ), gleamgen@expression:expression(NPL), gleamgen@expression:expression(NPN), gleamgen@expression:expression(NPP), gleamgen@expression:expression(NPR), gleamgen@expression:expression(NPT)) -> gleamgen@expression:expression(NPV))
) -> function_(fun((NPJ, NPL, NPN, NPP, NPR, NPT) -> NPV), NPV).
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(NQG),
    gleamgen@parameter:parameter(NQI),
    gleamgen@parameter:parameter(NQK),
    gleamgen@parameter:parameter(NQM),
    gleamgen@parameter:parameter(NQO),
    gleamgen@parameter:parameter(NQQ),
    gleamgen@parameter:parameter(NQS),
    gleamgen@types:generated_type(NQU),
    fun((gleamgen@expression:expression(NQG), gleamgen@expression:expression(NQI), gleamgen@expression:expression(NQK), gleamgen@expression:expression(NQM), gleamgen@expression:expression(NQO), gleamgen@expression:expression(NQQ), gleamgen@expression:expression(NQS)) -> gleamgen@expression:expression(NQU))
) -> function_(fun((NQG, NQI, NQK, NQM, NQO, NQQ, NQS) -> NQU), NQU).
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(NRG),
    gleamgen@parameter:parameter(NRI),
    gleamgen@parameter:parameter(NRK),
    gleamgen@parameter:parameter(NRM),
    gleamgen@parameter:parameter(NRO),
    gleamgen@parameter:parameter(NRQ),
    gleamgen@parameter:parameter(NRS),
    gleamgen@parameter:parameter(NRU),
    gleamgen@types:generated_type(NRW),
    fun((gleamgen@expression:expression(NRG), gleamgen@expression:expression(NRI), gleamgen@expression:expression(NRK), gleamgen@expression:expression(NRM), gleamgen@expression:expression(NRO), gleamgen@expression:expression(NRQ), gleamgen@expression:expression(NRS), gleamgen@expression:expression(NRU)) -> gleamgen@expression:expression(NRW))
) -> function_(fun((NRG, NRI, NRK, NRM, NRO, NRQ, NRS, NRU) -> NRW), NRW).
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(NSJ),
    gleamgen@parameter:parameter(NSL),
    gleamgen@parameter:parameter(NSN),
    gleamgen@parameter:parameter(NSP),
    gleamgen@parameter:parameter(NSR),
    gleamgen@parameter:parameter(NST),
    gleamgen@parameter:parameter(NSV),
    gleamgen@parameter:parameter(NSX),
    gleamgen@parameter:parameter(NSZ),
    gleamgen@types:generated_type(NTB),
    fun((gleamgen@expression:expression(NSJ), gleamgen@expression:expression(NSL), gleamgen@expression:expression(NSN), gleamgen@expression:expression(NSP), gleamgen@expression:expression(NSR), gleamgen@expression:expression(NST), gleamgen@expression:expression(NSV), gleamgen@expression:expression(NSX), gleamgen@expression:expression(NSZ)) -> gleamgen@expression:expression(NTB))
) -> function_(fun((NSJ, NSL, NSN, NSP, NSR, NST, NSV, NSX, NSZ) -> NTB), NTB).
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@types:dynamic_(), gleamgen@types: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", 400).
-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@types:render_type(erlang:element(3, Func)),
    Rendered_body = gleamgen@expression:render(
        erlang:element(4, Func),
        {context, erlang:element(2, 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_(NTW, any())) -> gleamgen@expression:expression(NTW).
anonymous(Function) ->
    Type_ = begin
        _pipe = erlang:element(2, Function),
        _pipe@1 = gleam@list:map(_pipe, fun gleamgen@parameter:type_/1),
        _pipe@3 = gleamgen@types: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, 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