gleamgen - v0.4.0

gleamgen/expression/block

Types

UseFunction

</> 
pub type UseFunction(callback_args, ret) {
  UseFunction(
    function: expression.Expression(types.Dynamic),
    args: List(expression.Expression(types.Dynamic)),
  )
}

Constructors

Values

new

</> 
pub fn new(
  statements: List(statement.Statement),
  return: types.GeneratedType(type_),
) -> expression.Expression(type_)

Create a block expression that returns a specific type (see also new_dynamic) Prefer building a block implicitly using the with_ functions of this module

new_dynamic

</> 
pub fn new_dynamic(
  statements: List(statement.Statement),
) -> expression.Expression(any)

use_function1

</> 
pub fn use_function1(
  func: expression.Expression(fn(a, callback) -> ret),
  arg1: expression.Expression(a),
) -> UseFunction(callback, ret)

use_function2

</> 
pub fn use_function2(
  func: expression.Expression(fn(a, b, callback) -> ret),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
) -> UseFunction(callback, ret)

use_function3

</> 
pub fn use_function3(
  func: expression.Expression(fn(a, b, c, callback) -> ret),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
) -> UseFunction(callback, ret)

use_function4

</> 
pub fn use_function4(
  func: expression.Expression(fn(a, b, c, d, callback) -> ret),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
) -> UseFunction(callback, ret)

use_function5

</> 
pub fn use_function5(
  func: expression.Expression(fn(a, b, c, d, e, callback) -> ret),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
  arg5: expression.Expression(e),
) -> UseFunction(callback, ret)

use_function6

</> 
pub fn use_function6(
  func: expression.Expression(
    fn(a, b, c, d, e, f, callback) -> ret,
  ),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
  arg5: expression.Expression(e),
  arg6: expression.Expression(f),
) -> UseFunction(callback, ret)

use_function7

</> 
pub fn use_function7(
  func: expression.Expression(
    fn(a, b, c, d, e, f, g, callback) -> ret,
  ),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
  arg5: expression.Expression(e),
  arg6: expression.Expression(f),
  arg7: expression.Expression(g),
) -> UseFunction(callback, ret)

use_function8

</> 
pub fn use_function8(
  func: expression.Expression(
    fn(a, b, c, d, e, f, g, h, callback) -> ret,
  ),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
  arg5: expression.Expression(e),
  arg6: expression.Expression(f),
  arg7: expression.Expression(g),
  arg8: expression.Expression(h),
) -> UseFunction(callback, ret)

use_function9

</> 
pub fn use_function9(
  func: expression.Expression(
    fn(a, b, c, d, e, f, g, h, i, callback) -> ret,
  ),
  arg1: expression.Expression(a),
  arg2: expression.Expression(b),
  arg3: expression.Expression(c),
  arg4: expression.Expression(d),
  arg5: expression.Expression(e),
  arg6: expression.Expression(f),
  arg7: expression.Expression(g),
  arg8: expression.Expression(h),
  arg9: expression.Expression(i),
) -> UseFunction(callback, ret)

use_function_dynamic

</> 
pub fn use_function_dynamic(
  func: expression.Expression(any),
  args: List(expression.Expression(types.Dynamic)),
) -> UseFunction(callback, ret)

with_comments

</> 
pub fn with_comments(
  comments: List(String),
  handler: fn() -> expression.Expression(ret),
) -> expression.Expression(ret)

with_empty_line

</> 
pub fn with_empty_line(
  handler: fn() -> expression.Expression(ret),
) -> expression.Expression(ret)

with_expression

</> 
pub fn with_expression(
  expression: expression.Expression(type_),
  handler: fn() -> expression.Expression(ret),
) -> expression.Expression(ret)

with_let_declaration

</> 
pub fn with_let_declaration(
  variable: String,
  value: expression.Expression(type_),
  handler: fn(expression.Expression(type_)) -> expression.Expression(
    ret,
  ),
) -> expression.Expression(ret)
{
  use x <- block.with_let_declaration("x", expression.int(4))
  use y <- block.with_let_declaration(
    "y",
    expression.math_operator(x, expression.Add, expression.int(5)),
  )
  y
}
|> expression.render(render.default_context())
|> render.to_string()

outputs:

{
  let x = 4
  let y = x + 5
  y
}

with_matching_let_declaration

</> 
pub fn with_matching_let_declaration(
  pattern: pattern.Pattern(type_, output),
  value: expression.Expression(type_),
  assert_ assert_: Bool,
  handler handler: fn(output) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_statements

</> 
pub fn with_statements(
  statements: List(statement.Statement),
  handler: fn() -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use0

</> 
pub fn with_use0(
  use_function: UseFunction(fn() -> ret, ret),
  callback: fn() -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use1

</> 
pub fn with_use1(
  use_function: UseFunction(fn(a) -> ret, ret),
  arg1: String,
  callback: fn(expression.Expression(a)) -> expression.Expression(
    ret,
  ),
) -> expression.Expression(ret)

with_use2

</> 
pub fn with_use2(
  use_function: UseFunction(fn(a, b) -> ret, ret),
  arg1: String,
  arg2: String,
  callback: fn(expression.Expression(a), expression.Expression(b)) -> expression.Expression(
    ret,
  ),
) -> expression.Expression(ret)

with_use3

</> 
pub fn with_use3(
  use_function: UseFunction(fn(a, b, c) -> ret, ret),
  arg1: String,
  arg2: String,
  arg3: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use4

</> 
pub fn with_use4(
  use_function: UseFunction(fn(a, b, c, d) -> ret, ret),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use5

</> 
pub fn with_use5(
  use_function: UseFunction(fn(a, b, c, d, e) -> ret, ret),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  arg5: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
    expression.Expression(e),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use6

</> 
pub fn with_use6(
  use_function: UseFunction(fn(a, b, c, d, e, f) -> ret, ret),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  arg5: String,
  arg6: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
    expression.Expression(e),
    expression.Expression(f),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use7

</> 
pub fn with_use7(
  use_function: UseFunction(fn(a, b, c, d, e, f, g) -> ret, ret),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  arg5: String,
  arg6: String,
  arg7: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
    expression.Expression(e),
    expression.Expression(f),
    expression.Expression(g),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use8

</> 
pub fn with_use8(
  use_function: UseFunction(
    fn(a, b, c, d, e, f, g, h) -> ret,
    ret,
  ),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  arg5: String,
  arg6: String,
  arg7: String,
  arg8: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
    expression.Expression(e),
    expression.Expression(f),
    expression.Expression(g),
    expression.Expression(h),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use9

</> 
pub fn with_use9(
  use_function: UseFunction(
    fn(a, b, c, d, e, f, g, h, i) -> ret,
    ret,
  ),
  arg1: String,
  arg2: String,
  arg3: String,
  arg4: String,
  arg5: String,
  arg6: String,
  arg7: String,
  arg8: String,
  arg9: String,
  callback: fn(
    expression.Expression(a),
    expression.Expression(b),
    expression.Expression(c),
    expression.Expression(d),
    expression.Expression(e),
    expression.Expression(f),
    expression.Expression(g),
    expression.Expression(h),
    expression.Expression(i),
  ) -> expression.Expression(ret),
) -> expression.Expression(ret)

with_use_dynamic

</> 
pub fn with_use_dynamic(
  use_function: UseFunction(any_func, ret),
  args: List(String),
  callback: fn(List(expression.Expression(types.Dynamic))) -> expression.Expression(
    ret,
  ),
) -> expression.Expression(ret)
✨ Search Document