Expression Standard Library

Dieser Inhalt ist noch nicht in deiner Sprache verfügbar.

mashinTalk’s expression language ships with built-in namespaces, value methods, and global functions. These are language built-ins compiled directly to BEAM code, not mashinTalk machines. They are available in any expression context: compute steps, decide conditions, field defaults, and string interpolation.

Namespaces

Namespaces are called as Namespace.function(args). Available namespaces:

Math DateTime JSON Object Set UUID Intl Result Option String form

Math

Mathematical functions and constants.

Function	Signature	Description
`Math.abs(x)`	`number -> number`	Absolute value
`Math.ceil(x)`	`number -> integer`	Round up to nearest integer
`Math.floor(x)`	`number -> integer`	Round down to nearest integer
`Math.round(x)`	`number -> integer`	Round to nearest integer
`Math.round(x, precision)`	`number, integer -> float`	Round to given decimal places
`Math.max(a, b)`	`number, number -> number`	Larger of two values
`Math.min(a, b)`	`number, number -> number`	Smaller of two values
`Math.pow(base, exp)`	`number, number -> float`	Base raised to exponent
`Math.sqrt(x)`	`number -> float`	Square root
`Math.log(x)`	`number -> float`	Natural logarithm
`Math.log2(x)`	`number -> float`	Base-2 logarithm
`Math.log10(x)`	`number -> float`	Base-10 logarithm
`Math.exp(x)`	`number -> float`	e raised to the power x
`Math.sin(x)`	`number -> float`	Sine (radians)
`Math.cos(x)`	`number -> float`	Cosine (radians)
`Math.tan(x)`	`number -> float`	Tangent (radians)
`Math.asin(x)`	`number -> float`	Arcsine
`Math.acos(x)`	`number -> float`	Arccosine
`Math.atan(x)`	`number -> float`	Arctangent
`Math.atan2(y, x)`	`number, number -> float`	Two-argument arctangent
`Math.trunc(x)`	`number -> integer`	Truncate decimal part toward zero
`Math.sign(x)`	`number -> -1 \| 0 \| 1`	Sign of the number
`Math.random()`	`-> float`	Random float in `[0.0, 1.0)`

Constants:

Constant	Value	Description
`Math.PI`	`3.14159...`	Pi
`Math.E`	`2.71828...`	Euler’s number

compute circle_area
  let r = input.radius
  Math.PI * Math.pow(r, 2)

DateTime

Date and time operations. All functions work with ISO 8601 strings and DateTime values.

Function	Signature	Description
`DateTime.now()`	`-> string`	Current UTC datetime as ISO 8601
`DateTime.today()`	`-> string`	Current UTC date as `YYYY-MM-DD`
`DateTime.parse(iso_string)`	`string -> DateTime`	Parse an ISO 8601 string
`DateTime.diff(a, b)`	`DateTime, DateTime -> integer`	Seconds between a and b
`DateTime.add(dt, amount)`	`DateTime, integer -> DateTime`	Add seconds to a datetime
`DateTime.add(dt, amount, unit)`	`DateTime, integer, string -> DateTime`	Add with unit: `"seconds"`, `"minutes"`, `"hours"`, `"days"`
`DateTime.isBefore(a, b)`	`DateTime, DateTime -> boolean`	True if a is before b
`DateTime.isAfter(a, b)`	`DateTime, DateTime -> boolean`	True if a is after b
`DateTime.isBetween(dt, from, to)`	`DateTime, DateTime, DateTime -> boolean`	True if dt is between from and to
`DateTime.format(dt, style)`	`DateTime, string -> string`	Format a datetime as a string
`DateTime.toUnix(dt)`	`DateTime -> integer`	Convert to Unix timestamp (seconds)
`DateTime.fromUnix(timestamp)`	`integer -> DateTime`	Convert from Unix timestamp
`DateTime.startOfDay(dt)`	`DateTime -> DateTime`	Midnight at the start of the day
`DateTime.dayOfWeek(dt)`	`DateTime -> integer`	Day of week: 1 (Monday) to 7 (Sunday)
`DateTime.relative(dt)`	`DateTime -> string`	Human-readable relative time (e.g. “3 hours ago”)

compute time_check
  let now = DateTime.now()
  let deadline = DateTime.parse(input.due_at)
  let overdue = DateTime.isAfter(now, deadline)
  {overdue: overdue, seconds_remaining: DateTime.diff(deadline, now)}

