Packages
gleamgen

0.3.6
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 2 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]).

-export([ending_block/1, ending_unchecked/1, new/2, new_unchecked/1, with_let_declaration/3, with_matching_let_declaration/4, with_statements_unchecked/2, with_expression/2, build/1, 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_unchecked/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_unchecked/3]).
-export_type([block_builder/1, 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.

-opaque block_builder(LRO) :: {block_builder,
        list(gleamgen@expression:statement()),
        gleamgen@types:generated_type(LRO)}.

-type use_function(LRP, LRQ) :: {use_function,
        gleamgen@expression:expression(gleamgen@types:unchecked()),
        list(gleamgen@expression:expression(gleamgen@types:unchecked()))} |
    {gleam_phantom, LRP, LRQ}.

-file("src/gleamgen/expression/block.gleam", 44).
?DOC(
    " Used as the final expression in a block. If you want a dynamic final expression see `ending_unchecked`.\n"
    "\n"
    " This will set the type of the block to the type of the expression passed in.\n"
).
-spec ending_block(gleamgen@expression:expression(LRR)) -> block_builder(LRR).
ending_block(Expr) ->
    {block_builder,
        [begin
                _pipe = Expr,
                _pipe@1 = gleamgen_ffi:identity(_pipe),
                {expression_statement, _pipe@1}
            end],
        gleamgen@expression:type_(Expr)}.

-file("src/gleamgen/expression/block.gleam", 51).
-spec ending_unchecked(list(gleamgen@expression:statement())) -> block_builder(any()).
ending_unchecked(Statements) ->
    {block_builder,
        Statements,
        begin
            _pipe = gleam@list:last(Statements),
            _pipe@2 = gleam@result:map(_pipe, fun(S) -> case S of
                        {expression_statement, Expr} ->
                            _pipe@1 = gleamgen@expression:type_(Expr),
                            gleamgen_ffi:identity(_pipe@1);

                        {let_declaration, _, _, _} ->
                            gleamgen@types:unchecked()
                    end end),
            gleam@result:unwrap(_pipe@2, gleamgen@types:unchecked())
        end}.

-file("src/gleamgen/expression/block.gleam", 68).
-spec new(
    list(gleamgen@expression:statement()),
    gleamgen@types:generated_type(LRY)
) -> gleamgen@expression:expression(LRY).
new(Statements, Return) ->
    gleamgen@expression:new_block(Statements, Return).

-file("src/gleamgen/expression/block.gleam", 75).
-spec new_unchecked(list(gleamgen@expression:statement())) -> gleamgen@expression:expression(any()).
new_unchecked(Statements) ->
    gleamgen@expression:new_block(Statements, gleamgen@types:unchecked()).

-file("src/gleamgen/expression/block.gleam", 81).
-spec with_let_declaration(
    binary(),
    gleamgen@expression:expression(LSE),
    fun((gleamgen@expression:expression(LSE)) -> block_builder(LSH))
) -> block_builder(LSH).
with_let_declaration(Variable, Value, Handler) ->
    Rest = Handler(gleamgen@expression:unchecked_ident(Variable)),
    _record = Rest,
    {block_builder,
        [{let_declaration,
                Variable,
                begin
                    _pipe = Value,
                    gleamgen_ffi:identity(_pipe)
                end,
                false} |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 97).
-spec with_matching_let_declaration(
    gleamgen@matcher:matcher(LSK, LSL),
    gleamgen@expression:expression(LSK),
    boolean(),
    fun((LSL) -> block_builder(LSP))
) -> block_builder(LSP).
with_matching_let_declaration(Matcher, Value, Assert_, Handler) ->
    Rest = Handler(gleamgen@matcher:get_output(Matcher)),
    _record = Rest,
    {block_builder,
        [{let_declaration,
                begin
                    _pipe = Matcher,
                    _pipe@1 = gleamgen_ffi:identity(_pipe),
                    _pipe@2 = gleamgen@matcher:render(_pipe@1, 1),
                    gleamgen@render:to_string(_pipe@2)
                end,
                begin
                    _pipe@3 = Value,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                Assert_} |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 117).
-spec with_statements_unchecked(
    list(gleamgen@expression:statement()),
    fun(() -> block_builder(LST))
) -> block_builder(LST).
with_statements_unchecked(Statements, Handler) ->
    Rest = Handler(),
    _record = Rest,
    {block_builder,
        lists:append(Statements, erlang:element(2, Rest)),
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 125).
-spec with_expression(
    gleamgen@expression:expression(any()),
    fun(() -> block_builder(LSY))
) -> block_builder(LSY).
with_expression(Expression, Handler) ->
    Rest = Handler(),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = Expression,
                _pipe@1 = gleamgen_ffi:identity(_pipe),
                {expression_statement, _pipe@1}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 136).
-spec build(block_builder(LTB)) -> gleamgen@expression:expression(LTB).
build(Builder) ->
    gleamgen@expression:new_block(
        erlang:element(2, Builder),
        erlang:element(3, Builder)
    ).

-file("src/gleamgen/expression/block.gleam", 149).
-spec use_function1(
    gleamgen@expression:expression(fun((LTE, LTF) -> LTG)),
    gleamgen@expression:expression(LTE)
) -> use_function(LTF, LTG).
use_function1(Func, Arg1) ->
    {use_function, gleamgen_ffi:identity(Func), [gleamgen_ffi:identity(Arg1)]}.

-file("src/gleamgen/expression/block.gleam", 156).
-spec use_function2(
    gleamgen@expression:expression(fun((LTL, LTM, LTN) -> LTO)),
    gleamgen@expression:expression(LTL),
    gleamgen@expression:expression(LTM)
) -> use_function(LTN, LTO).
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", 167).
-spec use_function3(
    gleamgen@expression:expression(fun((LTU, LTV, LTW, LTX) -> LTY)),
    gleamgen@expression:expression(LTU),
    gleamgen@expression:expression(LTV),
    gleamgen@expression:expression(LTW)
) -> use_function(LTX, LTY).
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", 180).
-spec use_function4(
    gleamgen@expression:expression(fun((LUF, LUG, LUH, LUI, LUJ) -> LUK)),
    gleamgen@expression:expression(LUF),
    gleamgen@expression:expression(LUG),
    gleamgen@expression:expression(LUH),
    gleamgen@expression:expression(LUI)
) -> use_function(LUJ, LUK).
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", 195).
-spec use_function5(
    gleamgen@expression:expression(fun((LUS, LUT, LUU, LUV, LUW, LUX) -> LUY)),
    gleamgen@expression:expression(LUS),
    gleamgen@expression:expression(LUT),
    gleamgen@expression:expression(LUU),
    gleamgen@expression:expression(LUV),
    gleamgen@expression:expression(LUW)
) -> use_function(LUX, LUY).
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", 212).
-spec use_function6(
    gleamgen@expression:expression(fun((LVH, LVI, LVJ, LVK, LVL, LVM, LVN) -> LVO)),
    gleamgen@expression:expression(LVH),
    gleamgen@expression:expression(LVI),
    gleamgen@expression:expression(LVJ),
    gleamgen@expression:expression(LVK),
    gleamgen@expression:expression(LVL),
    gleamgen@expression:expression(LVM)
) -> use_function(LVN, LVO).
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", 231).
-spec use_function7(
    gleamgen@expression:expression(fun((LVY, LVZ, LWA, LWB, LWC, LWD, LWE, LWF) -> LWG)),
    gleamgen@expression:expression(LVY),
    gleamgen@expression:expression(LVZ),
    gleamgen@expression:expression(LWA),
    gleamgen@expression:expression(LWB),
    gleamgen@expression:expression(LWC),
    gleamgen@expression:expression(LWD),
    gleamgen@expression:expression(LWE)
) -> use_function(LWF, LWG).
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", 252).
-spec use_function8(
    gleamgen@expression:expression(fun((LWR, LWS, LWT, LWU, LWV, LWW, LWX, LWY, LWZ) -> LXA)),
    gleamgen@expression:expression(LWR),
    gleamgen@expression:expression(LWS),
    gleamgen@expression:expression(LWT),
    gleamgen@expression:expression(LWU),
    gleamgen@expression:expression(LWV),
    gleamgen@expression:expression(LWW),
    gleamgen@expression:expression(LWX),
    gleamgen@expression:expression(LWY)
) -> use_function(LWZ, LXA).
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", 275).
-spec use_function9(
    gleamgen@expression:expression(fun((LXM, LXN, LXO, LXP, LXQ, LXR, LXS, LXT, LXU, LXV) -> LXW)),
    gleamgen@expression:expression(LXM),
    gleamgen@expression:expression(LXN),
    gleamgen@expression:expression(LXO),
    gleamgen@expression:expression(LXP),
    gleamgen@expression:expression(LXQ),
    gleamgen@expression:expression(LXR),
    gleamgen@expression:expression(LXS),
    gleamgen@expression:expression(LXT),
    gleamgen@expression:expression(LXU)
) -> use_function(LXV, LXW).
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", 300).
-spec use_function_unchecked(
    gleamgen@expression:expression(any()),
    list(gleamgen@expression:expression(gleamgen@types:unchecked()))
) -> use_function(any(), any()).
use_function_unchecked(Func, Args) ->
    {use_function, gleamgen_ffi:identity(Func), Args}.

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

-file("src/gleamgen/expression/block.gleam", 319).
-spec with_use1(
    use_function(fun((LYW) -> LYX), LYX),
    binary(),
    fun((gleamgen@expression:expression(LYW)) -> block_builder(LYX))
) -> block_builder(LYX).
with_use1(Use_function, Arg1, Callback) ->
    Rest = Callback(gleamgen@expression:unchecked_ident(Arg1)),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 332).
-spec with_use2(
    use_function(fun((LZD, LZE) -> LZF), LZF),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(LZD), gleamgen@expression:expression(LZE)) -> block_builder(LZF))
) -> block_builder(LZF).
with_use2(Use_function, Arg1, Arg2, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 347).
-spec with_use3(
    use_function(fun((LZM, LZN, LZO) -> LZP), LZP),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(LZM), gleamgen@expression:expression(LZN), gleamgen@expression:expression(LZO)) -> block_builder(LZP))
) -> block_builder(LZP).
with_use3(Use_function, Arg1, Arg2, Arg3, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 371).
-spec with_use4(
    use_function(fun((LZX, LZY, LZZ, MAA) -> MAB), MAB),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(LZX), gleamgen@expression:expression(LZY), gleamgen@expression:expression(LZZ), gleamgen@expression:expression(MAA)) -> block_builder(MAB))
) -> block_builder(MAB).
with_use4(Use_function, Arg1, Arg2, Arg3, Arg4, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 399).
-spec with_use5(
    use_function(fun((MAK, MAL, MAM, MAN, MAO) -> MAP), MAP),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MAK), gleamgen@expression:expression(MAL), gleamgen@expression:expression(MAM), gleamgen@expression:expression(MAN), gleamgen@expression:expression(MAO)) -> block_builder(MAP))
) -> block_builder(MAP).
with_use5(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4),
        gleamgen@expression:unchecked_ident(Arg5)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4, Arg5]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 436).
