Generates a + operation.

Examples

trick.add(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 + 2")

Generates a +. operation.

Examples

trick.add_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 +. 2.0")

Generates a && operation.

Examples

trick.and(trick.bool(True), trick.bool(False))
|> trick.expression_to_string
// -> Ok("True && False")

Generates an anonymous function.

Examples

trick.anonymous({
  use a <- trick.parameter("a", trick.int_type())
  use b <- trick.parameter("b", trick.int_type())
  trick.add(a, b) |> trick.expression |> trick.function_body
})
|> trick.expression_to_string
// -> Ok("fn(a: Int, b: Int) { a + b }")

Generates an assert statement with an optional message. The condition must be of type Bool, and the message, if present, must be of type String.

Like expression, assert by default terminates the block and doesn’t expect a continuation. To place statements after an assert, use discard.

Examples

trick.assert_(trick.bool(True), None)
|> trick.block
|> trick.expression_to_string

Will generate:

{
  assert True
}

trick.assert_(trick.bool(False), Some(trick.string("This will panic")))
|> trick.block
|> trick.expression_to_string

Will generate:

{
  assert False as \"This will panic\"
}

trick.assert_(trick.int(1), None)
|> trick.block
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Bool, got: Int))

trick.assert_(trick.bool(True), Some(trick.bool(True)))
|> trick.block
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: String, got: Bool))

Generates a pattern which matches a specific value and binds it to a variable. To match any value and bind it to a variable, see variable_pattern.

Examples

trick.case_(trick.int(1), [
  {
    use x <- trick.clause(
      trick.assignment_pattern(trick.int_pattern(1), "x"),
    )
    trick.add(x, 1)
  },
  {
    use x <- trick.clause(trick.variable_pattern("x"))
    x
  },
])
|> trick.expression_to_string

Will generate:

case 1 {
  1 as x -> x + 1
  x -> x
}

Returns the BitArray type.

Generates a block wrapping one or more statements.

Examples

trick.int(1)
|> trick.add(trick.int(2))
|> trick.expression
|> trick.block
|> trick.expression_to_string
// -> Ok("{ 1 + 2 }")

trick.block({
  use x <- trick.variable("x", trick.int(1))
  use y <- trick.variable("y", trick.int(2))
  trick.expression(trick.add(x, y))
})
|> trick.expression_to_string

Will generate:

{
  let x = 1
  let y = 2
  x + y
}

Generates a Bool.

Examples

trick.bool(True) |> trick.expression_to_string
// -> Ok("True")

Generates a pattern that matches a specific bool value.

Examples

{
  use bool_to_string <- trick.function("bool_to_string", trick.Public, {
    use value <- trick.parameter("value", trick.bool_type())
    trick.function_body(trick.expression(trick.case_(value, [
      {
        use _ <- trick.clause(trick.bool_pattern(True))
        trick.string("True")
      },
      {
        use _ <- trick.clause(trick.bool_pattern(False))
        trick.string("False")
      },
    ])))
  })

  trick.end_module()
}
|> trick.to_string

Will generate:

pub fn bool_to_string(value: Bool) -> String {
  case value {
    True -> "True"
    False -> "False"
  }
}

Returns the Bool type.

Generates a function call with unlabelled arguments. To use labels in the call, see labelled_call.

Example

The following examples assume a function called add defined as the following:

pub fn add(a: Int, b: Int) -> Int {
  a + b
}

The definition has been omitted for brevity. See function for examples of how to create functions.

trick.call(add, [trick.int(1), trick.int(2)]) |> trick.expression_to_string
// -> Ok("add(1, 2)")

trick.call(add, [trick.float(1.0), trick.float(2.0)])
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

trick.call(add, [trick.int(1), trick.int(2), trick.int(3)])
|> trick.expression_to_string
// -> Error(IncorrectNumberOfArguments(expected: 2, got: 3))

trick.call(trick.int(1), [trick.int(2), trick.int(3)])
|> trick.expression_to_string
// -> Error(InvalidCall(type_: int))

Generates a case expression that matches one or more patterns against a value. NOTE: Currently this does not perform any form of exhaustiveness checking so you need to ensure that patterns are exhaustive yourself.

Examples

{
  use operation_type <- trick.custom_type("Operation", trick.Public)
  use operation_constructor <- trick.constructor("Operation", [
    trick.Field(Some("operator"), trick.string_type()),
    trick.Field(Some("a"), trick.int_type()),
    trick.Field(Some("b"), trick.int_type()),
  ])
  use <- trick.end_custom_type

  use evaluate <- trick.funtion("evaluate", trick.Public, {
    use operation <- trick.parameter("operation", operation_type)
    trick.function_body(trick.expression(trick.case_(operation, [
      {
        use #(a, b) <- trick.clause(trick.constructor_pattern(
          operation_constructor,
          {
            use _ <- trick.pattern(trick.string_pattern("+"))
            use a <- trick.pattern(trick.variable_pattern("a"))
            use b <- trick.pattern(trick.variable_pattern("b"))
            #(a, b)
          },
        ))
        ttrick.return_from_pattern(rick.add(a, b))
      },
      {
        use #(left, right) <- trick.clause(trick.constructor_pattern(
          operation_constructor,
          {
            use _ <- trick.pattern(trick.string_pattern("-"))
            use left <- trick.labelled_pattern(
              "a",
              trick.variable_pattern("left"),
            )
            use right <- trick.labelled_pattern(
              "b",
              trick.variable_pattern("right"),
            )
            trick.return_from_pattern(#(left, right))
          },
        ))
        trick.subtract(left, right)
      },
      {
        use #(one, other) <- trick.clause(trick.constructor_pattern(
          operation_constructor,
          {
            use one <- trick.labelled_pattern(
              "b",
              trick.variable_pattern("one"),
            )
            use other <- trick.labelled_pattern(
              "a",
              trick.variable_pattern("other"),
            )
            use _ <- trick.labelled_pattern(
              "operator",
              trick.string_pattern("*"),
            )
            trick.return_from_pattern(#(one, other))
          },
        ))
        trick.multiply(one, other)
      },
      {
        use _ <- trick.clause(trick.constructor_pattern(
          operation_constructor,
          {
            use _ <- trick.pattern(trick.string_pattern("/"))
            use _ <- trick.labelled_pattern(
              "b",
              trick.int_pattern(0),
            )
            use <- trick.ignore_fields
            Nil
          },
        ))
        trick.int(0)
      },
      {
        use #(a, b) <- trick.clause(trick.constructor_pattern(
          operation_constructor,
          {
            use _ <- trick.pattern(trick.string_pattern("/"))
            use a <- trick.pattern(trick.variable_pattern("a"))
            use b <- trick.pattern(trick.variable_pattern("b"))
            trick.return_from_pattern(#(a, b))
          },
        ))
        trick.divide(a, b)
      },
      {
        use _ <- trick.clause(trick.discard_pattern())
        trick.int(0)
      }
    ])))
  })

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Operation {
  Operation(operator: String, a: Int, b: Int)
}

