gleamgen - v0.4.0

gleamgen/expression

Types

Comparison

</> 
pub type Comparison {
  GreaterThan
  GreaterThanOrEqual
  LessThan
  LessThanOrEqual
}

Constructors 

  • GreaterThan
  • GreaterThanOrEqual
  • LessThan
  • LessThanOrEqual

Expression

opaque </> 
pub opaque type Expression(type_)

MathOperator

</>

See math_operator and math_operator_float

pub type MathOperator {
  Add
  Sub
  Mul
  Div
}

Constructors 

  • Add
  • Sub
  • Mul
  • Div

Values

assert_

</> 
pub fn assert_(
  condition: Expression(Bool),
  as_string: option.Option(String),
) -> Expression(Nil)

Create an assert expression with an optional as clause

bool

</> 
pub fn bool(value: Bool) -> Expression(Bool)

call0

</> 
pub fn call0(func: Expression(fn() -> ret)) -> Expression(ret)

Call a function or constructor with no arguments

expression.call0(
  import_.function0(dict_module, dict.new)
)
|> expression.render(render.default_context())
|> render.to_string()
// -> "dict.new()"

call1

</> 
pub fn call1(
  func: Expression(fn(arg1) -> ret),
  arg1: Expression(arg1),
) -> Expression(ret)

Call a function or constructor with one argument See call0

call2

</> 
pub fn call2(
  func: Expression(fn(arg1, arg2) -> ret),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
) -> Expression(ret)

Call a function or constructor with two arguments See call0

call3

</> 
pub fn call3(
  func: Expression(fn(arg1, arg2, arg3) -> ret),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
) -> Expression(ret)

Call a function or constructor with three arguments See call0

call4

</> 
pub fn call4(
  func: Expression(fn(arg1, arg2, arg3, arg4) -> ret),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
) -> Expression(ret)

Call a function or constructor with four arguments See call0

call5

</> 
pub fn call5(
  func: Expression(fn(arg1, arg2, arg3, arg4, arg5) -> ret),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
  arg5: Expression(arg5),
) -> Expression(ret)

Call a function or constructor with five arguments See call0

call6

</> 
pub fn call6(
  func: Expression(fn(arg1, arg2, arg3, arg4, arg5, arg6) -> ret),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
  arg5: Expression(arg5),
  arg6: Expression(arg6),
) -> Expression(ret)

Call a function or constructor with six arguments See call0

call7

</> 
pub fn call7(
  func: Expression(
    fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -> ret,
  ),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
  arg5: Expression(arg5),
  arg6: Expression(arg6),
  arg7: Expression(arg7),
) -> Expression(ret)

Call a function or constructor with seven arguments See call0

call8

</> 
pub fn call8(
  func: Expression(
    fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) -> ret,
  ),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
  arg5: Expression(arg5),
  arg6: Expression(arg6),
  arg7: Expression(arg7),
  arg8: Expression(arg8),
) -> Expression(ret)

Call a function or constructor with eight arguments See call0

call9

</> 
pub fn call9(
  func: Expression(
    fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -> ret,
  ),
  arg1: Expression(arg1),
  arg2: Expression(arg2),
  arg3: Expression(arg3),
  arg4: Expression(arg4),
  arg5: Expression(arg5),
  arg6: Expression(arg6),
  arg7: Expression(arg7),
  arg8: Expression(arg8),
  arg9: Expression(arg9),
) -> Expression(ret)

Call a function or constructor with nine arguments See call0

call_dynamic

</> 
pub fn call_dynamic(
  func: Expression(types.Dynamic),
  args: List(Expression(types.Dynamic)),
) -> Expression(types.Dynamic)

Call a function or constructor without type checking

coerce_dynamic_unsafe

</> 
pub fn coerce_dynamic_unsafe(
  type_: Expression(t1),
) -> Expression(t2)

Convert an expression to any type without checking

comparison

</> 
pub fn comparison(
  expr1: Expression(Int),
  operator: Comparison,
  expr2: Expression(Int),
) -> Expression(Bool)

