ex
Translation status: 繁體中文 reader-locale proof. Code fences render through the zh-Hant pipeline; prose is canonical Latin.
Extracts fields from a value into local bindings.
Syntax: ex <expression> <fixum|varia> <field> [, ...] [ceteri <ident>]
Category#
destructuring
Related#
Examples#
radix/corpus/destructura/lista.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# ex — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Lista destructuring — `fixum [a, b, c] ← lista` extracts elements from a lista into individual bindings.
# • Rest patterns — `fixum [caput, ceteri cauda] ← lista` captures remaining elements.
# • Mutable destructuring — `varia [x, y] ← lista` for mutable bindings.
# • Skip and nested patterns — underscore `_` skips elements; nested listas destructure recursively.
#
# Common mistakes:
# • Destructuring fewer or more elements than the lista contains without handling bounds — pattern must match or the destructuring will fail.
#
# See also: de, ut, ceteri
# =============================================================================
# destructura — lista destructuring patterns
#
# fixum [a, b, c] ← lista
# varia [x, y, z] ← lista
# fixum [caput, ceteri cauda] ← lista
# fixum [_, medius, _] ← lista
#
# GRAMMAR:
# destructStmt :← ('fixum' | 'varia') '[' patternList ']' '←' expr
#
# EXPECTED OUTPUT:
# Element values from inline and bound listas, rest slices, nested rows.
main {
# --- Basic lista destructuring ---
const _ numeri ← [1, 2, 3]
const [a, b, c] ← numeri
print a
print b
print c
# Destructure inline lista literal
const [primus, secundus, tertius] ← [10, 20, 30]
print primus
print secundus
print tertius
# --- Mutable destructuring with varia ---
const _ coordinata ← [100, 200]
var [x, y] ← coordinata
print x
print y
x ← x + 50
y ← y + 50
print x
print y
# --- Partial destructuring (fewer variables than elements) ---
const _ valores ← [1, 2, 3, 4, 5]
const [unus, duo] ← valores
print unus
print duo
# --- Rest pattern with ceteri ---
const _ res ← [1, 2, 3, 4, 5]
const [caput, rest cauda] ← res
print caput
print cauda
# --- Skip elements with underscore ---
const _ triplex ← [10, 20, 30]
const [_, medius, _] ← triplex
print medius
# --- Nested listas ---
const _ matrix ← [[1, 2], [3, 4]]
const [ordo1, ordo2] ← matrix
print ordo1
print ordo2
}Expected output:
1
2
3
10
20
30
100
200
150
250
1
2
1
[1, 2, 3, 4, 5]
20
[1, 2]
[3, 4]
radix/corpus/destructura/objectum.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# ex — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Field destructuring — `ex <expr> fixum <field>, ...` extracts named fields from genus records into local bindings.
# • Aliasing — `ex <expr> fixum <field> ut <alias>` renames extracted fields.
# • Mutable extraction — `ex <expr> varia <field>, ...` for mutable field bindings.
# • Rest pattern — `ex <expr> fixum <field>, ceteri <rest>` captures remaining fields as a tabula.
# • Nested paths — `ex <expr>.<field> fixum ...` destructures through nested paths.
#
# Common mistakes:
# • Destructuring a field that does not exist on the target type — the field must be present in the genus definition or the type must support open shapes.
#
# See also: de, ut, ceteri
# =============================================================================
# destructura — field destructuring with `ex`
#
# ex <expr> fixum <field>, ...
# ex <expr> varia <field>, ...
# ex <expr> fixum <field> ut <alias>
# ex <expr> fixum <field>, ceteri <rest>
#
# Field destructuring works on genus records (fixed fields) and tabula/valor
# (open shapes). This tour uses genus types so that field names are statically
# known and codegen-complete.
#
# GRAMMAR:
# destructStmt :← 'ex' expr ('fixum' | 'varia') patternList
#
# EXPECTED OUTPUT:
# Extracted field values, aliased names, mutated varia bindings, rest maps.
class Persona {
string nomen
int aetas
string urbs
}
class Civis {
string nomen
string epistula
}
class Datum {
int numerus
bool activus
}
class Forma {
string hospes
int portus
bool tutus
}
class Plenus {
int signum
string nomen
string epistula
string munus
}
class Sodalis {
string nomen
bool probatus
}
class Relatus {
Sodalis civis
}
class Responsum {
Relatus datum
}
class Vestis {
string modus
string lingua
}
main {
# --- Basic field extraction ---
const _ persona ← Persona { nomen = "Marcus", aetas = 30, urbs = "Roma" }
from persona const nomen, aetas
print nomen
print aetas
# --- Extract with alias using 'ut' ---
const _ civis ← Civis { nomen = "Julia", epistula = "julia@roma.com" }
from civis const nomen as cognomen, epistula as epistula2
print cognomen
print epistula2
# --- Mutable destructuring with varia ---
const _ datum ← Datum { numerus = 100, activus = true }
from datum var numerus, activus
print numerus
print activus
numerus ← 200
activus ← false
print numerus
print activus
# --- Mixed alias and regular fields ---
const _ forma ← Forma { hospes = "localis", portus = 8080, tutus = true }
from forma const hospes, portus as porta, tutus
print hospes
print porta
print tutus
# --- Rest pattern with ceteri ---
const _ plenus ← Plenus { signum = 1, nomen = "Gaius", epistula = "g@roma.com", munus = "admin" }
from plenus const signum, rest reliqua
print signum
print reliqua
# --- Destructura ex nested path ---
const _ responsum ← Responsum { datum = Relatus { civis = Sodalis { nomen = "Claudia", probatus = true } } }
from responsum.datum.civis const nomen as internum, probatus
print internum
print probatus
# --- Single field extraction ---
const _ vestis ← Vestis { modus = "nigrum", lingua = "la" }
from vestis const modus
print modus
}radix/corpus/ex/ex.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# ex — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Field extraction — `ex <expr> fixum <field>, ...` extracts named fields from genus records into local scope.
# • Multiple field extraction — extract several fields from a single expression in one statement.
#
# Common mistakes:
# • Mode mismatch — passing a `de` (read-only) parameter to an `ex` (consume) position, or extracting a field that doesn't exist on the target type.
#
# See also: de, ut, ceteri
# =============================================================================
# ex — field extract statement
#
# GRAMMAR:
# extractStmt :← 'ex' expr bindingList
#
# EXPECTED OUTPUT:
# Scalar stdout smoke (see body).
#
# BACKEND:
# Cross-ref: destructura/objectum.fab, itera/ex.fab (itera ex mode).
#
class Persona {
string nomen
int aetas
}
main {
const _ p ← Persona { nomen = "Marcus", aetas = 30 }
from p const nomen, aetas
print nomen
print aetas
}Expected output:
Marcus
30
radix/corpus/itera/ex.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# ex — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • value iteration (`itera ex`) over lista elements — the primary workhorse for iterating over collections
# • transforming values inside the loop body (e.g., doubling each element)
#
# Common mistakes:
# • Using ex (value iteration) when de (key/index iteration) is needed — ex iterates values, de iterates keys or indices.
#
# See also: de, ut, ceteri
# =============================================================================
# itera ex — for-in value iteration over listas
#
# itera ex <collection> fixum <item> { <body> }
#
# GRAMMAR:
# forInStmt :← 'itera' 'ex' expr 'fixum' ident block
#
# EXPECTED OUTPUT:
# ex.expected — numbers, names, and doubled values.
main {
# Iterate over number lista
const _ numeri ← [1, 2, 3, 4, 5]
for from numeri const n {
print n
}
# Iterate over textus lista
const _ nomina ← ["Marcus", "Julia", "Claudia"]
for from nomina const nomen {
print nomen
}
# Transform values
const _ valores ← [10, 20, 30]
for from valores const v {
const _ duplex ← v * 2
print duplex
}
}Expected output:
1
2
3
4
5
Marcus
Julia
Claudia
20
40
60