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@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(MHV, MHW) :: {use_function,
        gleamgen@expression:expression(gleamgen@types:dynamic_()),
        list(gleamgen@expression:expression(gleamgen@types:dynamic_()))} |
    {gleam_phantom, MHV, MHW}.

-file("src/gleamgen/expression/block.gleam", 10).
?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@types:generated_type(MHY)
) -> gleamgen@expression:expression(MHY).
new(Statements, Return) ->
    gleamgen@expression:new_block(Statements, Return).

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

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

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

-file("src/gleamgen/expression/block.gleam", 54).
?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(MIL),
    fun((gleamgen@expression:expression(MIL)) -> gleamgen@expression:expression(MIO))
) -> gleamgen@expression:expression(MIO).
with_let_declaration(Variable, Value, Handler) ->
    Rest = Handler(gleamgen@expression:raw(Variable)),
    gleamgen@expression:add_to_or_create_block(
        {let_declaration,
            Variable,
            begin
                _pipe = Value,
                gleamgen_ffi:identity(_pipe)
            end,
            false},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 66).
-spec with_matching_let_declaration(
    gleamgen@pattern:pattern(MIR, MIS),
    gleamgen@expression:expression(MIR),
    boolean(),
    fun((MIS) -> gleamgen@expression:expression(MIW))
) -> gleamgen@expression:expression(MIW).
with_matching_let_declaration(Pattern, Value, Assert_, Handler) ->
    Rest = Handler(gleamgen@pattern:get_output(Pattern)),
    gleamgen@expression:add_to_or_create_block(
        {let_declaration,
            begin
                _pipe = Pattern,
                _pipe@1 = gleamgen_ffi:identity(_pipe),
                _pipe@2 = gleamgen@pattern:render(_pipe@1, 1),
                fun gleamgen@internal@render:to_string/1(_pipe@2)
            end,
            begin
                _pipe@3 = Value,
                gleamgen_ffi:identity(_pipe@3)
            end,
            Assert_},
        Rest
    ).

-file("src/gleamgen/expression/block.gleam", 86).
-spec with_expression(
    gleamgen@expression:expression(any()),
    fun(() -> gleamgen@expression:expression(MJB))
) -> gleamgen@expression:expression(MJB).
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", 97).
-spec with_statements(
    list(gleamgen@expression:statement()),
    fun(() -> gleamgen@expression:expression(MJF))
) -> gleamgen@expression:expression(MJF).
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", 114).
-spec use_function1(
    gleamgen@expression:expression(fun((MJI, MJJ) -> MJK)),
    gleamgen@expression:expression(MJI)
) -> use_function(MJJ, MJK).
use_function1(Func, Arg1) ->
    {use_function, gleamgen_ffi:identity(Func), [gleamgen_ffi:identity(Arg1)]}.

-file("src/gleamgen/expression/block.gleam", 121).
-spec use_function2(
    gleamgen@expression:expression(fun((MJP, MJQ, MJR) -> MJS)),
    gleamgen@expression:expression(MJP),
    gleamgen@expression:expression(MJQ)
) -> use_function(MJR, MJS).
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", 132).
-spec use_function3(
    gleamgen@expression:expression(fun((MJY, MJZ, MKA, MKB) -> MKC)),
    gleamgen@expression:expression(MJY),
    gleamgen@expression:expression(MJZ),
    gleamgen@expression:expression(MKA)
) -> use_function(MKB, MKC).
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", 145).
-spec use_function4(
    gleamgen@expression:expression(fun((MKJ, MKK, MKL, MKM, MKN) -> MKO)),
    gleamgen@expression:expression(MKJ),
    gleamgen@expression:expression(MKK),
    gleamgen@expression:expression(MKL),
    gleamgen@expression:expression(MKM)
) -> use_function(MKN, MKO).
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", 160).
-spec use_function5(
    gleamgen@expression:expression(fun((MKW, MKX, MKY, MKZ, MLA, MLB) -> MLC)),
    gleamgen@expression:expression(MKW),
    gleamgen@expression:expression(MKX),
    gleamgen@expression:expression(MKY),
    gleamgen@expression:expression(MKZ),
    gleamgen@expression:expression(MLA)
) -> use_function(MLB, MLC).
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", 177).
-spec use_function6(
    gleamgen@expression:expression(fun((MLL, MLM, MLN, MLO, MLP, MLQ, MLR) -> MLS)),
    gleamgen@expression:expression(MLL),
    gleamgen@expression:expression(MLM),
    gleamgen@expression:expression(MLN),
    gleamgen@expression:expression(MLO),
    gleamgen@expression:expression(MLP),
    gleamgen@expression:expression(MLQ)
) -> use_function(MLR, MLS).
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", 196).
-spec use_function7(
    gleamgen@expression:expression(fun((MMC, MMD, MME, MMF, MMG, MMH, MMI, MMJ) -> MMK)),
    gleamgen@expression:expression(MMC),
    gleamgen@expression:expression(MMD),
    gleamgen@expression:expression(MME),
    gleamgen@expression:expression(MMF),
    gleamgen@expression:expression(MMG),
    gleamgen@expression:expression(MMH),
    gleamgen@expression:expression(MMI)
) -> use_function(MMJ, MMK).
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", 217).
-spec use_function8(
    gleamgen@expression:expression(fun((MMV, MMW, MMX, MMY, MMZ, MNA, MNB, MNC, MND) -> MNE)),
    gleamgen@expression:expression(MMV),
    gleamgen@expression:expression(MMW),
    gleamgen@expression:expression(MMX),
    gleamgen@expression:expression(MMY),
    gleamgen@expression:expression(MMZ),
    gleamgen@expression:expression(MNA),
    gleamgen@expression:expression(MNB),
    gleamgen@expression:expression(MNC)
) -> use_function(MND, MNE).
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", 240).
-spec use_function9(
    gleamgen@expression:expression(fun((MNQ, MNR, MNS, MNT, MNU, MNV, MNW, MNX, MNY, MNZ) -> MOA)),
    gleamgen@expression:expression(MNQ),
    gleamgen@expression:expression(MNR),
    gleamgen@expression:expression(MNS),
    gleamgen@expression:expression(MNT),
    gleamgen@expression:expression(MNU),
    gleamgen@expression:expression(MNV),
    gleamgen@expression:expression(MNW),
    gleamgen@expression:expression(MNX),
    gleamgen@expression:expression(MNY)
) -> use_function(MNZ, MOA).
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", 265).
-spec use_function_dynamic(
    gleamgen@expression:expression(any()),
    list(gleamgen@expression:expression(gleamgen@types:dynamic_()))
) -> use_function(any(), any()).
use_function_dynamic(Func, Args) ->
    {use_function, gleamgen_ffi:identity(Func), Args}.

