Packages
gleamgen

1.0.4
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@expression@block.erl
Raw
src/gleamgen@expression@block.erl

-module(gleamgen@expression@block).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/expression/block.gleam").
-export([new/2, new_dynamic/1, with_comments/2, with_empty_line/1, with_let_declaration/3, with_matching_let_declaration/4, with_expression/2, with_statements/2, use_function1/2, use_function2/3, use_function3/4, use_function4/5, use_function5/6, use_function6/7, use_function7/8, use_function8/9, use_function9/10, use_function_dynamic/2, with_use0/2, with_use1/3, with_use2/4, with_use3/5, with_use4/6, with_use5/7, with_use6/8, with_use7/9, with_use8/10, with_use9/11, with_use_dynamic/3]).
-export_type([use_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 use_function(NBY, NBZ) :: {use_function,
        gleamgen@expression:expression(gleamgen@type_:dynamic_()),
        list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))} |
    {gleam_phantom, NBY, NBZ}.

-file("src/gleamgen/expression/block.gleam", 11).
?DOC(
    " Create a block expression that returns a specific type (see also `new_dynamic`)\n"
    " Prefer building a block implicitly using the `with_` functions of this module\n"
).
-spec new(
    list(gleamgen@expression:statement()),
    gleamgen@type_:generated_type(NCB)
) -> gleamgen@expression:expression(NCB).
new(Statements, Return) ->
    gleamgen@expression:new_block(Statements, Return).

-file("src/gleamgen/expression/block.gleam", 18).
-spec new_dynamic(list(gleamgen@expression:statement())) -> gleamgen@expression:expression(any()).
new_dynamic(Statements) ->
    gleamgen@expression:new_block(Statements, gleamgen@type_:dynamic()).

-file("src/gleamgen/expression/block.gleam", 24).
-spec with_comments(
    list(binary()),
    fun(() -> gleamgen@expression:expression(NCI))
) -> gleamgen@expression:expression(NCI).
with_comments(Comments, Handler) ->
    Rest = Handler(),
    gleamgen@expression:add_to_or_create_block({comment, Comments}, Rest).

-file("src/gleamgen/expression/block.gleam", 29).
-spec with_empty_line(fun(() -> gleamgen@expression:expression(NCL))) -> gleamgen@expression:expression(NCL).
with_empty_line(Handler) ->
    Rest = Handler(),
    gleamgen@expression:add_to_or_create_block(linebreak, Rest).

-file("src/gleamgen/expression/block.gleam", 55).
?DOC(
    " ```gleam\n"
    " {\n"
    "   use x <- block.with_let_declaration(\"x\", expression.int(4))\n"
    "   use y <- block.with_let_declaration(\n"
    "     \"y\",\n"
    "     expression.math_operator(x, expression.Add, expression.int(5)),\n"
    "   )\n"
    "   y\n"
    " }\n"
    " |> expression.render(render.default_context())\n"
    " |> render.to_string()\n"
    " ```\n"
    "\n"
    " outputs:\n"
    " ```gleam\n"
    " {\n"
    "   let x = 4\n"
    "   let y = x + 5\n"
    "   y\n"
    " }\n"
    " ```\n"
).
-spec with_let_declaration(
    binary(),
    gleamgen@expression:expression(NCO),
    fun((gleamgen@expression:expression(NCO)) -> gleamgen@expression:expression(NCR))
) -> gleamgen@expression:expression(NCR).
with_let_declaration(Variable, Value, Handler) ->
    Rest = Handler(gleamgen@expression:raw(Variable)),
    gleamgen@expression:add_to_or_create_block(
        {let_declaration,
            fun(_) ->
                {render,
                    glam@doc:from_string(Variable),
                    {rendered_details, [], [], {report, [], []}}}
            end,
            begin
                _pipe = Value,
                gleamgen_ffi:identity(_pipe)
            end,
            false},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 73).
-spec with_matching_let_declaration(
    gleamgen@pattern:pattern(NCU, NCV),
    gleamgen@expression:expression(NCU),
    boolean(),
    fun((NCV) -> gleamgen@expression:expression(NCZ))
) -> gleamgen@expression:expression(NCZ).
with_matching_let_declaration(Pattern, Value, Assert_, Handler) ->
    Rest = Handler(gleamgen@pattern:get_output(Pattern)),
    gleamgen@expression:add_to_or_create_block(
        {let_declaration, fun(Context) -> _pipe = Pattern,
                _pipe@1 = gleamgen_ffi:identity(_pipe),
                gleamgen@pattern:render(_pipe@1, Context, 1) end, begin
                _pipe@2 = Value,
                gleamgen_ffi:identity(_pipe@2)
            end, Assert_},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 94).