comparison_float

</> 
pub fn comparison_float(
  expr1: Expression(Float),
  operator: Comparison,
  expr2: Expression(Float),
) -> Expression(Bool)

concat_string

</> 
pub fn concat_string(
  expr1: Expression(String),
  expr2: Expression(String),
) -> Expression(String)

Use the <> operator to concatenate two strings

expression.concat_string(expression.string("hello "), expression.string("world"))
|> expression.render(render.default_context())
|> render.to_string()
// -> "\"hello \" <> \"world\""

construct0

</> 
pub fn construct0(
  constructor: Expression(fn() -> ret),
) -> Expression(ret)

construct1

</> 
pub const construct1: fn(Expression(fn(a) -> b), Expression(a)) -> Expression(
  b,
)

construct2

</> 
pub const construct2: fn(
  Expression(fn(c, d) -> e),
  Expression(c),
  Expression(d),
) -> Expression(e)

construct3

</> 
pub const construct3: fn(
  Expression(fn(f, g, h) -> i),
  Expression(f),
  Expression(g),
  Expression(h),
) -> Expression(i)

construct4

</> 
pub const construct4: fn(
  Expression(fn(j, k, l, m) -> n),
  Expression(j),
  Expression(k),
  Expression(l),
  Expression(m),
) -> Expression(n)

construct5

</> 
pub const construct5: fn(
  Expression(fn(o, p, q, r, s) -> t),
  Expression(o),
  Expression(p),
  Expression(q),
  Expression(r),
  Expression(s),
) -> Expression(t)

construct6

</> 
pub const construct6: fn(
  Expression(fn(u, v, w, x, y, z) -> aa),
  Expression(u),
  Expression(v),
  Expression(w),
  Expression(x),
  Expression(y),
  Expression(z),
) -> Expression(aa)

construct7

</> 
pub const construct7: fn(
  Expression(fn(ab, ac, ad, ae, af, ag, ah) -> ai),
  Expression(ab),
  Expression(ac),
  Expression(ad),
  Expression(ae),
  Expression(af),
  Expression(ag),
  Expression(ah),
) -> Expression(ai)

construct8

</> 
pub const construct8: fn(
  Expression(fn(aj, ak, al, am, an, ao, ap, aq) -> ar),
  Expression(aj),
  Expression(ak),
  Expression(al),
  Expression(am),
  Expression(an),
  Expression(ao),
  Expression(ap),
  Expression(aq),
) -> Expression(ar)

construct9

</> 
pub const construct9: fn(
  Expression(fn(as, at, au, av, aw, ax, ay, az, ba) -> bb),
  Expression(as),
  Expression(at),
  Expression(au),
  Expression(av),
  Expression(aw),
  Expression(ax),
  Expression(ay),
  Expression(az),
  Expression(ba),
) -> Expression(bb)

echo_

</> 
pub fn echo_(
  expression: Expression(a),
  as_string: option.Option(String),
) -> Expression(a)

equals

</> 
pub fn equals(
  first: Expression(a),
  second: Expression(a),
) -> Expression(Bool)

error

</> 
pub fn error(
  err_value: Expression(err),
) -> Expression(Result(ok, err))

float

</> 
pub fn float(value: Float) -> Expression(Float)

int

</> 
pub fn int(value: Int) -> Expression(Int)

list

</> 
pub fn list(value: List(Expression(t))) -> Expression(List(t))

list_prepend

</> 
pub fn list_prepend(
  prepending: List(Expression(t)),
  original: Expression(List(t)),
) -> Expression(List(t))

Prepend value(s) to list using [value, ..original] syntax

math_operator

</> 
pub fn math_operator(
  expr1: Expression(Int),
  op: MathOperator,
  expr2: Expression(Int),
) -> Expression(Int)

Apply a math operator to two expressions with the type of Int

expression.math_operator(expression.int(3), expression.Add, expression.int(5))
|> expression.render(render.default_context())
|> render.to_string()
// -> "3 + 5"

