3.2.1Function Application

Function application is written in prefix style: add 1 2

Functions have fixed arity, so applications can be parsed unambiguously without grouping syntax. For example, add 1 mul 2 3 parses as add(1, mul(2, 3)) because the parser knows add takes 2 arguments and mul takes 2 arguments.

Parentheses are used to defer application: map (double) [1 2 3]

3.2.2Lists

[1 2 3]

3.2.3Records

Records may use shorthand syntax for fields where the value is a reference to a variable of the same name.

let foo = 10..
{foo}         | equivalent to {foo: 10}

This provides a concise way to construct records using in-scope variable names as field keys and values.

You can also mix shorthand and explicit fields:

let x = 1..
let y = 2..
{x y z: 3}    | equivalent to {x: 1, y: 2, z: 3}

{ name: "Alice", age: 30 }

3.2.4Tags

A tag value is an arity-0 symbolic value used to represent symbolic variants in pattern matching or other symbolic forms.

Tag values are only defined by using record shorthand syntax. For example:

{red blue green}   | defines the tag values red, blue, and green

Tag values:

• Must be introduced via record shorthand notation
• Are resolved as symbolic constants with identity semantics
• Match directly in case expressions:

let color = get "red" {red blue green}
case color of
  red: "warm"
  blue: "cool"
  _: "other"
end

3.2.5Lambdas

<x: add x 1>

Multiple parameters: <x y: add x y>

3.2.6Let Bindings

let double = <x: mul 2 x>..

4.4.1Tag Identity and Type

Tag values are symbolic constants identified solely by their name. The same tag name (e.g., A) refers to the same symbolic value, regardless of where it is defined.

Tag values compare equal by name. For example, A in {A B} and A in {A C} are equal.

4.4.2Tag Sets as Structural Types

Although tag values are globally identified by name, the type system tracks which tags are expected to co-occur.

For example, {A B} and {A C} are different types:

{A B}    | type: { A: tag, B: tag }
{A C}    | type: { A: tag, C: tag }

This allows the type system to constrain the expected context for pattern matching, record shapes, or enum-style uses of tags.

Using tags not part of the expected set results in a type error.

4.4.3Default Type: `tag`

By default, a tag value has the type:

tag

When tags are introduced with:

{A B C}

the resulting type is:

{ A: tag, B: tag, C: tag }

This allows for composition and safe comparison.

4.4.4Example

let colors = {red blue green}..
case red of
  red: "warm"
  blue: "cool"
  _: "other"
end

In this case, red, blue, and green are all of type tag, and case matches by identity.

6.2.1add

Add two numbers.

add 2 3  | returns 5

6.2.2and

Logical AND operation

and false false  | returns false
and false true   | returns false
and true false   | returns false
and true true    | returns true

6.2.3apply

Apply a function to an argument list

apply add [1 2]  | returns 3

6.2.4div

Divide the first number by the second

div 10 2  | returns 5

6.2.5equiv

Tests if two values are strictly equivalent

equiv 1 1        | returns true
equiv "a" "a"    | returns true
equiv true true  | returns true
equiv 1 2        | returns false
equiv "a" "b"    | returns false

6.2.6filter

Filter elements matching predicate

filter (<x: mod x 2>) [1 2 3 4]  | returns [1 3]

6.2.7get

Retrieve a record field

get "b" {a: 1, b: 2}  | returns 2

6.2.8hd

Return the first item

hd [10 20 30]  | returns 10

6.2.9isEmpty

Return true if list is empty, otherwise return false

isEmpty []  | returns true

6.2.10log

Log a value to the console and return the value unchanged

log "Hello"  | prints "Hello" to console and returns "Hello"
log (add 1 2)  | prints 3 to console and returns 3

6.2.11map

Apply a function to each element

map (<x: add x 1>) [1 2 3]  | returns [2 3 4]

6.2.12max

Return the larger of two numbers

max 5 10  | returns 10

6.2.13min

Return the smaller of two numbers

min 5 10  | returns 5

6.2.14mod

Compute the remainder

mod 10 3  | returns 1

6.2.15mul

Multiply two numbers

mul 4 3  | returns 12

6.2.16not

Logical NOT that inverts a boolean value

not true   | returns false
not false  | returns true

6.2.17nth

Get the nth item (0-based)

nth 1 [10 20 30]  | returns 20

6.2.18or

Logical OR operation

or false false  | returns false
or false true   | returns true
or true false   | returns true
or true true    | returns true

6.2.19range

Produce a range list from start to end (exclusive) with step

range 1 10 2  | returns [1 3 5 7 9]

6.2.20reduce

Reduce a list to a single value, starting with an initial value

reduce (<a b: add a b>) 0 [1 2 3 4]  | returns 10

6.2.21set

Return a new record with an updated field

set "a" 2 {a: 1}  | returns {a: 2}

6.2.22sub

Subtract the second number from the first

sub 5 2  | returns 3

6.2.23tl

Return all but the first item

tl [10 20 30]  | returns [20 30]