-spec with_expression(
    gleamgen@expression:expression(any()),
    fun(() -> gleamgen@expression:expression(NDE))
) -> gleamgen@expression:expression(NDE).
with_expression(Expression, Handler) ->
    Rest = Handler(),
    gleamgen@expression:add_to_or_create_block(
        begin
            _pipe = Expression,
            _pipe@1 = gleamgen_ffi:identity(_pipe),
            {expression_statement, _pipe@1}
        end,
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 105).
-spec with_statements(
    list(gleamgen@expression:statement()),
    fun(() -> gleamgen@expression:expression(NDI))
) -> gleamgen@expression:expression(NDI).
with_statements(Statements, Handler) ->
    Rest = Handler(),
    gleamgen@expression:update_or_create_block(
        fun(_capture) -> lists:append(Statements, _capture) end,
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 122).
-spec use_function1(
    gleamgen@expression:expression(fun((NDL, NDM) -> NDN)),
    gleamgen@expression:expression(NDL)
) -> use_function(NDM, NDN).
use_function1(Func, Arg1) ->
    {use_function, gleamgen_ffi:identity(Func), [gleamgen_ffi:identity(Arg1)]}.

-file("src/gleamgen/expression/block.gleam", 129).
-spec use_function2(
    gleamgen@expression:expression(fun((NDS, NDT, NDU) -> NDV)),
    gleamgen@expression:expression(NDS),
    gleamgen@expression:expression(NDT)
) -> use_function(NDU, NDV).
use_function2(Func, Arg1, Arg2) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1), gleamgen_ffi:identity(Arg2)]}.

-file("src/gleamgen/expression/block.gleam", 140).
-spec use_function3(
    gleamgen@expression:expression(fun((NEB, NEC, NED, NEE) -> NEF)),
    gleamgen@expression:expression(NEB),
    gleamgen@expression:expression(NEC),
    gleamgen@expression:expression(NED)
) -> use_function(NEE, NEF).
use_function3(Func, Arg1, Arg2, Arg3) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3)]}.

-file("src/gleamgen/expression/block.gleam", 153).
-spec use_function4(
    gleamgen@expression:expression(fun((NEM, NEN, NEO, NEP, NEQ) -> NER)),
    gleamgen@expression:expression(NEM),
    gleamgen@expression:expression(NEN),
    gleamgen@expression:expression(NEO),
    gleamgen@expression:expression(NEP)
) -> use_function(NEQ, NER).
use_function4(Func, Arg1, Arg2, Arg3, Arg4) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4)]}.

-file("src/gleamgen/expression/block.gleam", 168).
-spec use_function5(
    gleamgen@expression:expression(fun((NEZ, NFA, NFB, NFC, NFD, NFE) -> NFF)),
    gleamgen@expression:expression(NEZ),
    gleamgen@expression:expression(NFA),
    gleamgen@expression:expression(NFB),
    gleamgen@expression:expression(NFC),
    gleamgen@expression:expression(NFD)
) -> use_function(NFE, NFF).
use_function5(Func, Arg1, Arg2, Arg3, Arg4, Arg5) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4),
            gleamgen_ffi:identity(Arg5)]}.

-file("src/gleamgen/expression/block.gleam", 185).
-spec use_function6(
    gleamgen@expression:expression(fun((NFO, NFP, NFQ, NFR, NFS, NFT, NFU) -> NFV)),
    gleamgen@expression:expression(NFO),
    gleamgen@expression:expression(NFP),
    gleamgen@expression:expression(NFQ),
    gleamgen@expression:expression(NFR),
    gleamgen@expression:expression(NFS),
    gleamgen@expression:expression(NFT)
) -> use_function(NFU, NFV).
use_function6(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4),
            gleamgen_ffi:identity(Arg5),
            gleamgen_ffi:identity(Arg6)]}.

-file("src/gleamgen/expression/block.gleam", 204).
-spec use_function7(
    gleamgen@expression:expression(fun((NGF, NGG, NGH, NGI, NGJ, NGK, NGL, NGM) -> NGN)),
    gleamgen@expression:expression(NGF),
    gleamgen@expression:expression(NGG),
    gleamgen@expression:expression(NGH),
    gleamgen@expression:expression(NGI),
    gleamgen@expression:expression(NGJ),
    gleamgen@expression:expression(NGK),
    gleamgen@expression:expression(NGL)
) -> use_function(NGM, NGN).
use_function7(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4),
            gleamgen_ffi:identity(Arg5),
            gleamgen_ffi:identity(Arg6),
            gleamgen_ffi:identity(Arg7)]}.

