gleamgen/expression/case_

Types

pub opaque type CaseExpression(input, output)

Values

pub fn build_expression(
  case_: CaseExpression(input, output),
) -> expression.Expression(output)
pub fn new(
  input_expression: expression.Expression(input),
) -> CaseExpression(input, a)

Create a new case expression that matches on the given input_expression

case_.new(expression.string("hello"))
|> case_.with_pattern(pattern.string_literal("hello"), fn(_) {
  expression.string("world")
})
|> case_.with_pattern(pattern.variable("v"), fn(v) {
  expression.concat_string(v, expression.string(" world"))
})
|> case_.build_expression()
|> expression.render(render.default_context())
|> render.to_string()

This creates:

case "hello" {
  "hello" -> "world"
  v -> v <> " world"
}

Note that providing a tuple literal as the case subject will expand into multiple subjects:

case_.new(expression.tuple2(expression.string("hello"), expression.int(3)))
|> case_.with_pattern(
  pattern.tuple2(pattern.string_literal("hello"), pattern.variable("_")),
  fn(_) { expression.string("world") },
)
|> case_.with_pattern(pattern.variable("_"), fn(_) {
  expression.string("other")
})
|> case_.build_expression()
|> expression.render(render.default_context())
|> render.to_string()

This creates:

case "hello", 3 {
  "hello", _ -> "world"
  _, _ -> "other"
}
pub fn with_pattern(
  old: CaseExpression(input, output),
  pattern: pattern.Pattern(input, pattern_output),
  handler: fn(pattern_output) -> expression.Expression(output),
) -> CaseExpression(input, output)
pub fn with_pattern_guarded(
  old: CaseExpression(input, output),
  pattern: pattern.Pattern(input, pattern_output),
  guard: expression.Expression(Bool),
  handler: fn(pattern_output) -> expression.Expression(output),
) -> CaseExpression(input, output)
Search Document