JSON

Function	Signature	Description
`JSON.parse(json_string)`	`string -> any`	Parse a JSON string into a value
`JSON.stringify(value)`	`any -> string`	Serialize a value to a JSON string
`JSON.stringify(value, indent)`	`any, integer -> string`	Pretty-print with given indent level

Object

Operations on objects (maps / key-value pairs).

Function	Signature	Description
`Object.keys(obj)`	`object -> array<string>`	List all keys
`Object.values(obj)`	`object -> array<any>`	List all values
`Object.entries(obj)`	`object -> array<[string, any]>`	List all `[key, value]` pairs
`Object.fromEntries(entries)`	`array<[string, any]> -> object`	Build an object from entries
`Object.merge(target, source)`	`object, object -> object`	Merge source into target (source wins on conflict)
`Object.assign(target, source)`	`object, object -> object`	Alias for `merge`
`Object.hasKey(obj, key)`	`object, string -> boolean`	True if key exists
`Object.get(obj, key)`	`object, string -> any \| nil`	Get value or nil if absent
`Object.get(obj, key, default)`	`object, string, any -> any`	Get value or default if absent
`Object.delete(obj, key)`	`object, string -> object`	Remove a key, return new object

compute normalize
  let keys = Object.keys(input.data)
  let entries = Object.entries(input.data)
  let cleaned = Object.fromEntries(entries.filter(([k, v]) => v != null))
  cleaned

Set

Operations on sets (unordered collections with no duplicates).

Function	Signature	Description
`Set.from(list)`	`array -> Set`	Create a set from a list
`Set.has(set, value)`	`Set, any -> boolean`	True if value is in the set
`Set.add(set, value)`	`Set, any -> Set`	Add a value, return new set
`Set.delete(set, value)`	`Set, any -> Set`	Remove a value, return new set
`Set.union(a, b)`	`Set, Set -> Set`	All elements in either set
`Set.intersection(a, b)`	`Set, Set -> Set`	Elements in both sets
`Set.difference(a, b)`	`Set, Set -> Set`	Elements in a but not b
`Set.size(set)`	`Set -> integer`	Number of elements
`Set.toList(set)`	`Set -> array`	Convert to a list

UUID

Function	Signature	Description
`UUID.generate()`	`-> string`	Generate a random UUID v4
`UUID.v4()`	`-> string`	Alias for `UUID.generate()`

Intl

Locale-aware formatting. Uses the machine’s locale when set via written in.

Function	Signature	Description
`Intl.formatNumber(num)`	`number -> string`	Format a number for display
`Intl.formatNumber(num, opts)`	`number, object -> string`	Format with options: `opts.decimals` (integer) for decimal places, `opts.style: "percent"` to multiply by 100 and append %
`Intl.formatDate(dt)`	`string -> string`	Format a date/datetime string
`Intl.formatDate(dt, opts)`	`string, object -> string`	Format with style: `"iso"`, `"date"`, `"time"`, or `"short"` (default)

Result

Explicit error handling without exceptions. Use Result to represent operations that may succeed or fail.

Function	Signature	Description
`Result.ok(value)`	`any -> Result`	Wrap a success value
`Result.error(reason)`	`any -> Result`	Wrap a failure reason
`Result.is_ok(r)`	`Result -> boolean`	True if the result is ok
`Result.is_error(r)`	`Result -> boolean`	True if the result is an error
`Result.map(r, fn)`	`Result, (any) -> any -> Result`	Transform the ok value
`Result.and_then(r, fn)`	`Result, (any) -> Result -> Result`	Chain operations that may fail
`Result.unwrap_or(r, default)`	`Result, any -> any`	Extract value or use default on error
`Result.unwrap!(r)`	`Result -> any`	Extract value, raise if error
`Result.try_fn(fn)`	`(() -> any) -> Result`	Wrap a function call, catching errors as `Result.error`

compute safe_parse
  let parsed = Result.try_fn(() => JSON.parse(input.payload))
  let data = Result.unwrap_or(parsed, {items: []})
  {items: data.items}

Option

Explicit null handling. Use Option to represent values that may or may not be present.