-file("src/gleamgen/expression/block.gleam", 225).
-spec use_function8(
    gleamgen@expression:expression(fun((NGY, NGZ, NHA, NHB, NHC, NHD, NHE, NHF, NHG) -> NHH)),
    gleamgen@expression:expression(NGY),
    gleamgen@expression:expression(NGZ),
    gleamgen@expression:expression(NHA),
    gleamgen@expression:expression(NHB),
    gleamgen@expression:expression(NHC),
    gleamgen@expression:expression(NHD),
    gleamgen@expression:expression(NHE),
    gleamgen@expression:expression(NHF)
) -> use_function(NHG, NHH).
use_function8(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4),
            gleamgen_ffi:identity(Arg5),
            gleamgen_ffi:identity(Arg6),
            gleamgen_ffi:identity(Arg7),
            gleamgen_ffi:identity(Arg8)]}.

-file("src/gleamgen/expression/block.gleam", 248).
-spec use_function9(
    gleamgen@expression:expression(fun((NHT, NHU, NHV, NHW, NHX, NHY, NHZ, NIA, NIB, NIC) -> NID)),
    gleamgen@expression:expression(NHT),
    gleamgen@expression:expression(NHU),
    gleamgen@expression:expression(NHV),
    gleamgen@expression:expression(NHW),
    gleamgen@expression:expression(NHX),
    gleamgen@expression:expression(NHY),
    gleamgen@expression:expression(NHZ),
    gleamgen@expression:expression(NIA),
    gleamgen@expression:expression(NIB)
) -> use_function(NIC, NID).
use_function9(Func, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9) ->
    {use_function,
        gleamgen_ffi:identity(Func),
        [gleamgen_ffi:identity(Arg1),
            gleamgen_ffi:identity(Arg2),
            gleamgen_ffi:identity(Arg3),
            gleamgen_ffi:identity(Arg4),
            gleamgen_ffi:identity(Arg5),
            gleamgen_ffi:identity(Arg6),
            gleamgen_ffi:identity(Arg7),
            gleamgen_ffi:identity(Arg8),
            gleamgen_ffi:identity(Arg9)]}.

-file("src/gleamgen/expression/block.gleam", 273).
-spec use_function_dynamic(
    gleamgen@expression:expression(any()),
    list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))
) -> use_function(any(), any()).
use_function_dynamic(Func, Args) ->
    {use_function, gleamgen_ffi:identity(Func), Args}.

-file("src/gleamgen/expression/block.gleam", 280).
-spec with_use0(
    use_function(fun(() -> NIY), NIY),
    fun(() -> gleamgen@expression:expression(NIY))
) -> gleamgen@expression:expression(NIY).
with_use0(Use_function, Callback) ->
    Rest = Callback(),
    gleamgen@expression:add_to_or_create_block(
        begin
            _pipe = gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                []
            ),
            {expression_statement, _pipe}
        end,
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 292).
-spec with_use1(
    use_function(fun((NJD) -> NJE), NJE),
    binary(),
    fun((gleamgen@expression:expression(NJD)) -> gleamgen@expression:expression(NJE))
) -> gleamgen@expression:expression(NJE).
with_use1(Use_function, Arg1, Callback) ->
    Rest = Callback(gleamgen@expression:raw(Arg1)),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 306).
-spec with_use2(
    use_function(fun((NJK, NJL) -> NJM), NJM),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NJK), gleamgen@expression:expression(NJL)) -> gleamgen@expression:expression(NJM))
) -> gleamgen@expression:expression(NJM).
with_use2(Use_function, Arg1, Arg2, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 321).
-spec with_use3(
    use_function(fun((NJT, NJU, NJV) -> NJW), NJW),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NJT), gleamgen@expression:expression(NJU), gleamgen@expression:expression(NJV)) -> gleamgen@expression:expression(NJW))
) -> gleamgen@expression:expression(NJW).
with_use3(Use_function, Arg1, Arg2, Arg3, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 342).
-spec with_use4(
    use_function(fun((NKE, NKF, NKG, NKH) -> NKI), NKI),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NKE), gleamgen@expression:expression(NKF), gleamgen@expression:expression(NKG), gleamgen@expression:expression(NKH)) -> gleamgen@expression:expression(NKI))
) -> gleamgen@expression:expression(NKI).
with_use4(Use_function, Arg1, Arg2, Arg3, Arg4, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 371).
-spec with_use5(
    use_function(fun((NKR, NKS, NKT, NKU, NKV) -> NKW), NKW),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NKR), gleamgen@expression:expression(NKS), gleamgen@expression:expression(NKT), gleamgen@expression:expression(NKU), gleamgen@expression:expression(NKV)) -> gleamgen@expression:expression(NKW))
) -> gleamgen@expression:expression(NKW).
with_use5(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4),
        gleamgen@expression:raw(Arg5)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4, Arg5]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 408).