math_operator_float

</> 
pub fn math_operator_float(
  expr1: Expression(Float),
  op: MathOperator,
  expr2: Expression(Float),
) -> Expression(Int)

Apply a math operator to two expressions with the type of Float

expression.math_operator_float(
  expression.float(3.3),
  expression.Sub,
  expression.unchecked_ident("other_float")
)
|> expression.render(render.default_context())
|> render.to_string()
// -> "3.3 -. other_float"

nil

</> 
pub fn nil() -> Expression(Nil)

not_equals

</> 
pub fn not_equals(
  first: Expression(a),
  second: Expression(a),
) -> Expression(Bool)

ok

</> 
pub fn ok(
  ok_value: Expression(ok),
) -> Expression(Result(ok, err))

panic_

</> 
pub fn panic_(as_string: option.Option(String)) -> Expression(a)

Create a panic expression with an optional as clause

expression.todo_(option.Some("ahhhhhh!!!"))
|> expression.render(render.default_context())
|> render.to_string()
// -> "panic as \"ahhhhhh!!!\""

raw

</> 
pub fn raw(value: String) -> Expression(a)

Provide an ident that could be of any type

raw_of_type

</> 
pub fn raw_of_type(
  value: String,
  type_: types.GeneratedType(t),
) -> Expression(t)

Provide a string to inject without any checking of the specified type

render

</> 
pub fn render(
  expression: Expression(t),
  context: @internal Context,
) -> @internal Rendered

render_statement

</> 
pub fn render_statement(
  statement: @internal Statement,
  context: @internal Context,
) -> @internal Rendered

string

</> 
pub fn string(value: String) -> Expression(String)

to_dynamic

</> 
pub fn to_dynamic(
  type_: Expression(t),
) -> Expression(types.Dynamic)

todo_

</> 
pub fn todo_(as_string: option.Option(String)) -> Expression(a)

Create a todo expression with an optional as clause

expression.todo_(option.Some("some unimplemented thing"))
|> expression.render(render.default_context())
|> render.to_string()
// -> "todo as \"some unimplemented thing\""

tuple1

</> 
pub fn tuple1(arg1: Expression(a)) -> Expression(#(a))

tuple2

</> 
pub fn tuple2(
  arg1: Expression(a),
  arg2: Expression(b),
) -> Expression(#(a, b))

tuple3

</> 
pub fn tuple3(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
) -> Expression(#(a, b, c))

tuple4

</> 
pub fn tuple4(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
) -> Expression(#(a, b, c, d))

tuple5

</> 
pub fn tuple5(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
  arg5: Expression(e),
) -> Expression(#(a, b, c, d, e))

tuple6

</> 
pub fn tuple6(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
  arg5: Expression(e),
  arg6: Expression(f),
) -> Expression(#(a, b, c, d, e, f))

tuple7

</> 
pub fn tuple7(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
  arg5: Expression(e),
  arg6: Expression(f),
  arg7: Expression(g),
) -> Expression(#(a, b, c, d, e, f, g))

tuple8

</> 
pub fn tuple8(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
  arg5: Expression(e),
  arg6: Expression(f),
  arg7: Expression(g),
  arg8: Expression(h),
) -> Expression(#(a, b, c, d, e, f, g, h))

tuple9

</> 
pub fn tuple9(
  arg1: Expression(a),
  arg2: Expression(b),
  arg3: Expression(c),
  arg4: Expression(d),
  arg5: Expression(e),
  arg6: Expression(f),
  arg7: Expression(g),
  arg8: Expression(h),
  arg9: Expression(i),
) -> Expression(#(a, b, c, d, e, f, g, h, i))

type_

</> 
pub fn type_(expr: Expression(t)) -> types.GeneratedType(t)

Get the internal type of an expression

with_render_config

</> 
pub fn with_render_config(
  expression: Expression(t),
  config: config.Config,
) -> Expression(t)
✨ Search Document