pub fn evaluate(operation: Operation) -> Int {
  case operation {
    Operation("+", a, b) -> a + b
    Operation("-", a: left, b: right) -> left - right
    Operation(b: one, a: other, operator: "*") -> one * other
    Operation("/", b: 0, ..) -> 0
    Operation("/", a, b) -> a / b
    _ -> 0
  }
}

Generates a single branch or “clause” of a case expression.

See the documentation for case_ for usae examples.

Generates a comment.

Examples

trick.block({
  use <- trick.comment("Pi to 2 decimal places")
  trick.expression(trick.float(3.14))
})
|> trick.expression_to_string

Will generate:

{
  // Pi to 2 decimal places
  3.14
}

Compiles a generated module, returning the string of generated code as well as the module interface, so it can be imported by other generated code.

If you don’t need to import it, use to_string instead.

Example

let assert Ok(#(maths_code, maths_module)) = {
  use _pi <- trick.constant("pi", trick.Public, trick.float(3.14))
  trick.end_module()
}
|> trick.compile("maths")

let assert Ok(main_module) = {
  use maths <- trick.import_(maths_module)
  use circle_area <- trick.function("circe_area", trick.Public, {
    use radius <- trick.parameter("radius", trick.float_type())
    radius
    |> trick.multiply_float(radius)
    |> trick.multiply_float(trick.imported_value(maths, "pi"))
    |> trick.expression
    |> trick.function_body
  })
  trick.end_module()
}

file.write("maths.gleam", maths_code)
file.write("main.gleam", main_module)

Produces:

// maths.gleam
pub const pi = 3.14

// main.gleam
import maths

pub fn circle_area(radius: Float) -> Float {
  radius *. radius *. maths.pi
}

Generates a <> operation.

Examples

trick.concatenate(trick.string("Hello"), trick.string("world"))
|> trick.expression_to_string
// -> Ok("\"Hello\" <> \"world\"")

Generates a top-level constant from a constant expression, passing the name of the constant to the continuing function allowing it to be used.

Examples

{
  use hello <- trick.constant("hello", trick.Private, trick.string("Hello,"))
  use world <- trick.constant("world", trick.Private, trick.string(" world!"))
  use hello_world <- trick.constant(
    "hello_world",
    trick.Public,
    trick.concatenate(hello, world),
  )
  trick.end_module()
}
|> trick.to_string

Will generate:

const hello = "Hello,"
const world = " world!"
pub const hello_world = hello <> world

Turns a constructor into an expression which references it.

Examples

