gleamgen/expression

Generating Expressions:

Using expressions:

render
type_

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_flaot`

pub type MathOperator {
  Add
  Sub
  Mul
  Div
}

Constructors

```
Add
```
```
Sub
```
```
Mul
```
```
Div
```

Values

and

</>

pub fn and(
  expr1: Expression(Bool),
  expr2: Expression(Bool),
) -> Expression(Bool)

Apply the and operator to two expressions with the type of Bool.

expression.and(expression.raw("has_cheese"), expression.raw("wants_cheese"))
// Expression(Bool) -> "has_cheese && wants_cheese"

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)

Create a boolean literal expression.

expression.bool(True) // Expression(Bool) -> True

call0

</>

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

Call a function or constructor with no arguments

expression.call0(
  import_.value_of_type(dict_module, "new", types.reference(dict.new))
) // Expression(dict.Dict(key, value)) -> "dict.new()"

call1

</>

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

Call a function or constructor with one argument.

expression.call1(
  import_.value_of_type(list_module, "is_empty", types.reference(list.is_empty))
  expression.list([])
) // Expression(Bool) -> "list.is_empty([])"

To call with a dynamic number of arguments, use call_dynamic.

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 call1.

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 call1.

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 call1.

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 call1.

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 call1.

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 call1.

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 call1.

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 call1.

call_dynamic

</>

pub fn call_dynamic(
  func: Expression(type_.Dynamic),
  args: List(Expression(type_.Dynamic)),
) -> Expression(type_.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.raw("greeting"), expression.string("world"))
// Expression(String) -> greeting <> "world"

construct0

</>

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

construct1

</>

pub const construct1: fn(
  Expression(fn(arg1) -> ret),
  Expression(arg1),
) -> Expression(ret)

construct2

</>

pub const construct2: fn(
  Expression(fn(arg1, arg2) -> ret),
  Expression(arg1),
  Expression(arg2),
) -> Expression(ret)

construct3

</>

pub const construct3: fn(
  Expression(fn(arg1, arg2, arg3) -> ret),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
) -> Expression(ret)

construct4

</>

pub const construct4: fn(
  Expression(fn(arg1, arg2, arg3, arg4) -> ret),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
) -> Expression(ret)

construct5

</>

pub const construct5: fn(
  Expression(fn(arg1, arg2, arg3, arg4, arg5) -> ret),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
  Expression(arg5),
) -> Expression(ret)

construct6

</>

pub const construct6: fn(
  Expression(fn(arg1, arg2, arg3, arg4, arg5, arg6) -> ret),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
  Expression(arg5),
  Expression(arg6),
) -> Expression(ret)

construct7

</>

pub const construct7: fn(
  Expression(fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7) -> ret),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
  Expression(arg5),
  Expression(arg6),
  Expression(arg7),
) -> Expression(ret)

construct8

</>

pub const construct8: fn(
  Expression(
    fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) -> ret,
  ),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
  Expression(arg5),
  Expression(arg6),
  Expression(arg7),
  Expression(arg8),
) -> Expression(ret)

construct9

</>

pub const construct9: fn(
  Expression(
    fn(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) -> ret,
  ),
  Expression(arg1),
  Expression(arg2),
  Expression(arg3),
  Expression(arg4),
  Expression(arg5),
  Expression(arg6),
  Expression(arg7),
  Expression(arg8),
  Expression(arg9),
) -> Expression(ret)

echo_

</>

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

Create an echo expression with an optional as clause.

expression.echo_(
  expression.math_operator(
    expression.int(2),
    expression.Add,
    expression.int(3),
  ), 
  option.None
) // Expression(Int) -> echo 2 + 3

equals

</>

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

Determine if values are equal using == syntax.

expression.equals(
  expression.raw("movie"),
  expression.string("The Needle")
) // Expression(Bool) -> movie == "The Needle"

error

</>

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

Create an Error value of the result type.

expression.error(expression.string("File not found"))
// Expression(Result(ok, String)) -> Error("File not found")

field

</>

pub fn field(
  base: Expression(a),
  field: String,
) -> Expression(type_.Dynamic)

Access a field of a custom type or tuple. This function cannot be type checked, so it returns an Expression(type_.Dynamic)

expression.field(expression.raw("movie"), "director") 
// Expression(type_.Dynamic) -> movie.director

float

</>

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

Create a float literal expression.

expression.float(3.14) // Expression(Float) -> 3.14

int

</>

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

Create an integer literal expression.

expression.int(42) // Expression(Int) -> 42

list

</>

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

Create a list literal expression.

expression.list([
  expression.int(1),
  expression.int(2),
  expression.int(3),
  expression.int(4),
]) // Expression(List(Int)) -> [1, 2, 3, 4]

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.

expression.list_prepend(
  [expression.int(1), expression.int(2)],
  expression.raw("integers")
) Expression(List(Int)) // -> [1, 2, ..integers]

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)

Create a Nil literal expression.

expression.nil() // Expression(Nil) -> Nil

not_equals

</>

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

Determine if values are not equal using != syntax.

expression.not_equals(
  expression.raw("movie"),
  expression.string("The Shining")
) // Expression(Bool) -> movie != "The Shining"

ok

</>

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

Create an Ok value of the result type.

expression.ok(expression.int(5))
// Expression(Result(Int, error)) -> Ok(5)

option_none

</>

pub fn option_none() -> Expression(option.Option(t))

option_some

</>

pub fn option_some(
  value: Expression(t),
) -> Expression(option.Option(t))

or

</>

pub fn or(
  expr1: Expression(Bool),
  expr2: Expression(Bool),
) -> Expression(Bool)

Apply the or operator to two expressions with the type of Bool.

expression.or(expression.raw("wants_cake"), expression.raw("wants_cheese"))
// Expression(Bool) -> "wants_cake || wants_cheese"

panic_

</>

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

Create a panic expression with an optional as clause.

expression.panic_(option.Some("ahhhhhh!!!"))
// Expression(a) -> "panic as \"ahhhhhh!!!\""

raw

</>

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

Provide an ident that could be of any type Prefer using raw_of_type

raw_of_type

</>

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

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

render

</>

pub fn render(
  expression: Expression(t),
  context: render.Context,
) -> render.Rendered

Render an expression. See the render module for more information. In general, prefer rendering at the module level, rather than individual expressions.

string

</>

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

Create a string literal expression.

expression.string("Labas!") // Expression(String) -> "Labas!"

to_dynamic

</>

pub fn to_dynamic(
  type_: Expression(t),
) -> Expression(type_.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(a) -> "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)) -> type_.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)

Return a new expression that will be rendered with a specific render config, separate from the config used for the surrounding expression. See the render module for more information.

Generating Expressions:

Literals:

Operators:

Keywords:

Other expressions:

Creating dynamic expressions:

Using expressions:

Constructors

Constructors