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)