gleamgen/pattern · gleamgen

as_

pub fn as_(
  original: Pattern(input, match_output),
  name: String,
) -> Pattern(input, expression.Expression(input))

bool_literal

</>

pub fn bool_literal(literal: Bool) -> Pattern(Bool, Nil)

Match a boolean literal

concat_string

</>

pub fn concat_string(
  starting initial: String,
  variable variable: String,
) -> Pattern(String, expression.Expression(a))

Match a string that starts with initial

case_.new(expression.string("I love gleam"))
|> case_.with_pattern(
  pattern.concat_string(starting: "I love ", variable: "thing"),
  fn(thing) {
    expression.string("I love ")
    |> expression.concat_string(thing)
    |> expression.concat_string(expression.string(" too"))
  },
)
|> case_.with_pattern(pattern.variable("_"), fn(_) {
  expression.string("interesting")
})
|> case_.build_expression()
|> expression.render(render.default_context())
|> render.to_string()
// -> "case \"I love gleam\" {
 \"I love \" <> thing -> \"I love \" <> thing <> \" too\"
 _ -> \"Interesting\"
}"

discard

</>

pub fn discard() -> Pattern(a, Nil)

Match and discard any value (Generates _). If you want to name the discarded value, use named_discard If you want to use the discarded value in the output, use variable

error

</>

pub fn error(
  err_pattern: Pattern(a, a_output),
) -> Pattern(Result(ok, a), a_output)

from_constructor0

</>

pub fn from_constructor0(
  constructor: constructor.Constructor(
    construct_to,
    #(),
    generics,
  ),
) -> Pattern(construct_to, Nil)

See from_constructor1.

from_constructor1

</>

pub fn from_constructor1(
  constructor: constructor.Constructor(
    construct_to,
    #(#(), a),
    generics,
  ),
  first: Pattern(a, a_output),
) -> Pattern(custom.CustomType(construct_to, generics), a_output)

Create a pattern that matches a custom constructor with one argument. Use from_constructor_dynamic for ad dynamic number of arguments.

let animals =
  custom.new(ExampleAnimal)
  |> custom.with_variant(fn(_) {
    variant.new("Dog")
    |> variant.with_argument(option.Some("bones"), type_.int)
  })

use animal_type, dog_constructor <- module.with_custom_type1(
  definition.new("Animal") |> definition.with_publicity(True),
  animals,
)
...
pattern.from_constructor1(
  dog_constructor,
  pattern.variable("bones"),
) |> pattern.render(context, 1)
// -> "Dog(bones)"

from_constructor2

</>

pub fn from_constructor2(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(), a), b),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
) -> Pattern(
  custom.CustomType(construct_to, generics),
  #(a_output, b_output),
)

from_constructor3

</>

pub fn from_constructor3(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(), a), b), c),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
) -> Pattern(construct_to, #(a_output, b_output, c_output))

from_constructor4

</>

pub fn from_constructor4(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(), a), b), c), d),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
) -> Pattern(
  construct_to,
  #(a_output, b_output, c_output, d_output),
)

from_constructor5

</>