-spec with_use6(
    use_function(fun((MAZ, MBA, MBB, MBC, MBD, MBE) -> MBF), MBF),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MAZ), gleamgen@expression:expression(MBA), gleamgen@expression:expression(MBB), gleamgen@expression:expression(MBC), gleamgen@expression:expression(MBD), gleamgen@expression:expression(MBE)) -> block_builder(MBF))
) -> block_builder(MBF).
with_use6(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4),
        gleamgen@expression:unchecked_ident(Arg5),
        gleamgen@expression:unchecked_ident(Arg6)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 477).
-spec with_use7(
    use_function(fun((MBQ, MBR, MBS, MBT, MBU, MBV, MBW) -> MBX), MBX),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MBQ), gleamgen@expression:expression(MBR), gleamgen@expression:expression(MBS), gleamgen@expression:expression(MBT), gleamgen@expression:expression(MBU), gleamgen@expression:expression(MBV), gleamgen@expression:expression(MBW)) -> block_builder(MBX))
) -> block_builder(MBX).
with_use7(Use_function, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Callback) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4),
        gleamgen@expression:unchecked_ident(Arg5),
        gleamgen@expression:unchecked_ident(Arg6),
        gleamgen@expression:unchecked_ident(Arg7)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 522).
-spec with_use8(
    use_function(fun((MCJ, MCK, MCL, MCM, MCN, MCO, MCP, MCQ) -> MCR), MCR),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MCJ), gleamgen@expression:expression(MCK), gleamgen@expression:expression(MCL), gleamgen@expression:expression(MCM), gleamgen@expression:expression(MCN), gleamgen@expression:expression(MCO), gleamgen@expression:expression(MCP), gleamgen@expression:expression(MCQ)) -> block_builder(MCR))
) -> block_builder(MCR).
with_use8(
    Use_function,
    Arg1,
    Arg2,
    Arg3,
    Arg4,
    Arg5,
    Arg6,
    Arg7,
    Arg8,
    Callback
) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4),
        gleamgen@expression:unchecked_ident(Arg5),
        gleamgen@expression:unchecked_ident(Arg6),
        gleamgen@expression:unchecked_ident(Arg7),
        gleamgen@expression:unchecked_ident(Arg8)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 571).
