eyg/ir/tree

Types

Expression

pub type Expression(m) {
  Variable(label: String)
  Lambda(label: String, body: #(Expression(m), m))
  Apply(func: #(Expression(m), m), argument: #(Expression(m), m))
  Let(
    label: String,
    definition: #(Expression(m), m),
    body: #(Expression(m), m),
  )
  Binary(value: BitArray)
  Integer(value: Int)
  String(value: String)
  Tail
  Cons
  Vacant
  Empty
  Extend(label: String)
  Select(label: String)
  Overwrite(label: String)
  Tag(label: String)
  Case(label: String)
  NoCases
  Perform(label: String)
  Handle(label: String)
  Builtin(identifier: String)
  Reference(identifier: v1.Cid)
  Release(package: String, release: Int, identifier: v1.Cid)
}

Constructors

```
Variable(label: String)
```

Lambda(label: String, body: #(Expression(m), m))

Apply(func: #(Expression(m), m), argument: #(Expression(m), m))

Let(
  label: String,
  definition: #(Expression(m), m),
  body: #(Expression(m), m),
)

```
Binary(value: BitArray)
```
```
Integer(value: Int)
```
```
String(value: String)
```
```
Tail
```
```
Cons
```
```
Vacant
```
```
Empty
```
```
Extend(label: String)
```
```
Select(label: String)
```
```
Overwrite(label: String)
```
```
Tag(label: String)
```
```
Case(label: String)
```
```
NoCases
```
```
Perform(label: String)
```
```
Handle(label: String)
```
```
Builtin(identifier: String)
```
```
Reference(identifier: v1.Cid)
```

Release(package: String, release: Int, identifier: v1.Cid)

Node

</>

pub type Node(m) =
  #(Expression(m), m)

Values

add

</>

pub fn add(
  a: #(Expression(Nil), Nil),
  b: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

apply

</>

pub fn apply(
  func: #(Expression(m), m),
  argument: #(Expression(m), m),
) -> #(Expression(m), Nil)

binary

</>

pub fn binary(value: BitArray) -> #(Expression(m), Nil)

block

</>

pub fn block(
  assignments: List(#(String, #(Expression(Nil), Nil))),
  then: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

builtin

</>

pub fn builtin(identifier: String) -> #(Expression(m), Nil)

call

</>

pub fn call(
  f: #(Expression(Nil), Nil),
  args: List(#(Expression(Nil), Nil)),
) -> #(Expression(Nil), Nil)

case_

</>

pub fn case_(label: String) -> #(Expression(m), Nil)

clear_annotation

</>

pub fn clear_annotation(
  source: #(Expression(a), a),
) -> #(Expression(Nil), Nil)

cons

</>

pub fn cons() -> #(Expression(m), Nil)

do_gather_snippets

</>

pub fn do_gather_snippets(
  node: #(Expression(m), m),
  comments: List(String),
  assigns: List(#(String, #(Expression(m), m), m)),
  acc: List(
    #(List(String), List(#(String, #(Expression(m), m), m))),
  ),
) -> List(
  #(List(String), List(#(String, #(Expression(m), m), m))),
)

do_list

</>

pub fn do_list(
  reversed: List(#(Expression(Nil), Nil)),
  acc: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

do_record

</>

pub fn do_record(
  reversed: List(#(String, #(Expression(Nil), Nil))),
  acc: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

empty

</>

pub fn empty() -> #(Expression(m), Nil)

extend

</>

pub fn extend(label: String) -> #(Expression(m), Nil)

false

</>

pub fn false() -> #(Expression(Nil), Nil)

free_variables

</>

pub fn free_variables(exp: #(Expression(m), m)) -> List(String)

from_block

</>

pub fn from_block(
  assigns: List(#(String, #(Expression(m), m), m)),
  tail: #(Expression(m), m),
) -> #(Expression(m), m)

func

</>

pub fn func(
  params: List(String),
  body: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

gather_snippets

</>

pub fn gather_snippets(
  source: #(Expression(m), m),
) -> List(
  #(List(String), List(#(String, #(Expression(m), m), m))),
)

get

</>

pub fn get(
  value: #(Expression(Nil), Nil),
  label: String,
) -> #(Expression(Nil), Nil)

get_annotation

</>

pub fn get_annotation(in: #(Expression(m), m)) -> List(m)

handle

</>

pub fn handle(label: String) -> #(Expression(m), Nil)

integer

</>

pub fn integer(value: Int) -> #(Expression(m), Nil)

lambda

</>

pub fn lambda(
  label: String,
  body: #(Expression(m), m),
) -> #(Expression(m), Nil)

let_

</>

pub fn let_(
  label: String,
  value: #(Expression(m), m),
  then: #(Expression(m), m),
) -> #(Expression(m), Nil)

list

</>

pub fn list(
  items: List(#(Expression(Nil), Nil)),
) -> #(Expression(Nil), Nil)

list_builtins

</>

pub fn list_builtins(exp: #(Expression(m), m)) -> List(String)

list_named_references

</>

pub fn list_named_references(
  exp: #(Expression(m), m),
) -> List(#(String, Int, v1.Cid))

list_references

</>

pub fn list_references(exp: #(Expression(m), m)) -> List(v1.Cid)

map_annotation

</>

pub fn map_annotation(
  in: #(Expression(a), a),
  f: fn(a) -> b,
) -> #(Expression(b), b)

map_release

</>

pub fn map_release(
  exp: #(Expression(m), m),
  mapper: fn(String, Int, v1.Cid) -> #(String, Int, v1.Cid),
) -> #(Expression(m), m)

match

</>

pub fn match(
  value: #(Expression(Nil), Nil),
  matches: List(#(String, #(Expression(Nil), Nil))),
) -> #(Expression(Nil), Nil)

multiply

</>

pub fn multiply(
  a: #(Expression(Nil), Nil),
  b: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

nocases

</>

pub fn nocases() -> #(Expression(m), Nil)

overwrite

</>

pub fn overwrite(label: String) -> #(Expression(m), Nil)

perform

</>

pub fn perform(label: String) -> #(Expression(m), Nil)

record

</>

pub fn record(
  fields: List(#(String, #(Expression(Nil), Nil))),
) -> #(Expression(Nil), Nil)

reference

</>

pub fn reference(identifier: v1.Cid) -> #(Expression(m), Nil)

release

</>

pub fn release(
  package: String,
  release: Int,
  identifier: v1.Cid,
) -> #(Expression(m), Nil)

select

</>

pub fn select(label: String) -> #(Expression(m), Nil)

string

</>

pub fn string(value: String) -> #(Expression(m), Nil)

subtract

</>

pub fn subtract(
  a: #(Expression(Nil), Nil),
  b: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

tag

</>

pub fn tag(label: String) -> #(Expression(m), Nil)

tagged

</>

pub fn tagged(
  label: String,
  inner: #(Expression(Nil), Nil),
) -> #(Expression(Nil), Nil)

tail

</>

pub fn tail() -> #(Expression(m), Nil)

true

</>

pub fn true() -> #(Expression(Nil), Nil)

unit

</>

pub fn unit() -> #(Expression(m), Nil)

vacant

</>

pub fn vacant() -> #(Expression(m), Nil)

variable

</>

pub fn variable(label: String) -> #(Expression(m), Nil)