Function	Signature	Description
`Option.some(value)`	`any -> Option`	Wrap a present value
`Option.none()`	`-> Option`	Represent absence
`Option.is_some(o)`	`Option -> boolean`	True if value is present
`Option.is_none(o)`	`Option -> boolean`	True if value is absent
`Option.map(o, fn)`	`Option, (any) -> any -> Option`	Transform the inner value if present
`Option.and_then(o, fn)`	`Option, (any) -> Option -> Option`	Chain operations on optional values
`Option.unwrap_or(o, default)`	`Option, any -> any`	Extract value or use default if absent
`Option.from_nullable(value)`	`any \| nil -> Option`	Convert a nullable value to an Option

String (namespace)

String utility functions callable as String.function(args). See also String value methods for dot-syntax equivalents.

Function	Signature	Description
`String.join(list, separator)`	`array, string -> string`	Join a list into a string
`String.to_string(value)`	`any -> string`	Coerce any value to a string
`String.split(str, delimiter)`	`string, string -> array<string>`	Split a string into a list
`String.trim(str)`	`string -> string`	Remove leading and trailing whitespace
`String.replace(str, pattern, replacement)`	`string, string, string -> string`	Replace first occurrence
`String.length(str)`	`string -> integer`	Character count
`String.uppercase(str)`	`string -> string`	Convert to uppercase
`String.lowercase(str)`	`string -> string`	Convert to lowercase

form (Governed Metaprogramming)

The form namespace provides access to machine forms: the AST representation of a mashinTalk machine. Use form functions inside compute steps to inspect, transform, and serialize machine structure. form.eval, form.propose, and form.describe require an ask step because they perform governed effects.

Introspection

Function	Signature	Description
`form.kind(f)`	`Form -> string`	Node type (e.g. `"machine"`, `"step"`, `"section"`)
`form.name(f)`	`Form -> string`	Node name
`form.children(f)`	`Form -> array<Form>`	Direct children
`form.fields(f)`	`Form -> object`	Field map for the node
`form.section(f, name)`	`Form, string -> Form`	Find a section by name
`form.step(f, name)`	`Form, string -> Form`	Find a step by name
`form.steps(f)`	`Form -> array<Form>`	All steps in the form
`form.inputs(f)`	`Form -> array<Form>`	Input field forms
`form.outputs(f)`	`Form -> array<Form>`	Output field forms
`form.get(f, path)`	`Form, string -> any`	Get a field value by path

Mutation

All mutation functions return a new Form; the original is unchanged.

Function	Signature	Description
`form.set(f, path, value)`	`Form, string, any -> Form`	Set a field at path
`form.add(f, child)`	`Form, Form -> Form`	Append a child node
`form.add(f, position, child)`	`Form, integer, Form -> Form`	Insert a child at position
`form.remove(f, name)`	`Form, string -> Form`	Remove a child by name
`form.replace(f, name, new_form)`	`Form, string, Form -> Form`	Replace a child by name
`form.merge(f1, f2)`	`Form, Form -> Form`	Merge two forms
`form.diff(f1, f2)`	`Form, Form -> object`	Diff between two forms
`form.insert_before(f, ref, child)`	`Form, string, Form -> Form`	Insert before a named sibling
`form.insert_after(f, ref, child)`	`Form, string, Form -> Form`	Insert after a named sibling
`form.wrap(f, wrapper_kind)`	`Form, string -> Form`	Wrap a form in a new node of the given kind
`form.dissoc(f, key)`	`Form, string -> Form`	Remove a key from fields
`form.update(f, key, fn)`	`Form, string, (any) -> any -> Form`	Update a field with a function
`form.merge_with(f1, f2, fn)`	`Form, Form, (any, any) -> any -> Form`	Merge forms using a custom conflict resolver

Serialization

Function	Signature	Description
`form.to_text(f)`	`Form -> string`	Serialize to mashinTalk source
`form.to_text(f, opts)`	`Form, object -> string`	Serialize with options
`form.from_text(text)`	`string -> Form`	Parse mashinTalk source into a form
`form.to_json(f)`	`Form -> string`	Serialize to JSON
`form.from_json(json)`	`string -> Form`	Deserialize from JSON
`form.to_minified(f)`	`Form -> string`	Minified mashinTalk source
`form.to_node(f)`	`Form -> object`	Convert to a plain object node

Traversal and Search

