取自
Translation status: 简体中文 reader-locale proof. Term names and code fences follow the zh-Hans pack; supporting prose may still be English.
Extracts fields from a value into local bindings.
Syntax: 取自 <expression> <常量|变量> <field> [, ...] [其余 <ident>]
Category#
destructuring
Related#
Examples#
radix/corpus/destructura/lista.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# 取自 — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Lista destructuring — `常量 [a, b, c] ← 列表` extracts elements from a 列表 into individual bindings.
# • Rest patterns — `常量 [caput, 其余 cauda] ← 列表` captures remaining elements.
# • Mutable destructuring — `变量 [x, y] ← 列表` for mutable bindings.
# • Skip and nested patterns — underscore `_` skips elements; nested listas destructure recursively.
#
# Common mistakes:
# • Destructuring fewer or more elements than the 列表 contains without handling bounds — pattern must match or the destructuring will fail.
#
# See also: 借自, 作为, 其余
# =============================================================================
# destructura — 列表 destructuring patterns
#
# 常量 [a, b, c] ← 列表
# 变量 [x, y, z] ← 列表
# 常量 [caput, 其余 cauda] ← 列表
# 常量 [_, medius, _] ← 列表
#
# GRAMMAR:
# destructStmt :← ('常量' | '变量') '[' patternList ']' '←' expr
#
# EXPECTED OUTPUT:
# Element values from inline and bound listas, rest slices, nested rows.
main {
# --- Basic 列表 destructuring ---
const _ numeri ← [1, 2, 3]
const [a, b, c] ← numeri
print a
print b
print c
# Destructure inline 列表 literal
const [primus, secundus, tertius] ← [10, 20, 30]
print primus
print secundus
print tertius
# --- Mutable destructuring with 变量 ---
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 其余 ---
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 _ 矩阵 ← [[1, 2], [3, 4]]
const [ordo1, ordo2] ← 矩阵
print ordo1
print ordo2
}Expected output:
1
2
3
10
20
30
100
200
150
250
1
2
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.
# =============================================================================
# 取自 — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Field destructuring — `取自 <expr> 常量 <field>, ...` extracts named fields from 类 records into local bindings.
# • Aliasing — `取自 <expr> 常量 <field> 作为 <alias>` renames extracted fields.
# • Mutable extraction — `取自 <expr> 变量 <field>, ...` for mutable field bindings.
# • Rest pattern — `取自 <expr> 常量 <field>, 其余 <rest>` captures remaining fields as a 映射.
# • Nested paths — `取自 <expr>.<field> 常量 ...` destructures through nested paths.
#
# Common mistakes:
# • Destructuring a field that does not exist on the target type — the field must be present in the 类 definition or the type must support open shapes.
#
# See also: 借自, 作为, 其余
# =============================================================================
# destructura — field destructuring with `取自`
#
# 取自 <expr> 常量 <field>, ...
# 取自 <expr> 变量 <field>, ...
# 取自 <expr> 常量 <field> 作为 <alias>
# 取自 <expr> 常量 <field>, 其余 <rest>
#
# Field destructuring works on 类 records (fixed fields) and 映射/valor
# (open shapes). This tour uses 类 types so that field names are statically
# known and codegen-complete.
#
# GRAMMAR:
# destructStmt :← '取自' expr ('常量' | '变量') patternList
#
# EXPECTED OUTPUT:
# Extracted field values, aliased names, mutated 变量 bindings, rest maps.
class Persona {
var string 名称
var int aetas
var string urbs
}
class Civis {
var string 名称
var string epistula
}
class Datum {
var int 整数
var bool activus
}
class Forma {
var string hospes
var int portus
var bool tutus
}
class Plenus {
var int signum
var string 名称
var string epistula
var string munus
}
class Sodalis {
var string 名称
var bool probatus
}
class Relatus {
var Sodalis civis
}
class Responsum {
var Relatus datum
}
class Vestis {
var string modus
var string lingua
}
main {
# --- Basic field extraction ---
const _ persona ← Persona { 名称 = "Marcus", aetas = 30, urbs = "Roma" }
from persona const 名称, aetas
print 名称
print aetas
# --- Extract with alias using '作为' ---
const _ civis ← Civis { 名称 = "Julia", epistula = "julia@roma.com" }
from civis const 名称 as cognomen, epistula as epistula2
print cognomen
print epistula2
# --- Mutable destructuring with 变量 ---
const _ datum ← Datum { 整数 = 100, activus = true }
from datum var 整数, activus
print 整数
print activus
整数 ← 200
activus ← false
print 整数
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 其余 ---
const _ plenus ← Plenus { signum = 1, 名称 = "Gaius", epistula = "g@roma.com", munus = "admin" }
from plenus const signum, rest reliqua
print signum
print reliqua
# --- Destructura 取自 nested path ---
const _ responsum ← Responsum { datum = Relatus { civis = Sodalis { 名称 = "Claudia", probatus = true } } }
from responsum.datum.civis const 名称 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.
# =============================================================================
# 取自 — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Field extraction — `取自 <expr> 常量 <field>, ...` extracts named fields from 类 records into local scope.
# • Multiple field extraction — extract several fields from a single expression in one statement.
#
# Common mistakes:
# • Mode mismatch — passing a `借自` (read-only) parameter to an `取自` (consume) position, or extracting a field that doesn't exist on the target type.
#
# See also: 借自, 作为, 其余
# =============================================================================
# 取自 — field extract statement
#
# GRAMMAR:
# extractStmt :← '取自' expr bindingList
#
# EXPECTED OUTPUT:
# Scalar stdout smoke (see body).
#
# BACKEND:
# Cross-ref: destructura/objectum.fab, 遍历/ex.fab (遍历 取自 mode).
#
class Persona {
var string 名称
var int aetas
}
main {
const _ p ← Persona { 名称 = "Marcus", aetas = 30 }
from p const 名称, aetas
print 名称
print aetas
}Expected output:
Marcus
30
radix/corpus/itera/destructuring.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# 取自 — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • Loop-binder destructuring — `for from xs const [a, b] { ... }` binds each
# element through the same pattern grammar as binding-position forms.
# • Records (类) — `for from puncta const {x, y} { ... }` object_pattern
# binds fields by name on each element.
# • Positional tuples — `for from ordines const [a, b] { ... }` binds tuple
# slots positionally.
# • Rest patterns — `for from matricula const [caput, rest cauda]` captures
# the remaining 列表.
# • Holes — `for from ordines const [_, secundus]` skips a slot with `_`.
#
# Common mistakes:
# • Binding more pattern slots than the tuple element has — the loop binder
# inherits the binding-form width rules and rejects with
# `tuple_index_out_of_bounds`.
# • Naming an element label the tuple does not declare — by-label patterns
# must name declared labels and reject with `unknown_tuple_element_label`.
#
# See also: 借自, 作为, 其余
# =============================================================================
# 遍历 — destructuring loop binders
#
# for from <collection> <const|var> <pattern> { <body> }
#
# The binder accepts the same array/object patterns as binding position:
# [a, b] positional slots
# {x, y} record fields
# [caput, rest cauda] rest pattern
# [_, x] holes
#
# GRAMMAR:
# forInStmt :← '遍历' '取自' expr ('常量' | '变量') pattern block
#
# EXPECTED OUTPUT:
# destructuring.expected — sums and elements from every pattern form.
class Punctum {
var int x
var int y
}
main {
# --- Records: object_pattern over 列表 of 类 elements ---
const _ puncta ← [Punctum { x = 1, y = 2 }, Punctum { x = 3, y = 4 }]
for from puncta const {x, y} {
print x + y
}
# --- Labeled tuples: object_pattern binds by label ---
const list<tuple<gx: int, int>> paria ← [tuple<int, int> [50, 60], tuple<int, int> [70, 80]]
for from paria const {gx} {
print gx
}
# --- Positional tuples: array_pattern over fixed-width rows ---
const list<tuple<int, int>> ordines ← [tuple<int, int> [10, 20], tuple<int, int> [30, 40]]
for from ordines const [a, b] {
print a + b
}
# --- Rest patterns: first element plus the remaining 列表 ---
const _ matricula ← [[1, 2, 3], [4, 5, 6]]
for from matricula const [caput, rest cauda] {
print caput
print cauda[1]
}
# --- Holes: `_` skips a slot ---
for from ordines const [_, secundus] {
print secundus
}
}Expected output:
3
7
50
70
30
70
1
3
4
6
20
40
radix/corpus/itera/ex.fab (canonical · keyword)#
Extracts fields from a value into local bindings.
# =============================================================================
# 取自 — Extracts fields from a value into local bindings.
# =============================================================================
#
# What this teaches:
# • value iteration (`遍历 取自`) over 列表 elements — the primary workhorse for iterating over collections
# • transforming values inside the loop body (e.g., doubling each element)
#
# Common mistakes:
# • Using 取自 (value iteration) when 借自 (key/index iteration) is needed — 取自 iterates values, 借自 iterates keys or indices.
#
# See also: 借自, 作为, 其余
# =============================================================================
# 遍历 取自 — for-in value iteration over listas
#
# 遍历 取自 <collection> 常量 <item> { <body> }
#
# GRAMMAR:
# forInStmt :← '遍历' '取自' expr '常量' ident block
#
# EXPECTED OUTPUT:
# ex.expected — numbers, names, and doubled values.
main {
# Iterate over number 列表
const list<int, 5> numeri ← [1, 2, 3, 4, 5]
for from numeri const n {
print n
}
# Iterate over 文本 列表
const list<string, 3> nomina ← ["Marcus", "Julia", "Claudia"]
for from nomina const 名称 {
print 名称
}
# Transform values
const list<int, 3> valores ← [10, 20, 30]
for from valores const v {
const int duplex ← v * 2
print duplex
}
}Expected output:
1
2
3
4
5
Marcus
Julia
Claudia
20
40
60