Renderingen-US

Experimental through version 1. Version 0 was alpha. This is the first language release: the interface is relatively stable, not frozen. Nothing is promised stable until version 2.

membrum

Translation status: English reader-locale proof. Term names and code fences follow the en pack; supporting prose may still be English.

Dot, bracket, chained, and optional member access expressions.

Syntax: <expr>.<field> | <expr>[<index>] | <expr>?.<field>

Category#

class

Examples#

radix/corpus/reference/concept/membrum/membrum.fab (canonical · concept)#

Dot, bracket, chained, and optional member access expressions.

# =============================================================================
# membrum — Dot, bracket, chained, and optional member access expressions.
# =============================================================================
#
# What this teaches:
#   • dot access (`expr.field`) on class records — direct field lookup
#   • bracket access (`expr[index]`) on listas and ledger — indexed access
#   • optional chaining (`expr?.field`) — safe navigation that returns none on missing values
#   • chained access combining dot, bracket, and optional access
#
# Common mistakes:
#   • Accessing a field that does not exist on the receiver type — dot access requires a matching member on the class.
#
# See also: ?., list, map, class
# =============================================================================

# membrum — dot, bracket, chained, and optional access
#
# expr.<field>        -- dot access on class records
# expr[index]         -- bracket access on listas and ledger
# expr?.<field>       -- optional chaining (see optionalis/optionalis.fab)
#
# GRAMMAR:
#   memberExpr :← primary ('.' ident | '[' expr ']' | '?.' ident)*
#
# EXPECTED OUTPUT:
#   membrum.expected — chained access samples.

class Punctum {
    mut int x
    mut int y
}

class Figura {
    mut string name
    mut int valor
}

class Imum {
    mut string imum
}

class Medium {
    mut Imum medium
}

class Extra {
    mut Medium extra
}

class Datum {
    mut list<string> nomina
}

class Adest {
    mut int valor
}

class Forsitan {
    mut Adest adest
}

main {
    # --- Dot accessus ---

    let Punctum punctum ← Punctum { x = 10, y = 20 }
    print punctum.x
    print punctum.y

    # --- Bracket accessus on list ---

    let list<int, size 3> numeri ← [1, 2, 3]
    print numeri[0]
    print numeri[2]

    # --- Bracket accessus on map ---

    let map<string, int> indicium ← { "nomen": 1, "valor": 42 }
    print indicium["nomen"]
    print indicium["valor"]

    # --- Chained member access ---

    let Extra nidus ← Extra { extra = Medium { medium = Imum { imum = "inventum" } } }
    print nidus.extra.medium.imum

    # --- Mixed dot and bracket ---

    let Datum datum ← Datum { nomina = ["primus", "secundus", "tertius"] }
    print datum.nomina[0]
    print datum.nomina[2]

    # --- Accessus optionalis ---

    let Forsitan forsitan ← Forsitan { adest = Adest { valor = 100 } }
    print forsitan?.adest?.valor

    # Accessus optionalis on none binding
    let none void ← null
    print void?.absens
}

Expected output:

10
20
1
3
1
42
inventum
primus
tertius
100
none