Function	Signature	Description
`form.postwalk(f, fn)`	`Form, (Form) -> Form -> Form`	Walk tree bottom-up, transforming each node
`form.prewalk(f, fn)`	`Form, (Form) -> Form -> Form`	Walk tree top-down, transforming each node
`form.flatten(f)`	`Form -> array<Form>`	All nodes as a flat list
`form.clone(f)`	`Form -> Form`	Deep copy
`form.find(f, predicate)`	`Form, (Form) -> boolean -> Form \| nil`	First node matching predicate
`form.select(f, predicate)`	`Form, (Form) -> boolean -> array<Form>`	All nodes matching predicate
`form.some(f, predicate)`	`Form, (Form) -> boolean -> boolean`	True if any node matches
`form.every(f, predicate)`	`Form, (Form) -> boolean -> boolean`	True if all nodes match
`form.map_children(f, fn)`	`Form, (Form) -> Form -> Form`	Transform direct children only
`form.flat_map(f, fn)`	`Form, (Form) -> array<Form> -> array<Form>`	Map then flatten children

Deep Access

Function	Signature	Description
`form.get_in(f, path)`	`Form, array<string> -> any`	Get a nested value by path
`form.put_in(f, path, value)`	`Form, array<string>, any -> Form`	Set a nested value by path
`form.update_in(f, path, fn)`	`Form, array<string>, (any) -> any -> Form`	Update a nested value with a function

Construction

Function	Signature	Description
`form.new(kind, name)`	`string, string -> Form`	Create a new form node
`form.new(kind, name, fields)`	`string, string, object -> Form`	Create with initial fields
`form.from_node(node)`	`object -> Form`	Build a form from a plain object

Analysis

Function	Signature	Description
`form.validate(f)`	`Form -> object`	Validate; returns `{valid: boolean, errors: array}`
`form.hash(f)`	`Form -> string`	Content hash of the form
`form.capabilities(f)`	`Form -> array<string>`	Capabilities declared or used
`form.dependencies(f)`	`Form -> array<string>`	Machine references this form depends on
`form.credential_requirements(f)`	`Form -> array<string>`	Credentials required to run
`form.explain(f)`	`Form -> string`	Human-readable description

Composition

Function	Signature	Description
`form.pipe(f, fns...)`	`Form, ...(Form) -> Form -> Form`	Apply a sequence of transformations

Utilities

Function	Signature	Description
`form.frequencies(f)`	`Form -> object`	Map of node kind to count
`form.sort_by(f, fn)`	`Form, (Form) -> any -> array<Form>`	Sort children by a key function
`form.select_keys(f, keys)`	`Form, array<string> -> object`	Extract named fields as an object
`form.group_by(f, fn)`	`Form, (Form) -> any -> object`	Group nodes by a key function

Zipper (cursor-based traversal)

Zippers let you navigate and edit a form tree by keeping a cursor position. Changes made via a zipper are applied when you call form.root.

Function	Signature	Description
`form.zipper(f)`	`Form -> Zipper`	Create a zipper at the root
`form.down(z)`	`Zipper -> Zipper`	Move to first child
`form.up(z)`	`Zipper -> Zipper`	Move to parent
`form.left(z)`	`Zipper -> Zipper`	Move to left sibling
`form.right(z)`	`Zipper -> Zipper`	Move to right sibling
`form.zip_node(z)`	`Zipper -> Form`	Get the form at the current cursor
`form.edit(z, fn)`	`Zipper, (Form) -> Form -> Zipper`	Transform the current node
`form.zip_replace(z, form)`	`Zipper, Form -> Zipper`	Replace the current node
`form.insert_left(z, form)`	`Zipper, Form -> Zipper`	Insert a sibling to the left
`form.insert_right(z, form)`	`Zipper, Form -> Zipper`	Insert a sibling to the right
`form.zip_remove(z)`	`Zipper -> Zipper`	Remove the current node
`form.root(z)`	`Zipper -> Form`	Return the full form with all zipper edits applied

Extensions

Function	Signature	Description
`form.generate_inputs(f)`	`Form -> object`	Generate a sample input object matching the form’s `accepts` contract
`form.apply_rules(f, rules)`	`Form, array -> Form`	Apply a list of transformation rules to the form
`form.recommend_supervision(f)`	`Form -> object`	Suggest governance settings based on form analysis

Governed effects (require `ask` step)

These functions perform governed effects and cannot be called in a compute step. Use them inside an ask step.

