Values, types and operators

This page lists the values, types and operators you can use in Acore. Acore has two expression grammars: the general evaluator used by general modules and property values, and the checked expression grammar used by backend pure fn bodies, managed blocks and Acore UI. Each section says which one it covers. Examples were evaluated with axiom eval or checked with axiom check from CLI 0.149.1.

Values in general modules

Types in general modules

name: String = "tasks"
attempts: Int = 3
enabled: Boolean = true
ratio: Number = 1.5
description: String? = null
identifier: String | Int = "task-1"
mode: "audit" | "strict" = "audit"
tags: Listing<String> = Listing { "alpha" }
sampleRate: Float(this >= 0.0 && this <= 1.0) = 0.5
handler: (String, Int) -> Boolean = (s, i) -> true

Rules verified in 0.149.1:

• A declared type and its constraints are checked on the property's value. x: Int(this > 0) = -5 fails with Type mismatch.
• typealias Mode = "audit" | "strict" is accepted, but a property typed Mode is not checked against the literals. Write the union inline when you need the check.
• A typed object such as Base { port = "x" } does not re-check an overridden property against the class's declared type or constraint. A class property with no default must still be set. Profile validators for backend, UI and database sources remain authoritative.
• Constraints validate authored values during evaluation. They are not server-side authorization rules.

Types in backend and UI declarations

Backend models use these types. Field constraints such as String(minLength: 1) are listed in Validation.

Acore UI has its own portable types, such as Int and Bool, and keeps integers within the safe JavaScript range. See Acore UI.

Operators in general modules

From lowest to highest binding precedence. All binary operators are left associative except **.

Unary - negates a number and ! negates a Boolean. Mixing an integer and a float promotes to float. Integer +, -, * and ** fail on overflow, and integer division by zero fails with Division by zero. A float divided by zero is infinite, and rendering it fails with Cannot render non-finite float.

The lexer also recognizes % and ~/, but the 0.149.1 parser rejects them (Unexpected token: Mod, Unexpected token: TruncDiv).

baseTimeout = 5
timeout = baseTimeout * 2
configuredLabel = null
label = configuredLabel ?? "Untitled"
active = true
attempts = 2
eligible = active && attempts < 3

{
  "active": true,
  "attempts": 2,
  "baseTimeout": 5,
  "eligible": true,
  "label": "Untitled",
  "timeout": 10
}

Member access and null handling

length = name.length
safeName = account?.profile?.name
requiredName = safeName!!

Type checks and casts

is and as are reserved words, but the 0.149.1 parser rejects them (Unexpected token: Is). Use a typed property, such as text: String = value, to check a value's type.

Conditionals and let

cacheSeconds = if (environment == "prod") 300 else 0
area = let (side = 4) side * side

The condition must be a Boolean. Without else, a false condition produces null, so the property is left out of output. Write an explicit alternative for typed contract values. let (name = value) body binds a name for one expression; let (name: Type = value) also checks the type.

Lambdas

double = (value: Int) -> value * 2
doubled = [1, 2, 3].map(double)
add = (a, b) -> a + b
sum = add(1, 2)

Lambdas capture their lexical scope. Extra call arguments are ignored. Acore UI also has a compact lambda form for list keys; see Acore UI.

Errors and reads

required = configured ?? throw("configured is required")
region = read("env:REGION") ?? "local"

Every read goes through the evaluator's security manager. Naming a path does not grant I/O. Contracts must not depend on environment values: declare a runtime secret instead.

Checked expressions in backend and UI code

Backend pure fn bodies, managed blocks, validator checks and Acore UI expressions share a separate, checked grammar.

Other forms:

• Unary ! and -, member access . and ?., and indexing items[0], which returns an optional value.
• Records {title: value}, lists [a, b], record updates {task with title: t} and interpolated strings $"...".
• Calls to declared pure functions and bounded methods: String has length, trim(), toLowerCase(), toUpperCase(), contains(s), startsWith(s), endsWith(s) and slice(start, end); List has length, contains(x), take(n), drop(n), sum() for integers and join(sep) for strings.
• No lambdas, ** or |>. Arithmetic is checked, evaluation runs left to right, &&, || and ?? short-circuit, and string length counts Unicode scalar values.

project(id: "pure-example", version: "1.0.0")
pure fn label(count: Int32): String = count > 1 ? "many" : "one"
pure fn orNone(value: String?): String = value ?? "none"
pure fn isEven(value: Int32): Bool = value % 2 == 0

Related

• Syntax
• Objects, classes and functions
• Standard library
• Managed logic and concurrency