membrum

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

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

Category#

expression

Related#

• ?.
• list
• map
• class

Examples#

radix/corpus/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 tabulae — 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 tabulae
# expr?.<field>       -- optional chaining (see optionalis/optionalis.fab)
#
# GRAMMAR:
#   memberExpr :← primary ('.' ident | '[' expr ']' | '?.' ident)*
#
# EXPECTED OUTPUT:
#   membrum.expected — chained access samples.

class Punctum {
    var int x
    var int y
}

class Figura {
    var string name
    var int value
}

class Imum {
    var string imum
}

class Medium {
    var Imum medium
}

class Extra {
    var Medium extra
}

class Datum {
    var list<string> nomina
}

class Adest {
    var int value
}

class Forsitan {
    var Adest adest
}

main {
    # --- Dot accessus ---

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

    # --- Bracket accessus on list ---

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

    # --- Bracket accessus on map ---

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

    # --- Chained member access ---

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

    # --- Mixed dot and bracket ---

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

    # --- Accessus optionalis ---

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

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

Expected output:

10
20
1
3
1
42
inventum
primus
tertius
100
nihil