Function	Description
`form.eval(f, input)`	Execute the form with a given input object
`form.propose(f, name)`	Propose the form for promotion under a given name
`form.describe(machine_ref)`	Load and describe a machine by reference

Value Methods

Value methods are called on a value using dot syntax: value.method(args).

Array Methods

Methods available on any array value.

Method	Signature	Description
`.map(fn)`	`(any) -> any -> array`	Transform each element
`.map(fn)`	`(any, integer) -> any -> array`	Transform with element and index
`.flatMap(fn)`	`(any) -> array -> array`	Map then flatten one level
`.filter(fn)`	`(any) -> boolean -> array`	Keep elements where fn returns true
`.reject(fn)`	`(any) -> boolean -> array`	Remove elements where fn returns true
`.reduce(fn, initial)`	`(acc, el) -> acc, any -> any`	Accumulate a single value
`.sort()`	`-> array`	Sort using default order
`.sort(fn)`	`(a, b) -> number -> array`	Sort using a comparator
`.sortBy(fn)`	`(any) -> comparable -> array`	Sort by a key function
`.reverse()`	`-> array`	Reverse element order
`.uniq()`	`-> array`	Remove duplicates
`.unique()`	`-> array`	Alias for `.uniq()`
`.uniqBy(fn)`	`(any) -> any -> array`	Remove duplicates by a key function
`.uniqueBy(fn)`	`(any) -> any -> array`	Alias for `.uniqBy()`
`.groupBy(fn)`	`(any) -> any -> object`	Group elements by a key function
`.chunk(size)`	`integer -> array<array>`	Split into sub-arrays of given size
`.zip(other)`	`array -> array<[any, any]>`	Pair elements with another array
`.flat()`	`-> array`	Flatten one level of nesting
`.find(fn)`	`(any) -> boolean -> any \| nil`	First element matching fn
`.some(fn)`	`(any) -> boolean -> boolean`	True if any element matches fn
`.any(fn)`	`(any) -> boolean -> boolean`	Alias for `.some()`
`.every(fn)`	`(any) -> boolean -> boolean`	True if all elements match fn
`.includes(value)`	`any -> boolean`	True if the array contains value
`.indexOf(value)`	`any -> integer`	Index of first occurrence, -1 if absent
`.count(fn)`	`(any) -> boolean -> integer`	Count elements matching fn
`.first()`	`-> any \| nil`	First element or nil
`.last()`	`-> any \| nil`	Last element or nil
`.pop()`	`-> any \| nil`	Alias for `.last()`
`.take(n)`	`integer -> array`	First n elements
`.drop(n)`	`integer -> array`	All elements after the first n
`.slice(start)`	`integer -> array`	Elements from start to end
`.slice(start, stop)`	`integer, integer -> array`	Elements from start to stop (exclusive)
`.at(index)`	`integer -> any \| nil`	Element at index, nil if out of bounds
`.sum()`	`-> number`	Sum of all elements
`.min()`	`-> any`	Minimum element
`.max()`	`-> any`	Maximum element
`.join(separator)`	`string -> string`	Join elements into a string
`.concat(other)`	`array -> array`	Concatenate two arrays
`.length`	`integer`	Number of elements (property, not a method call)

compute summarize
  let active = input.users.filter(u => u.active)
  let names = active.map(u => u.name)
  let sorted = names.sort()
  {count: active.length, names: sorted}

String Methods

Methods available on any string value.

Method	Signature	Description
`.toUpperCase()`	`-> string`	Convert to uppercase
`.toLowerCase()`	`-> string`	Convert to lowercase
`.uppercase()`	`-> string`	Alias for `.toUpperCase()`
`.lowercase()`	`-> string`	Alias for `.toLowerCase()`
`.trim()`	`-> string`	Remove leading and trailing whitespace
`.trimStart()`	`-> string`	Remove leading whitespace only
`.trimEnd()`	`-> string`	Remove trailing whitespace only
`.split(delimiter)`	`string -> array<string>`	Split into a list on delimiter
`.replace(pattern, replacement)`	`string, string -> string`	Replace first occurrence
`.replaceAll(pattern, replacement)`	`string, string -> string`	Replace all occurrences
`.startsWith(prefix)`	`string -> boolean`	True if string starts with prefix
`.endsWith(suffix)`	`string -> boolean`	True if string ends with suffix
`.padStart(length)`	`integer -> string`	Pad with spaces on the left
`.padEnd(length)`	`integer -> string`	Pad with spaces on the right
`.repeat(count)`	`integer -> string`	Repeat the string count times
`.substring(start)`	`integer -> string`	Characters from start to end
`.substring(start, end)`	`integer, integer -> string`	Characters from start to end (exclusive)
`.match(pattern)`	`string \| regex -> array<string> \| nil`	First match, or nil if no match
`.matchAll(pattern)`	`string \| regex -> array<array<string>>`	All matches
`.test(pattern)`	`string \| regex -> boolean`	True if pattern matches
`.toString()`	`-> string`	Identity (returns the string itself)
`.length`	`integer`	Character count (property, not a method call)