-spec with_use9(
    use_function(fun((MDE, MDF, MDG, MDH, MDI, MDJ, MDK, MDL, MDM) -> MDN), MDN),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    binary(),
    fun((gleamgen@expression:expression(MDE), gleamgen@expression:expression(MDF), gleamgen@expression:expression(MDG), gleamgen@expression:expression(MDH), gleamgen@expression:expression(MDI), gleamgen@expression:expression(MDJ), gleamgen@expression:expression(MDK), gleamgen@expression:expression(MDL), gleamgen@expression:expression(MDM)) -> block_builder(MDN))
) -> block_builder(MDN).
with_use9(
    Use_function,
    Arg1,
    Arg2,
    Arg3,
    Arg4,
    Arg5,
    Arg6,
    Arg7,
    Arg8,
    Arg9,
    Callback
) ->
    Rest = Callback(
        gleamgen@expression:unchecked_ident(Arg1),
        gleamgen@expression:unchecked_ident(Arg2),
        gleamgen@expression:unchecked_ident(Arg3),
        gleamgen@expression:unchecked_ident(Arg4),
        gleamgen@expression:unchecked_ident(Arg5),
        gleamgen@expression:unchecked_ident(Arg6),
        gleamgen@expression:unchecked_ident(Arg7),
        gleamgen@expression:unchecked_ident(Arg8),
        gleamgen@expression:unchecked_ident(Arg9)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    [Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, Arg8, Arg9]
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.

-file("src/gleamgen/expression/block.gleam", 624).
-spec with_use_unchecked(
    use_function(any(), MEC),
    list(binary()),
    fun((list(gleamgen@expression:expression(gleamgen@types:unchecked()))) -> block_builder(MEC))
) -> block_builder(MEC).
with_use_unchecked(Use_function, Args, Callback) ->
    Rest = Callback(
        gleam@list:map(Args, fun gleamgen@expression:unchecked_ident/1)
    ),
    _record = Rest,
    {block_builder,
        [begin
                _pipe = gleamgen@expression:new_use(
                    erlang:element(2, Use_function),
                    erlang:element(3, Use_function),
                    Args
                ),
                {expression_statement, _pipe}
            end |
            erlang:element(2, Rest)],
        erlang:element(3, _record)}.
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