-file("src/gleamgen/expression/block.gleam", 272).
-spec with_use0(
    use_function(fun(() -> MOV), MOV),
    fun(() -> gleamgen@expression:expression(MOV))
) -> gleamgen@expression:expression(MOV).
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", 284).
-spec with_use1(
    use_function(fun((MPA) -> MPB), MPB),
    binary(),
    fun((gleamgen@expression:expression(MPA)) -> gleamgen@expression:expression(MPB))
) -> gleamgen@expression:expression(MPB).
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", 298).
-spec with_use2(
    use_function(fun((MPH, MPI) -> MPJ), MPJ),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MPH), gleamgen@expression:expression(MPI)) -> gleamgen@expression:expression(MPJ))
) -> gleamgen@expression:expression(MPJ).
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", 313).
-spec with_use3(
    use_function(fun((MPQ, MPR, MPS) -> MPT), MPT),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MPQ), gleamgen@expression:expression(MPR), gleamgen@expression:expression(MPS)) -> gleamgen@expression:expression(MPT))
) -> gleamgen@expression:expression(MPT).
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", 334).
-spec with_use4(
    use_function(fun((MQB, MQC, MQD, MQE) -> MQF), MQF),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MQB), gleamgen@expression:expression(MQC), gleamgen@expression:expression(MQD), gleamgen@expression:expression(MQE)) -> gleamgen@expression:expression(MQF))
) -> gleamgen@expression:expression(MQF).
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", 363).
-spec with_use5(
    use_function(fun((MQO, MQP, MQQ, MQR, MQS) -> MQT), MQT),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MQO), gleamgen@expression:expression(MQP), gleamgen@expression:expression(MQQ), gleamgen@expression:expression(MQR), gleamgen@expression:expression(MQS)) -> gleamgen@expression:expression(MQT))
) -> gleamgen@expression:expression(MQT).
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", 401).
-spec with_use6(
    use_function(fun((MRD, MRE, MRF, MRG, MRH, MRI) -> MRJ), MRJ),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MRD), gleamgen@expression:expression(MRE), gleamgen@expression:expression(MRF), gleamgen@expression:expression(MRG), gleamgen@expression:expression(MRH), gleamgen@expression:expression(MRI)) -> gleamgen@expression:expression(MRJ))
) -> gleamgen@expression:expression(MRJ).
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", 443).
-spec with_use7(
    use_function(fun((MRU, MRV, MRW, MRX, MRY, MRZ, MSA) -> MSB), MSB),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MRU), gleamgen@expression:expression(MRV), gleamgen@expression:expression(MRW), gleamgen@expression:expression(MRX), gleamgen@expression:expression(MRY), gleamgen@expression:expression(MRZ), gleamgen@expression:expression(MSA)) -> gleamgen@expression:expression(MSB))
) -> gleamgen@expression:expression(MSB).
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", 489).
-spec with_use8(
    use_function(fun((MSN, MSO, MSP, MSQ, MSR, MSS, MST, MSU) -> MSV), MSV),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MSN), gleamgen@expression:expression(MSO), gleamgen@expression:expression(MSP), gleamgen@expression:expression(MSQ), gleamgen@expression:expression(MSR), gleamgen@expression:expression(MSS), gleamgen@expression:expression(MST), gleamgen@expression:expression(MSU)) -> gleamgen@expression:expression(MSV))
) -> gleamgen@expression:expression(MSV).
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", 539).
-spec with_use9(
    use_function(fun((MTI, MTJ, MTK, MTL, MTM, MTN, MTO, MTP, MTQ) -> MTR), MTR),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MTI), gleamgen@expression:expression(MTJ), gleamgen@expression:expression(MTK), gleamgen@expression:expression(MTL), gleamgen@expression:expression(MTM), gleamgen@expression:expression(MTN), gleamgen@expression:expression(MTO), gleamgen@expression:expression(MTP), gleamgen@expression:expression(MTQ)) -> gleamgen@expression:expression(MTR))
) -> gleamgen@expression:expression(MTR).
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", 593).
-spec with_use_dynamic(
    use_function(any(), MUG),
    list(binary()),
    fun((list(gleamgen@expression:expression(gleamgen@types:dynamic_()))) -> gleamgen@expression:expression(MUG))
) -> gleamgen@expression:expression(MUG).
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