compute format_slug
  input.title.toLowerCase().trim().replaceAll(" ", "-")

Global Functions

Global functions are called without a namespace prefix.

Type Checking

Function	Signature	Description
`typeof(value)`	`any -> string`	Returns `"number"`, `"string"`, `"boolean"`, `"list"`, `"object"`, or `"null"`
`isNumber(value)`	`any -> boolean`	True if value is a number
`isString(value)`	`any -> boolean`	True if value is a string
`isBoolean(value)`	`any -> boolean`	True if value is a boolean
`isArray(value)`	`any -> boolean`	True if value is an array
`isObject(value)`	`any -> boolean`	True if value is an object
`isNull(value)`	`any -> boolean`	True if value is nil
`isNaN(value)`	`any -> boolean`	True if value is NaN

Type Conversion

Function	Signature	Description
`string(value)`	`any -> string`	Coerce to string
`number(value)`	`string -> integer`	Parse string to integer
`parseInt(value)`	`any -> integer \| NaN`	Parse to integer, NaN if unparseable
`parseFloat(value)`	`any -> float \| NaN`	Parse to float, NaN if unparseable

Collection (Polymorphic)

These functions work on both arrays and strings.

Function	Signature	Description
`length(value)`	`array \| string \| object -> integer`	Count of elements, characters, or keys
`first(arr)`	`array -> any \| nil`	First element or nil
`last(arr)`	`array -> any \| nil`	Last element or nil
`includes(collection, value)`	`array \| string, any -> boolean`	True if collection contains value
`indexOf(collection, value)`	`array \| string, any -> integer`	Index of first occurrence, -1 if absent
`slice(collection, start)`	`array \| string, integer -> array \| string`	Sub-list or substring from start
`slice(collection, start, stop)`	`array \| string, integer, integer -> array \| string`	Sub-list or substring from start to stop

Control Flow

Function	Signature	Description
`while(initial, condition, body)`	`any, (state) -> boolean, (state) -> state -> any`	Iterate until condition is false. Max 10,000 iterations.

compute collatz
  let steps = while(input.n, n => n != 1, n => n % 2 == 0 ? n / 2 : 3 * n + 1)
  {result: steps}

Metaprogramming

Function	Signature	Description
`quote(expr)`	`expr -> Form`	Capture an expression as a `Form` at compile time
`reflect()`	`-> Form \| nil`	Return the current machine’s own form

Utilities

Function	Signature	Description
`inspect(value)`	`any -> string`	Debug representation of any value
`now()`	`-> string`	Current UTC time as ISO 8601 (alias for `DateTime.now()`)

Property Access

The .length property works on arrays, strings, and objects without parentheses:

input.items.length        // number of elements in an array
input.name.length         // number of characters in a string
Object.keys(obj).length   // number of keys in an object

Runtime Bindings

Special variables available in machine context:

Binding	Type	Description
`me`	`object`	Current machine runtime context. Includes the machine name, version, and execution metadata.

Expression Standard Library

Namespaces

Math

DateTime

JSON

Object

Set

UUID

Intl

Result

Option

String (namespace)

form (Governed Metaprogramming)

Introspection

Mutation

Serialization

Traversal and Search

Deep Access

Construction

Analysis

Composition

Utilities

Zipper (cursor-based traversal)

Extensions

Governed effects (require ask step)

Value Methods

Array Methods

String Methods

Global Functions

Type Checking

Type Conversion

Collection (Polymorphic)

Control Flow

Metaprogramming

Utilities

Property Access

Runtime Bindings

See also

Governed effects (require `ask` step)