pub fn from_constructor5(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(#(), a), b), c), d), e),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
  fifth: Pattern(e, e_output),
) -> Pattern(
  construct_to,
  #(a_output, b_output, c_output, d_output, e_output),
)

from_constructor6

</>

pub fn from_constructor6(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(#(#(), a), b), c), d), e), f),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
  fifth: Pattern(e, e_output),
  sixth: Pattern(f, f_output),
) -> Pattern(
  construct_to,
  #(a_output, b_output, c_output, d_output, e_output, f_output),
)

from_constructor7

</>

pub fn from_constructor7(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(#(#(#(), a), b), c), d), e), f), g),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
  fifth: Pattern(e, e_output),
  sixth: Pattern(f, f_output),
  seventh: Pattern(g, g_output),
) -> Pattern(
  construct_to,
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
  ),
)

from_constructor8

</>

pub fn from_constructor8(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(#(#(#(#(), a), b), c), d), e), f), g), h),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
  fifth: Pattern(e, e_output),
  sixth: Pattern(f, f_output),
  seventh: Pattern(g, g_output),
  eighth: Pattern(h, h_output),
) -> Pattern(
  construct_to,
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
    h_output,
  ),
)

from_constructor9

</>

pub fn from_constructor9(
  constructor: constructor.Constructor(
    construct_to,
    #(#(#(#(#(#(#(#(#(#(), a), b), c), d), e), f), g), h), i),
    generics,
  ),
  first: Pattern(a, a_output),
  second: Pattern(b, b_output),
  third: Pattern(c, c_output),
  fourth: Pattern(d, d_output),
  fifth: Pattern(e, e_output),
  sixth: Pattern(f, f_output),
  seventh: Pattern(g, g_output),
  eighth: Pattern(h, h_output),
  ninth: Pattern(i, i_output),
) -> Pattern(
  construct_to,
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
    h_output,
    i_output,
  ),
)

from_constructor_dynamic

</>

pub fn from_constructor_dynamic(
  constructor: constructor.Constructor(
    construct_to,
    any,
    generics,
  ),
  constructors: List(Pattern(type_.Dynamic, type_.Dynamic)),
) -> Pattern(
  construct,
  List(expression.Expression(type_.Dynamic)),
)

get_output

</>

pub fn get_output(pattern: Pattern(input, output)) -> output

int_literal

</>

pub fn int_literal(literal: Int) -> Pattern(Int, Nil)

Match an integer literal

list_empty

</>

pub fn list_empty() -> Pattern(List(a), Nil)

Renders [].

list_first_discard_rest

</>

pub fn list_first_discard_rest(
  first: String,
) -> Pattern(List(a), expression.Expression(a))

Renders [first, ..] and binds the head element to first.

named_discard

</>

pub fn named_discard(name: String) -> Pattern(a, Nil)

Match and discard any value (Generates _name)

ok

</>

pub fn ok(
  ok_pattern: Pattern(a, a_output),
) -> Pattern(Result(a, err), a_output)

option_none

</>

pub fn option_none() -> Pattern(option.Option(a), Nil)

Matches with None. If the option module is already imported, this uses the existing import options (ie qualified or unqualified and aliases). Otherwise, it adds the import.

option_some

</>

pub fn option_some(
  inner: Pattern(a, a_out),
) -> Pattern(option.Option(a), a_out)

Matches with option.Some(inner). If the option module is already imported, this uses the existing import options (ie qualified or unqualified and aliases). Otherwise, it adds the import.

or

</>

pub fn or(
  first: Pattern(input, match_output),
  second: Pattern(input, match_output),
) -> Pattern(input, match_output)

Use either of the two patterns

case_.new(expression.string("hello"))
|> case_.with_pattern(
  pattern.or(pattern.string_literal("hello"), pattern.string_literal("hi")),
  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()
// -> "case \"hello\" {
 \"hello\" | \"hi\" -> \"world\"
 v -> v <> \" world\"
}",

render

</>

pub fn render(
  pattern: Pattern(type_.Dynamic, type_.Dynamic),
  context: render.Context,
  number_of_subjects: Int,
) -> render.Rendered

string_literal

</>

pub fn string_literal(literal: String) -> Pattern(a, Nil)

Match a string literal

to_dynamic

</>

pub fn to_dynamic(
  type_: Pattern(input, handler_output),
) -> Pattern(type_.Dynamic, type_.Dynamic)

tuple0

</>

pub fn tuple0() -> Pattern(#(), Nil)

tuple1

</>

pub fn tuple1(
  pattern: Pattern(a_input, a_output),
) -> Pattern(#(a_input), #(a_output))

tuple2

</>

pub fn tuple2(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
) -> Pattern(#(a_input, b_input), #(a_output, b_output))

tuple3

</>

pub fn tuple3(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
) -> Pattern(
  #(a_input, b_input, c_input),
  #(a_output, b_output, c_output),
)

tuple4

</>

pub fn tuple4(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
) -> Pattern(
  #(a_input, b_input, c_input, d_input),
  #(a_output, b_output, c_output, d_output),
)

tuple5

</>

pub fn tuple5(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
  pattern5: Pattern(e_input, e_output),
) -> Pattern(
  #(a_input, b_input, c_input, d_input, e_input),
  #(a_output, b_output, c_output, d_output, e_output),
)

tuple6

</>

pub fn tuple6(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
  pattern5: Pattern(e_input, e_output),
  pattern6: Pattern(f_input, f_output),
) -> Pattern(
  #(a_input, b_input, c_input, d_input, e_input, f_input),
  #(a_output, b_output, c_output, d_output, e_output, f_output),
)

tuple7

</>

pub fn tuple7(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
  pattern5: Pattern(e_input, e_output),
  pattern6: Pattern(f_input, f_output),
  pattern7: Pattern(g_input, g_output),
) -> Pattern(
  #(a_input, b_input, c_input, d_input, e_input, f_input, g_input),
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
  ),
)

tuple8

</>

pub fn tuple8(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
  pattern5: Pattern(e_input, e_output),
  pattern6: Pattern(f_input, f_output),
  pattern7: Pattern(g_input, g_output),
  pattern8: Pattern(h_input, h_output),
) -> Pattern(
  #(
    a_input,
    b_input,
    c_input,
    d_input,
    e_input,
    f_input,
    g_input,
    h_input,
  ),
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
    h_output,
  ),
)

tuple9

</>

pub fn tuple9(
  pattern1: Pattern(a_input, a_output),
  pattern2: Pattern(b_input, b_output),
  pattern3: Pattern(c_input, c_output),
  pattern4: Pattern(d_input, d_output),
  pattern5: Pattern(e_input, e_output),
  pattern6: Pattern(f_input, f_output),
  pattern7: Pattern(g_input, g_output),
  pattern8: Pattern(h_input, h_output),
  pattern9: Pattern(i_input, i_output),
) -> Pattern(
  #(
    a_input,
    b_input,
    c_input,
    d_input,
    e_input,
    f_input,
    g_input,
    h_input,
    i_input,
  ),
  #(
    a_output,
    b_output,
    c_output,
    d_output,
    e_output,
    f_output,
    g_output,
    h_output,
    i_output,
  ),
)

variable

</>

pub fn variable(
  name: String,
) -> Pattern(a, expression.Expression(a))

Match any value with a variable name. If you do not care about the contents, use discard