{
  use wibble_type <- trick.custom_type("Wibble", trick.Public)
  use wibble <- trick.constructor("Wibble", [])
  use <- trick.end_custom_type

  use main <- trick.function(
    "main",
    trick.Public,
    wibble
    |> trick.construct
    |> trick.expression
    |> trick.function_body,
  )

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Wibble {
  Wibble
}

pub fn main() -> Wibble {
  Wibble
}

Generates a constructor for a custom types.

Examples

{
  use wibble_type <- trick.custom_type("Wibble", trick.Public)
  use wibble <- trick.constructor("Wibble", [
    trick.Field(None, trick.int_type()),
    trick.Field(None, trick.float_type()),
    trick.Field(Some("a_label"), trick.string_type()),
    trick.Field(Some("another_label"), trick.bool_type()),
  ])
  use <- trick.end_custom_type

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Wibble {
  Wibble(Int, Float, a_label: String, another_label: Bool)
}

Generates a pattern that matches on a specific constructor a custom type, along with the specified arguments. If you want to match a variant without any fields, use variant_pattern instead.

Examples

{
  use person_type <- trick.custom_type("Person", trick.Public)
  use person_constructor <- trick.constructor("Person", [
    trick.Field(Some("name"), trick.string_type()),
    trick.Field(Some("job"), trick.string_type()),
    trick.Field(Some("age"), trick.int_type()),
  ])
  use <- trick.end_custom_type

  use is_gleam_creator <- trick.function("is_gleam_creator", trick.Public, {
    use person <- trick.parameter("person", person_type)
    trick.function_body(trick.expression(trick.case_(person, [
      {
        use _ <- trick.clause(trick.constructor_pattern(person_constructor, {
          use _ <- trick.labelled_pattern(
            "name",
            trick.string_pattern("Louis"),
          )
          use _ <- trick.labelled_pattern(
            "job",
            trick.string_pattern("Programmer"),
          )
          use <- trick.ignore_fields
          Nil
        }))
        trick.bool(True)
      },
      {
        use _ <- trick.clause(trick.discard_pattern())
        trick.bool(False)
      },
    ])))
  })

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Person {
  Person(name: String, job: String, age: Int)
}

pub fn is_gleam_creator(person: Person) -> Bool {
  case person {
    Person(name: "Louis", job: "Programmer", ..) -> True
    _ -> False
  }
}

Begins a custom type declaration, passing the type to the continuing function so it can be used in constructors as a recursive definition, or in later functions and types.

Examples

{
  use list <- trick.custom_type("List", trick.Public)
  use a <- trick.type_parameter("a")
  use empty <- trick.constructor("Empty", [])
  use non_empty <- trick.constructor("NonEmpty", [
    trick.Field(Some("head"), a),
    trick.Field(Some("tail"), list),
  ])
  use <- trick.end_custom_type

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type List(a) {
  Empty
  NonEmpty(head: a, tail: List(a))
}

Defines public interface for the constructors of a custom type.

Examples

let assert Ok(option_module) = trick.define_module("gleam/option", {
  use option <- trick.define_custom_type("Option")
  use a <- trick.define_type_parameter("a")
  use <- trick.define_constructors([
    trick.DefinedConstructor("Some", [trick.Field(None, a)]),
    trick.DefinedConstructor("None", []),
  ])
  trick.define_values([])
})

Defines the public interface of a custom type, so that it can be imported from another module.

Examples

let assert Ok(option_module) = trick.define_module("gleam/option", {
  use option <- trick.define_custom_type("Option")
  use a <- trick.define_type_parameter("a")
  use <- trick.define_constructors([
    trick.DefinedConstructor("Some", [trick.Field(None, a)]),
    trick.DefinedConstructor("None", []),
  ])
  trick.define_values([])
})

Defines the minimum public interface of a module so it can be imported and used in generated code. If you need to generate code for this module, see compile.

Examples

let assert Ok(interface) = trick.define_module("wibble/wobble", {
  use wibble <- trick.define_custom_type("Wibble")
  use <- trick.define_constructors([trick.DefinedConstructor("Wibble", [
    trick.Field(Some("self"), wibble)
  ])])
  trick.define_values([trick.FunctionInterface("wobble", [wibble], wibble)])
})

Defines a type parameter for a custom type interface generated using define_custom_type. If you want a type parameter for a custom type being generated as code, see type_parameter.

Examples

let assert Ok(module) = trick.define_module("pair", {
  use pair <- trick.define_custom_type("pair")
  use left <- trick.define_type_parameter("left")
  use right <- trick.define_type_parameter("right")
  use <- trick.define_constructors([trick.DefinedConstructor("Pair", [
    trick.Field(None, left), trick.Field(None, right)
  ])])
  trick.define_values([trick.FunctionInterface("new", [left, right], pair)])
})

Defines the types of public values in a module so they can be imported and used in other modules. Only contains type information, not enough information to generate code.

Examples

let assert Ok(int_module) = trick.define_module(
  "gleam/int",
  trick.define_values([
    trick.ConstantInterface("zero", trick.int_type()),
    trick.FunctionInterface("add", trick.function_type([
      trick.int_type(), trick.int_type()
    ], trick.int_type())),
  ])),

Discards a terminating statement and allows continuation.

trick.block({
  use <- trick.discard(trick.expression(trick.int(1)))
  trick.expression(trick.int(2))
})
|> trick.expression_to_string

Will generate:

{
  1
  2
}

trick.block({
  use <- trick.discard(trick.assert(trick.bool(True), None))
  trick.assert(trick.bool(False), None)
})
|> trick.expression_to_string

Will generate:

{
  assert True
  assert False
}

Generates a pattern that matches anything and ignores its contents.

Examples

trick.case_(trick.int(1), [
  {
    use _ <- trick.clause(trick.discard_pattern())
    trick.nil()
  }
])
|> trick.expression_to_string

Will generate:

case 1 {
  _ -> Nil
}

Generates a / operation.

Examples

trick.divide(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 / 2")

Generates a /. operation.

Examples

trick.divide_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 /. 2.0")

Generates a doc comment in a module, which provides documentation for a particular type or value..

Examples

{
  use <- trick.doc_comment(
    "The ultimate answer to life, the universe, and everything."
  )
  use _ <- trick.constant("the_answer", trick.Public, trick.int(42))
  trick.end_module()
}

Will generate:

/// The ultimate answer to life, the universe, and everything.
pub const the_answer = 42

Generates an echo expression, with an optional message. If present, the message must be of type String.

Examples

trick.echo_(trick.int(42), None) |> trick.expression_to_string
// -> Ok("echo 42")

trick.echo_(trick.int(42), Some(trick.string("the answer")))
|> trick.expression_to_string
// -> Ok("echo 42 as \"the answer\"")

trick.echo_(trick.int(42), Some(trick.int(42)))
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: String, got: Int))

Marks the end of a custom type definition.

Examples

{
  use box_type <- trick.custom_type("Box", trick.Public)
  use value <- trick.type_parameter("value")
  use box <- trick.constructor("Box", [trick.Field(None, value)])
  use <- trick.end_custom_type
  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Box(value) {
  Box(value)
}

Marks the end of a module.

Examples

{
  use _ <- trick.constant("pi", trick.Public, trick.float(3.14))
  trick.end_module()
}
|> trick.to_string
// -> Ok("pub const pi = 3.14")

Generates a == operation. The two values must be of the same type.

Examples

trick.equal(trick.int(1), trick.int(1)) |> trick.expression_to_string
// -> Ok("1 == 1")

trick.equal(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 == 2.0")

trick.equal(trick.int(1), trick.float(2.0))
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

Turns an Expression into a Statement so it can be used in statement position.

By default, an expression statement ends the block and doesn’t allow being followed by another statement. Use discard to include a continuation.

Turns an Expression into a string of Gleam code.

Examples

trick.int(1) |> trick.add(trick.int(2)) |> trick.expression_to_string
// -> Ok("1 + 2")

trick.int(1) |> trick.add(trick.float(2.0)) |> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

Generates a field access expression.

Examples

{
  use person <- trick.custom_type("Person", trick.public)
  use child <- trick.constructor("Child", [
    trick.Field(Some("age"), trick.int_type()),
  ])
  use adult <- trick.constructor("Adult", [
    trick.Field(Some("age"), trick.int_type()),
    trick.Field(Some("job"), trick.string_type()),
  ])
  use <- trick.end_custom_type

  use age_after_birthday <- trick.function("age_after_birthday", trick.Public, {
    use person <- trick.parameter("person", person)
    person
    |> trick.field_access("age")
    |> trick.add(trick.int(1))
    |> trick.expression
    |> trick.function_body
  })

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Person {
  Child(age: Int)
  Adult(age: Int, job: String)
}

pub fn age_after_birthday(person: Person) -> Int {
  person.age + 1
}

Generates a Float.

Examples

trick.float(3.14) |> trick.expression_to_string
// -> Ok("3.14")

Generates a pattern which matches a specific float value.

Examples

trick.case_(trick.float(1.0), [
  {
    use _ <- trick.clause(trick.float_pattern(3.14))
    trick.float(3.14159265)
  },
  {
    use x <- trick.clause(trick.variable_pattern("x"))
    x
  },
])
|> trick.expression_to_string

Will generate:

case 1.0 {
  3.14 -> 3.14159265
  x -> x
}

Returns the Float type.

Generates a top-level function definition, passing the function name to the continuing function so it can be called later.

Examples

{
  use square <- trick.function("square", trick.Private, {
    use value <- trick.parameter("value", trick.float_type())
    trick.multiply_float(value, value)
    |> trick.expression
    |> trick.function_body
  })

  use circle_area <- trick.function("circle_area", trick.Public, {
    use radius <- trick.parameter("radius", trick.float_type())
    trick.call(square, [radius])
    |> trick.multiple_float(trick.float(3.14))
    |> trick.expression
    |> trick.function_body
  })

  use main <- trick.function("main", trick.Public, trick.function_body(
    trick.expression(
      trick.echo_(trick.call(circle_area, [trick.float(5.0)]), None)
    )
  ))
}
|> trick.to_string

Will generate:

fn square(value: Float) -> Float {
  value *. value
}

pub fn circle_area(radius: Float) -> Float {
  square(radius) *. 3.14
}

pub fn main() -> Float {
  echo circle_area(5.0)
}

Marks a statement as the body of a function, concluding the definition.

Examples

trick.nil()
|> trick.expression
|> trick.function_body
|> trick.anonymous
|> trick.expression_to_string
// -> Ok("fn() { Nil }")

Generates a function capture expression, receiving two lists of arguments. The function hole goes between the two lists.

See also: function_capture_alt for an alternative API.

Examples

{
  use add_5_numbers <- trick.function("add_5_numbers", trick.Private, {
    use a <- trick.parameter("a", int_type())
    use b <- trick.parameter("b", int_type())
    use c <- trick.parameter("c", int_type())
    use d <- trick.parameter("d", int_type())
    use e <- trick.parameter("e", int_type())
    a
    |> trick.add(b)
    |> trick.add(c)
    |> trick.add(d)
    |> trick.add(e)
    |> trick.expression
    |> trick.function_body
  })

  use main <- trick.function("main", trick.Public, trick.function_body(
    trick.expression(trick.function_capture(
      add_5_numbers,
      [trick.int(1), trick.int(2)],
      [trick.int(4), trick.int(5)],
    ))
  ))

  trick.end_module()
}

Will generate:

fn add_5_numbers(a: Int, b: Int, c: Int, d: Int, e: Int) -> Int {
  a + b + c + d + e
}

pub fn main() -> fn(Int) -> Int {
  add_5_numbers(1, 2, _, 4, 5)
}

An alternative experimental API to function_capture, structured more like a regular call.

The downside to this approach is that the type system doesn’t guarantee that there’s exactly one type hole, so we need to report errors for that too.

Examples

{
  use add_5_numbers <- trick.function("add_5_numbers", trick.Private, {
    use a <- trick.parameter("a", int_type())
    use b <- trick.parameter("b", int_type())
    use c <- trick.parameter("c", int_type())
    use d <- trick.parameter("d", int_type())
    use e <- trick.parameter("e", int_type())
    a
    |> trick.add(b)
    |> trick.add(c)
    |> trick.add(d)
    |> trick.add(e)
    |> trick.expression
    |> trick.function_body
  })

  use main <- trick.function("main", trick.Public, trick.function_body(
    trick.expression(trick.function_capture_alt(add_5_numbers, [
      CaptureArgument(trick.int(1)),
      CaptureArgument(trick.int(2)),
      CaptureHole,
      CaptureArgument(trick.int(4)),
      CaptureArgument(trick.int(5)),
    ]))
  ))

  trick.end_module()
}

Will generate:

fn add_5_numbers(a: Int, b: Int, c: Int, d: Int, e: Int) -> Int {
  a + b + c + d + e
}

pub fn main() -> fn(Int) -> Int {
  add_5_numbers(1, 2, _, 4, 5)
}

Returns a function type with the specified parameters and return type.

Returns a generic type with the given name.

Generates a > operation.

Examples

trick.greater_than(trick.int(1), trick.int(2))
|> trick.expression_to_string
// -> Ok("1 > 2")

Generates a >. operation.

Examples

trick.greater_than_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 >. 2.0")

Generates a >= operation.

Examples

trick.greater_than_or_equal(trick.int(1), trick.int(2))
|> trick.expression_to_string
// -> Ok("1 >= 2")

Generates a >=. operation.

Examples

trick.greater_than_or_equal_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 >=. 2.0")

Generates a pattern which ignores the remaining fields of a record. Since this pattern cannot bind any variables and must not be followed by other patterns, this function doesn’t acceptanother pattern from the callback, just the value to return from the entire pattern.

See the documentation for constructor_pattern for usage examples.

Import a particular module so it can be used.

Examples

let assert Ok(option_module) = trick.define_module("gleam/option", ...)

{
  use imported_option <- trick.import_(option_module)
  use _ <- trick.function(
    "main",
    trick.Public,
    trick.function_body({
      use option <- trick.variable(
        "option",
        trick.call(trick.imported_value(imported_option, "Some"), [
          trick.int(1),
        ]),
      )
      trick.expression(
        trick.call(trick.imported_value(imported_option, "unwrap"), [
          option,
          trick.int(1),
        ]),
      )
    }),
  )
  trick.end_module()
}
|> trick.to_string

Will produce:

import gleam/option

pub fn main() -> Int {
  let option = option.Some(1)
  option.unwrap(option, 1)
}

Imports a constructor from another module, for use in either an expression, or a pattern. For expressions, imported_value can be used also.

Examples

{
  use option <- trick.import_(option_module)
  let option_type = trick.imported_generic_type(option, "Option")
  let some = trick.imported_constructor(option, "Some")
  let none = trick.imported_constructor(option, "None")
  use unwrap <- trick.function("unwrap", trick.Public, {
    let a = trick.generic("a")
    use option <- trick.parameter(
      "option",
      trick.with_generics(option_type, [a]),
    )
    use fallback <- trick.parameter("fallback", a)
    trick.function_body(trick.expression(trick.case_(option, [
      {
        use value <- trick.clause(trick.constructor_pattern(some, {
          use value <- trick.pattern(trick.variable_pattern("value"))
          trick.return_from_pattern(value)
        })))
        value
      },
      {
        use _ <- trick.clause(trick.variant_pattern(none)
        fallback
      },
    ])))
  })
  trick.end_module()
}
|> trick.to_string

Will generate:

import gleam/option

pub fn unwrap(option: option.Option(a), fallback: a) -> a {
  case option {
    Some(value) -> value
    None -> fallback
  }
}

Retrieves a generic type from an imported module. For importing non-generic types, use imported_type.

Examples

{
  use option <- trick.import_(option_module)
  let option_type = trick.imported_generic_type(option, "Option")
  use _process_option <- trick.function("process_option", trick.Public, {
    use option <- trick.parameter(
      "option",
      trick.with_generics(option_type, trick.generic("a")),
    )
    trick.function_body(trick.expression(option))
  })
  trick.end_module()
}
|> trick.to_string

Will generate:

import gleam/option

pub fn process_option(option: option.Option(a)) -> option.Option(a) {
  option
}

Retrieves a type from an imported module.

If a generic type is imported using this function, an error will be returned. For generic types, use imported_generic_type.

Examples

{
  use person <- trick.import_(person_module)
  let person_type = trick.imported_type(person, "Person")
  use _process_person <- trick.function("process_person", trick.Public, {
    use person <- trick.parameter("person", person_type)
    trick.function_body(trick.expression(person))
  })
  trick.end_module()
}
|> trick.to_string

Will generate:

import person

pub fn process_person(person: person.Person) -> person.Person {
  person
}

Generates an expression representing a value which is imported from another module.

Examples

{
  use option <- trick.import_(option_module)
  let none = trick.imported_value(option, "None")
  use _none <- trick.constant("none", trick.Public, none)
  trick.end_module()
}
|> trick.to_string

Will generate:

import gleam/option

pub const none: option.Option(a) = option.None

Generates an Int.

Examples

trick.int(42) |> trick.expression_to_string
// -> Ok("42")

Generates an Int using hexadecimal syntax.

Examples

trick.int_base16(42) |> trick.expression_to_string
// -> Ok("0x2a")

Generates an Int using binary syntax.

Examples

trick.int_base2(42) |> trick.expression_to_string
// -> Ok("0b101010")

Generates an Int using octal syntax.

Examples

trick.int_base8(42) |> trick.expression_to_string
// -> Ok("0o52")

Generates a pattern which matches a specific integer value.

Examples

trick.case_(trick.int(1), [
  {
    use _ <- trick.clause(trick.int_pattern(1))
    trick.int(-1)
  },
  {
    use x <- trick.clause(trick.variable_pattern("x"))
    x
  },
])
|> trick.expression_to_string

Will generate:

case 1 {
  1 -> -1
  x -> x
}

Returns the Int type.

Generates a function call, allowing you to specify labelled arguments. For a call with no labelled arguments, it’s more convenient to simply use call.

Examples

{
  use function_with_labels <- trick.function(
    "function_with_labels",
    trick.Private,
    {
      use _ <- trick.parameter("unlabelled", trick.int_type())
      use _ <- trick.labelled_parameter("label", "name", trick.float_type())
      use _ <- trick.labelled_parameter(
        "other_label",
        "different_name",
        trick.bool_type(),
      )
      trick.todo_(None) |> trick.expression |> trick.function_body
    },
  )

  use main <- trick.function("main", trick.Public, trick.function_body(
    trick.expression(trick.labelled_call(function_with_labels, [
      trick.Argument(None, trick.int(42)),
      trick.Argument(Some("other_label"), trick.bool(False)),
      trick.Argument(Some("label"), trick.float(3.14)),
    ]))
  ))

  trick.end_module()
}
|> trick.to_string

Will generate:

fn function_with_labels(
  unlabelled: Int,
  label name: Float,
  other_label different_name: Bool,
) -> a {
  todo
}

pub fn main() -> a {
  function_with_labels(42, other_label: False, label: 3.14)
}

Adds a labelled parameter to a function definition.

Examples

trick.function("subtract", trick.Public, {
  use left <- trick.labelled_parameter("from", "left", trick.type_int())
  use right <- trick.labelled_parameter("subtract", "right", trick.type_int())
  trick.subtract(left, right) |> trick.expression |> trick.function_body
}, fn(_) { trick.end_module() })
|> trick.to_string

Will generate:

pub fn subtract(from left: Int, subtract right: Int) -> Int {
  left - right
}

Generates an argument of a constructor pattern which matches a specific pattern for a labelled parameter of the record.

See the documentation for constructor_pattern for usage examples.

Generates a < operation.

Examples

trick.less_than(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 < 2")

Generates a <. operation.

Examples

trick.less_than_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 <. 2.0")

Generates a <= operation.

Examples

trick.less_than_or_equal(trick.int(1), trick.int(2))
|> trick.expression_to_string
// -> Ok("1 <= 2")

Generates a <=. operation.

Examples

trick.less_than_or_equal_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 <=. 2.0")

Generates a let statement which matches the provided expression to the specified pattern. Returns an error if the pattern does not always match.

For binding a simple variable pattern, it’s easier to use variable.

Examples

trick.block({
  use #(a, b) <- trick.let_(
    trick.tuple_pattern({
      use a <- trick.pattern(trick.variable_pattern("a"))
      use b <- trick.pattern(trick.variable_pattern("b"))
      trick.return_from_pattern(#(a, b))
    }),
    trick.tuple([trick.int(1), trick.int(2)])
  )
  trick.expression(trick.add(a, b))
})
|> trick.expression_to_string

Will generate:

{
  let #(a, b) = #(1, 2)
  a + b
}

Generates a let assert statement which matches the provided expression to the specified pattern.

Examples

trick.block({
  use #(a, b) <- trick.let_assert(
    trick.list_pattern({
      use _ <- trick.pattern(trick.int_pattern(1))
      use a <- trick.pattern(trick.variable_pattern("a"))
      use _ <- trick.pattern(trick.int_pattern(3))
      use b <- trick.pattern(trick.variable_pattern("b"))
      trick.return_from_pattern(#(a, b))
    }),
    trick.list([trick.int(1), trick.int(2), trick.int(3), trick.int(4)]),
  )
  trick.expression(trick.add(a, b))
})
|> trick.expression_to_string

Will generate:

{
  let assert [1, a, 3, b] = [1, 2, 3, 4]
  a + b
}

Generates a list of values. The values must all be of the same type.

Examples

trick.list([trick.int(1), trick.int(2), trick.int(3)])
|> trick.expression_to_string
// -> Ok("[1, 2, 3]")

trick.list([trick.float(1.0), trick.float(2.0), trick.float(3.0)])
|> trick.expression_to_string
// -> Ok("[1.0, 2.0, 3.0]")

trick.list([trick.int(1), trick.float(2.0), trick.float(3.0)])
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

Generates a pattern that matches a list using the specified elements.

Since list patterns can potentially bind more than one variable, the API is different to that of most other patterns. Here, each element of the pattern is used, so that each variable can be obtained. At the end of the pattern, the relevant variables are returned so that they can be referenced in the clause body.

Examples

trick.case_(trick.list([trick.int(1), trick.int(2), trick.int(3)]), [
  {
    use #(x, rest) <- trick.clause(trick.in({
      use _ <- trick.pattern(trick.int_pattern(1))
      use x <- trick.pattern(trick.variable_pattern("x"))
      use rest <- trick.tail(trick.variable_pattern("rest"))
      #(x, rest)
    }))
    trick.tuple([x, rest])
  },
  {
    use _ <- trick.clause(trick.discard_pattern())
    trick.tuple([trick.int(0), trick.list([])])
  },
])
|> trick.expression_to_string

Will generate:

case [1, 2, 3] {
  [1, x, ..rest] -> #(x, rest)
  _ -> #(0, [])
}

Returns a List type with the specified element type.

Generates a top-level module comment to provide documentation for the entire module.

Examples

{
  use <- trick.module_comment(
    "This module contains constants relating to\n"
    <> "the Hitchhiker's Guide to the Galaxy.",
  )
  use _ <- trick.constant("the_answer", trick.Public, trick.int(42))
  trick.end_module()
}

Will generate:

//// This module contains constants relating to
//// the Hitchhiker's Guide to the Galaxy.

pub const the_answer = 42

Generates a * operation.

Examples

trick.multiply(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 * 2")

Generates a *. operation.

Examples

trick.multiply_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 *. 2.0")

Generates a unary ! operation.

Examples

trick.negate_bool(trick.bool(True))
|> trick.expression_to_string
// -> Ok("!True")

Generates a unary - operation.

Examples

trick.negate_int(trick.int(1))
|> trick.expression_to_string
// -> Ok("-1")

trick.negate_int(trick.float(1.0))
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

Generates Nil.

Examples

trick.nil() |> trick.expression_to_string
// -> Ok("Nil")

Returns the Nil type.

Generates a != operation. The two values must be of the same type.

Examples

trick.not_equal(trick.int(1), trick.int(1)) |> trick.expression_to_string
// -> Ok("1 != 1")

trick.not_equal(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 != 2.0")

trick.not_equal(trick.int(1), trick.float(2.0))
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

Generates a || operation.

Examples

trick.or(trick.bool(False), trick.bool(False))
|> trick.expression_to_string
// -> Ok("False || False")

Generates a panic expression, with an optional message. If present, the message must be of type String.

Examples

trick.panic_(None) |> trick.expression_to_string
// -> Ok("panic")

trick.panic_(Some(trick.string("uh oh"))) |> trick.expression_to_string
// -> Ok("panic as \"uh oh\"")

trick.panic_(Some(trick.int(42))) |> trick.expression_to_string
// -> Error(TypeMismatch(expected: String, got: Int))

Adds an unlabelled parameter to a function definition.

Examples

trick.anonymous({
  use parameter <- trick.parameter("parameter", trick.type_int())
  trick.todo_(None) |> trick.expression |> trick.function_body
})
|> trick.expression_to_string
// -> Ok("fn(parameter: Int) { todo }")

Generates a pattern as an element of a composite pattern.

Examples

trick.case_(trick.tuple([trick.int(1), trick.int(2), trick.int(3)]), [
  {
    use #(a, b) <- trick.clause(trick.tuple_pattern({
      use a <- trick.pattern(trick.variable_pattern("a"))
      use b <- trick.pattern(trick.variable_pattern("b"))
      use _ <- trick.pattern(trick.int(3))
      trick.return_from_pattern(#(a, b))
    }))
    trick.add(a, b)
  },
  {
    use _ <- trick.clause(trick.discard_pattern())
    trick.int(0)
  },
])

Will generate:

case #(1, 2, 3) {
  #(a, b, 3) -> a + b
  _ -> 0
}

Generates a list prepend expression, prepending one or more items.

Examples

trick.list([trick.int(2), trick.int(3)])
|> trick.prepend([trick.int(0), trick.int(1)])
|> trick.expression_to_string
// -> Ok("[0, 1, ..[2, 3]]")

trick.list([trick.int(2), trick.int(3)])
|> trick.prepend([trick.float(0.0), trick.float(1.0)])
|> trick.expression_to_string
// -> Error(TypeMismatch(expected: Int, got: Float))

trick.int(2)
|> trick.prepend([trick.int(0), trick.int(1)])
|> trick.expression_to_string
// -> InvalidListPrepend(type_: Int)

Creates a recursive function by passing in the function name to the body.

Once a function is declared as recursive, no more parameters can be added.

Examples

trick.function("infinity", trick.Private, {
  use parameter <- trick.parameter("parameter", trick.generic("a"))
  use infinity <- trick.recursive
  trick.call(infinity, parameter)
}, fn(_) { trick.end_module() })
|> trick.to_string

Will generate:

fn infinity(parameter: a) -> b {
  infinity(parameter)
}

Generates a % operation.

Examples

trick.remainder(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 % 2")

Returns a value from a pattern, usually containing a tuple of the variables which are bound by the pattern.

Examples

trick.case_(trick.tuple([trick.int(1), trick.int(2), trick.int(3)]), [
  {
    use #(a, b, c) <- trick.clause(trick.tuple_pattern({
      use a <- trick.variable_pattern("a")
      use b <- trick.variable_pattern("b")
      use c <- trick.variable_pattern("c")
      trick.return_from_pattern(#(a, b, c))
    }))
    a |> trick.add(b) |> trick.add(c)
  },
])

Generates a String.

Examples

trick.string("Hello, world!") |> trick.expression_to_string
// -> Ok("\"Hello, world!\"")

Generates a pattern that matches a specific string value. For extracting a prefix from a string, see string_prefix_pattern.

Examples

trick.case_(trick.string("Hello, world!"), [
  {
    use _ <- trick.clause(trick.string_pattern("Hello, world!"))
    trick.string("greeting")
  },
  {
    use _ <- trick.clause(trick.discard_pattern())
    trick.string("other")
  },
])
|> trick.expression_to_string

Will generate:

case "Hello, world!" {
  "Hello, world!" -> "greeting"
  _ -> "other"
}

Generates a pattern that matches a specific string prefix, and binds the remainder of the string to a variable.

Examples

trick.case_(trick.string("Hello Joe"), [
  {
    use name <- trick.clause(trick.string_prefix_pattern("Hello", "name"))
    name
  },
  {
    use _ <- trick.clause(trick.discard_variable())
    trick.string("unknown")
  },
])
|> trick.expression_to_string

Will generate:

case "Hello Joe" {
  "Hello" <> name -> name
  _ -> "unknown"
}

Returns the String type.

Generates a - operation.

Examples

trick.subtract(trick.int(1), trick.int(2)) |> trick.expression_to_string
// -> Ok("1 - 2")

Generates a -. operation.

Examples

trick.subtract_float(trick.float(1.0), trick.float(2.0))
|> trick.expression_to_string
// -> Ok("1.0 -. 2.0")

Generates a pattern which matches any remaining items in a list. Since list tails must come at the end of list patterns, this function doesn’t accept another pattern from the callback, just the value to return from the entire pattern.

Examples

trick.case_(trick.list([trick.int(1), trick.int(2)]), [
  {
    use tail <- trick.clause(trick.list_pattern({
      use _ <- trick.pattern(trick.discard_pattern())
      use tail <- trick.tail(trick.variable_pattern("tail"))
      tail
    }))
    tail
  },
  {
    use _ <- trick.clause(trick.discard_pattern())
    trick.list([])
  }
])

Will generate:

case [1, 2] {
  [_, ..tail] -> tail
  _ -> []
}

Turns a Module into a string of Gleam code. If you need to import the module from other generated code, use compile instead.

Examples

{
  use _pi <- trick.constant("pi", trick.Public, trick.float(3.14))
  trick.end_module()
}
|> trick.to_string
// -> Ok("pub const pi = 3.14")

Generates a todo expression, with an optional message. If present, the message must be of type String.

Examples

trick.todo_(None) |> trick.expression_to_string
// -> Ok("todo")

trick.todo_(Some(trick.string("uh oh"))) |> trick.expression_to_string
// -> Ok("todo as \"uh oh\"")

trick.todo_(Some(trick.int(42))) |> trick.expression_to_string
// -> Error(TypeMismatch(expected: String, got: Int))

Generates a tuple from the specified values. The values can be of different types.

Examples

trick.tuple([trick.int(1), trick.float(2.0), trick.string("three")])
|> trick.expression_to_string
// -> Ok("#(1, 2.0, \"three\")")

Generates a tuple access expression.

Examples

trick.tuple([trick.int(1), trick.float(2.0), trick.string("three")])
|> trick.tuple_index(2)
|> trick.expression_to_string
// -> Ok("#(1, 2.0, \"three\").2")

trick.tuple([trick.int(1), trick.float(2.0), trick.string("three")])
|> trick.tuple_index(4)
|> trick.expression_to_string
// -> Error(TupleIndexOutOfBounds(length: 3, index: 4))

trick.list([trick.int(1), trick.int(2)])
|> trick.tuple_index(0)
|> trick.expression_to_string
// -> Error(InvalidTupleAccess(type_: List(Int)))

Generates a pattern that matches a tuple using the specified elements.

Since tuple patterns can potentially bind more than one variable, the API is different to that of most other patterns. Here, each element of the pattern is used, so that each variable can be obtained. At the end of the pattern, the relevant variables are returned so that they can be referenced in the clause body.

Examples

trick.case_(trick.tuple([trick.int(1), trick.int(2)]), [
  {
    use x <- trick.clause(trick.tuple_pattern({
      use _ <- trick.pattern(trick.int_pattern(0))
      use x <- trick.pattern(trick.variable_pattern("x"))
      trick.return_from_pattern(x)
    }))
    x
  },
  {
    use #(a, b) <- trick.clause(trick.tuple_pattern({
      use a <- trick.pattern(trick.variable_pattern("b"))
      use b <- trick.pattern(trick.variable_pattern("b"))
      trick.return_from_pattern(#(a, b))
    }))
    trick.add(a, b)
  },
])
|> trick.expression_to_string