-spec with_use6(
    use_function(fun((NLG, NLH, NLI, NLJ, NLK, NLL) -> NLM), NLM),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NLG), gleamgen@expression:expression(NLH), gleamgen@expression:expression(NLI), gleamgen@expression:expression(NLJ), gleamgen@expression:expression(NLK), gleamgen@expression:expression(NLL)) -> gleamgen@expression:expression(NLM))
) -> gleamgen@expression:expression(NLM).
with_use6(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4),
        gleamgen@expression:raw(Arg5),
        gleamgen@expression:raw(Arg6)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 449).
-spec with_use7(
    use_function(fun((NLX, NLY, NLZ, NMA, NMB, NMC, NMD) -> NME), NME),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NLX), gleamgen@expression:expression(NLY), gleamgen@expression:expression(NLZ), gleamgen@expression:expression(NMA), gleamgen@expression:expression(NMB), gleamgen@expression:expression(NMC), gleamgen@expression:expression(NMD)) -> gleamgen@expression:expression(NME))
) -> gleamgen@expression:expression(NME).
with_use7(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Callback) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4),
        gleamgen@expression:raw(Arg5),
        gleamgen@expression:raw(Arg6),
        gleamgen@expression:raw(Arg7)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 494).
-spec with_use8(
    use_function(fun((NMQ, NMR, NMS, NMT, NMU, NMV, NMW, NMX) -> NMY), NMY),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NMQ), gleamgen@expression:expression(NMR), gleamgen@expression:expression(NMS), gleamgen@expression:expression(NMT), gleamgen@expression:expression(NMU), gleamgen@expression:expression(NMV), gleamgen@expression:expression(NMW), gleamgen@expression:expression(NMX)) -> gleamgen@expression:expression(NMY))
) -> gleamgen@expression:expression(NMY).
with_use8(
    Use_function,
    Arg1,
    Arg2,
    Arg3,
    Arg4,
    Arg5,
    Arg6,
    Arg7,
    Arg8,
    Callback
) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4),
        gleamgen@expression:raw(Arg5),
        gleamgen@expression:raw(Arg6),
        gleamgen@expression:raw(Arg7),
        gleamgen@expression:raw(Arg8)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 543).
-spec with_use9(
    use_function(fun((NNL, NNM, NNN, NNO, NNP, NNQ, NNR, NNS, NNT) -> NNU), NNU),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(NNL), gleamgen@expression:expression(NNM), gleamgen@expression:expression(NNN), gleamgen@expression:expression(NNO), gleamgen@expression:expression(NNP), gleamgen@expression:expression(NNQ), gleamgen@expression:expression(NNR), gleamgen@expression:expression(NNS), gleamgen@expression:expression(NNT)) -> gleamgen@expression:expression(NNU))
) -> gleamgen@expression:expression(NNU).
with_use9(
    Use_function,
    Arg1,
    Arg2,
    Arg3,
    Arg4,
    Arg5,
    Arg6,
    Arg7,
    Arg8,
    Arg9,
    Callback
) ->
    Rest = Callback(
        gleamgen@expression:raw(Arg1),
        gleamgen@expression:raw(Arg2),
        gleamgen@expression:raw(Arg3),
        gleamgen@expression:raw(Arg4),
        gleamgen@expression:raw(Arg5),
        gleamgen@expression:raw(Arg6),
        gleamgen@expression:raw(Arg7),
        gleamgen@expression:raw(Arg8),
        gleamgen@expression:raw(Arg9)
    ),
    gleamgen@expression:add_to_or_create_block(
        {expression_statement,
            gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9]
            )},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 596).
-spec with_use_dynamic(
    use_function(any(), NOJ),
    list(binary()),
    fun((list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))) -> gleamgen@expression:expression(NOJ))
) -> gleamgen@expression:expression(NOJ).
with_use_dynamic(Use_function, Args, Callback) ->
    Rest = Callback(gleam@list:map(Args, fun gleamgen@expression:raw/1)),
    gleamgen@expression:add_to_or_create_block(
        begin
            _pipe = gleamgen@expression:new_use(
                erlang:element(2, Use_function),
                erlang:element(3, Use_function),
                Args
            ),
            {expression_statement, _pipe}
        end,
        Rest
    ).
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