gen_core_erlang

Types

Clause

pub type Clause

Definition

</>

pub type Definition =
  #(FunctionDecl, Function)

Expression

</>

Type that wraps the various c_erl() subtypes into an expression. These expressions are used as function bodies, in case clauses after ->.

pub opaque type Expression

Function

</>

pub opaque type Function

FunctionDecl

</>

Type that wraps name and arity, such as loop/1.

pub type FunctionDecl

ModuleAttribute

</>

pub type ModuleAttribute

ModuleDef

</>

Outermost Core Erlang term that can be passed to compile:forms(mod, [from_core]).

pub type ModuleDef

Pattern

</>

Type that wraps the various c_erl() subtypes into a pattern. These patterns are used as function arguments, in case clauses before ->,

pub opaque type Pattern

Functions

c_apply

</>

pub fn c_apply(
  f_def: FunctionDecl,
  arguments: List(Expression),
) -> Expression

c_apply_anonymous

</>

pub fn c_apply_anonymous(
  function: Expression,
  arguments: List(Expression),
) -> Expression

Call a function, but not by name. Most likely, the function has been assigned to a variable

c_let([p_var("Fun")], f2e(c_fun(...)), c_call_anonymous(c_var("Fun", [])))

c_atom

</>

pub fn c_atom(name: String) -> Expression

Create an expression for the atom that has string representation name

c_binary

</>

pub fn c_binary(string: String) -> Expression

Create an Erlang binary for a Gleam string. Currently, there is no way to generate other binaries

c_case

</>

pub fn c_case(
  expr: Expression,
  clauses: List(Clause),
) -> Expression

c_clause

</>

pub fn c_clause(
  patterns: List(Pattern),
  expr: Expression,
) -> Clause

A single clause for a c_case. Although you can pass a list of patterns, it seems expr always returns one value

c_clause_w_guard

</>

pub fn c_clause_w_guard(
  patterns: List(Pattern),
  guard: Expression,
  expr: Expression,
) -> Clause

Although we use the type Expression, you should only pass those allowed in guards. Maybe some day we can enforce this with a type, but that seems very hard

c_cons

</>

pub fn c_cons(head: Expression, tail: Expression) -> Expression

Concatenate two expressions. As per Erlang, the tail argument does not have to be a list. If you want to generate an empty list, use c_nil, if you want to generate a list from 1 or more items, use make_list

c_float

</>

pub fn c_float(value: Float) -> Expression

c_fname

</>

pub fn c_fname(name: String, arity: Int) -> FunctionDecl

Create a function ‘name’ such as “loop/1”. To be used in module definitions (both exports and functions) as well as local function application

c_fun

</>

pub fn c_fun(
  arguments: List(Pattern),
  body: Expression,
) -> Function

If you need this as an Expression, use f2e

c_int

</>

pub fn c_int(value: Int) -> Expression

c_let

</>

pub fn c_let(
  variables: List(Pattern),
  argument: Expression,
  body: Expression,
) -> Expression

Equivalent to

<P1, ..., Pn> = argument
body

where you can use a pattern line p_int("Num") by its variable `c_int(“Num”)

Note that all Pi need to be p_var patterns. If you need other matches, use c_case with a single c_clause

c_module

</>

pub fn c_module(
  name: String,
  exports: List(FunctionDecl),
  attributes: List(ModuleAttribute),
  definitions: List(#(FunctionDecl, Function)),
) -> ModuleDef

There should be a definition for each export. Other definitions are local functions. Note: For attributes, you currnely have to pass an empty list.

c_nil

</>

pub fn c_nil() -> Expression

Erlang’s empty list.

c_receive

</>

pub fn c_receive(clauses: List(Clause)) -> Expression

c_seq

</>

pub fn c_seq(arg: Expression, body: Expression) -> Expression

Execute two expression consecutively. Erlang functions always return a result. If you need that result, use c_let. If you want to execute more than 2 expressions, use:

let assert Ok(expr) = list.reduce(expressions, c_seq)

c_tuple

</>

pub fn c_tuple(values: List(Expression)) -> Expression

c_var

</>

pub fn c_var(name: String) -> Expression

f2e

</>

pub fn f2e(f: Function) -> Expression

list_elements

</>

pub fn list_elements(list: Expression) -> List(Expression)

Unspecified behaviour. Used for testing this library.

make_list

</>

pub fn make_list(expressions: List(Expression)) -> Expression

Convenience function, equivalent to

c_cons(expr_1, .... c_cons(expr_n, c_nil()))

p_atom

</>

pub fn p_atom(name: String) -> Pattern

Create a pattern for the atom that has string representation name

p_cons

</>

pub fn p_cons(head: Pattern, tail: Pattern) -> Pattern

p_float

</>

pub fn p_float(value: Float) -> Pattern

p_int

</>

pub fn p_int(value: Int) -> Pattern

p_nil

</>

pub fn p_nil() -> Pattern

p_tuple

</>

pub fn p_tuple(values: List(Pattern)) -> Pattern

p_var

</>

pub fn p_var(name: String) -> Pattern