Will generate:

case #(1, 2) {
  #(0, x) -> x
  #(a, b) -> a + b
}

Returns a tuple type containing the specified elements.

Adds a type parameter to a custom type.

Examples

{
  use dict <- trick.custom_type("Dict", trick.Public)
  use key <- trick.type_parameter("key")
  use value <- trick.type_parameter("value")
  use <- trick.end_custom_type

  trick.end_module()
}
|> trick.to_string
// -> Ok("pub type Dict(key, value)")

{
  use box_type <- trick.custom_type("Box", trick.Public)
  use value <- trick.type_parameter("value")
  use box <- trick.constructor("Box", [trick.Field(None, value)])
  use <- trick.end_custom_type
  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Box(value) {
  Box(value)
}

Returns the UtfCodepoint type.

Declares a variable in the current scope. Calls the continuing function with an expression representing the variable name.

For matching more complex patterns, use let_

Examples

trick.block({
  use x <- trick.variable("x", trick.int(1))
  trick.expression(trick.add(x, trick.int(1)))
})
|> trick.expression_to_string

Will generate:

{
  let x = 1
  x + 1
}

Generates a pattern which matches any value and binds it to a variable.

If you want to match a specific value and bind it, see assignment_pattern.

Examples

trick.case_(trick.int(1), [
  {
    use a <- trick.clause(trick.variable_pattern("a"))
    trick.add(a, trick.int(1))
  }
])
|> trick.expression_to_string

Will generate:

case 1 {
  a -> a + 1
}

Generates a pattern that matches a specific variant of a custom type, without any parameters. For variants which have parameters, use constructor_pattern.

Examples

{
  use wibble_type <- trick.custom_type(trick.Public, "Wibble")
  use wibble <- trick.constructor("Wibble", [])
  use wobble <- trick.constructor("Wobble", [])
  use <- trick.end_custom_type

  use is_wibble <- trick.function(trick.Public, "is_wibble", {
    use value <- trick.parameter("value", wibble_type)
    trick.function_body(trick.expression(trick.case_(value, [
      {
        use _ <- trick.clause(trick.variant_pattern(wibble))
        trick.bool(True)
      },
      {
        use _ <- trick.clause(trick.variant_pattern(wobble))
        trick.bool(False)
      },
    ])))
  })

  trick.end_module()
}
|> trick.to_string

Will generate:

pub type Wibble {
  Wibble
  Wobble
}

pub fn is_wibble(value: Wibble) -> Bool {
  case value {
    Wibble -> True
    Wobble -> False
  }
}

Adds generics to a generic type constructor, turning it into a type which can be used in annotations.

Returns an error if the wrong number of parameters are supplied.

Examples

{
  use option <- trick.import_(option_module)
  let option_type = trick.imported_generic_type(option, "Option")
  use wibble <- trick.function("wibble", trick.Public, {
    use a <- trick.parameter(
      "a",
      trick.with_generics(option_type, [trick.int_type()]),
    )
    use b <- trick.parameter(
      "b",
      trick.with_generics(option_type, [trick.float_type()]),
    )
    trick.function_body(trick.expression(trick.tuple([a, b])))
  })
}
|> trick.to_string

Will generate:

import gleam/option

pub fn wibble(
  a: option.Option(Int),
  b: option.Option(Float),
) -> #(option.Option(Int), option.Option(Float)) {
 #(a, b) 
}