gen_gleam/statements

For generating Gleam statements

Types

Argument

pub opaque type Argument

Clause

pub opaque type Clause

ComparisonOperator

pub type ComparisonOperator {
  Lt
  Lte
  Eq
  Neq
  Gt
  Gte
}

Constructors

```
Lt
```
```
Lte
```
```
Eq
```
```
Neq
```
```
Gt
```
```
Gte
```

GleamStatement

Might become opaque. Do use the functions to generate the constructors/variants.

pub type GleamStatement {
  NilVal
  IntVal(value: Int)
  ListVal(items: List(GleamStatement))
  StringVal(string: String)
  TupleVal(items: List(GleamStatement))
  VariantVal(name: String, fields: List(GleamStatement))
  VarPrimitive(name: String)
  Comparison(GleamStatement, ComparisonOperator, GleamStatement)
  CaseStatement(
    guards: List(GleamStatement),
    clauses: List(Clause),
  )
  Function(
    name: String,
    arguments: List(Argument),
    statements: List(GleamStatement),
  )
  FunctionCall(name: String, arguments: List(GleamStatement))
  UseArg(arg: GleamStatement)
  LetVar(pattern: Pattern, statement: GleamStatement)
  LetArray(patterns: List(Pattern), array: GleamStatement)
  LetTuple(patterns: List(Pattern), tuple: GleamStatement)
  Multiply(terms: List(GleamStatement))
  Direct(string: String)
}

Constructors

```
NilVal
```
```
IntVal(value: Int)
```
```
ListVal(items: List(GleamStatement))
```
```
StringVal(string: String)
```
```
TupleVal(items: List(GleamStatement))
```

VariantVal(name: String, fields: List(GleamStatement))

```
VarPrimitive(name: String)
```

Comparison(GleamStatement, ComparisonOperator, GleamStatement)

CaseStatement(
  guards: List(GleamStatement),
  clauses: List(Clause),
)

Function(
  name: String,
  arguments: List(Argument),
  statements: List(GleamStatement),
)

FunctionCall(name: String, arguments: List(GleamStatement))

```
UseArg(arg: GleamStatement)
```

LetVar(pattern: Pattern, statement: GleamStatement)

LetArray(patterns: List(Pattern), array: GleamStatement)

LetTuple(patterns: List(Pattern), tuple: GleamStatement)

```
Multiply(terms: List(GleamStatement))
```
```
Direct(string: String)
```

Pattern

pub opaque type Pattern

Functions

arg_typed

pub fn arg_typed(name: String, arg_type: GleamType) -> Argument

arg_untyped

pub fn arg_untyped(name: String) -> Argument

call

pub fn call(
  name: String,
  arguments: List(GleamStatement),
) -> GleamStatement

case_stmt

pub fn case_stmt(
  guards: List(GleamStatement),
  clauses: List(Clause),
) -> GleamStatement

clause

pub fn clause(
  patterns: List(Pattern),
  stmt: GleamStatement,
) -> Clause

compare

pub fn compare(
  stmt1: GleamStatement,
  comp_op: ComparisonOperator,
  stmt2: GleamStatement,
) -> GleamStatement

direct

pub fn direct(string: String) -> GleamStatement

@deprecated

function

pub fn function(
  name: String,
  arguments: List(Argument),
  statements: List(GleamStatement),
) -> GleamStatement

generate

pub fn generate(stmt: GleamStatement) -> String

int

pub fn int(value: Int) -> GleamStatement

let_array

pub fn let_array(
  patterns: List(Pattern),
  array: GleamStatement,
) -> GleamStatement

TODO: Needs middle argument Option(Pattern) for ..tail

let_tuple

pub fn let_tuple(
  patterns: List(Pattern),
  tuple: GleamStatement,
) -> GleamStatement

let_var

pub fn let_var(
  pattern: Pattern,
  statement: GleamStatement,
) -> GleamStatement

list

pub fn list(values: List(GleamStatement)) -> GleamStatement

literal

pub fn literal(lit: String) -> Pattern

a constant pattern, such as True or 42 (represented as a string, for now) TODO make actual patterns for these constants

multiply

pub fn multiply(terms: List(GleamStatement)) -> GleamStatement

name_of_var

pub fn name_of_var(var: GleamStatement) -> String

nil

pub fn nil() -> GleamStatement

underscore

pub fn underscore() -> Pattern

unused_var

pub fn unused_var(name: String) -> Pattern

name: variable name without the underscore, it will be prepended when generating code

use_arg

pub fn use_arg(arg: Argument) -> GleamStatement

var_pattern

pub fn var_pattern(var: String) -> Pattern

variable

pub fn variable(name: String) -> GleamStatement

variant

pub fn variant(
  name: String,
  field_values: List(GleamStatement),
) -> GleamStatement