vel

Provides a default when the left side is null.

Aliases: nullish coalescing

Syntax: <expression> vel <expression>

Category#

logic

Related#

• nihil

Examples#

radix/corpus/vel/vel.fab (canonical · operator-group)#

Provides a default when the left side is null.

# =============================================================================
# vel — Provides a default when the left side is null.
# =============================================================================
#
# What this teaches:
#   • Nullish coalescing — `vel` supplies a fallback when the left operand is `nihil`
#   • Chaining — multiple `vel` expressions fall through until the first non-`nihil` value
#
# Common mistakes:
#   • confusing vel (nullish coalescing, checks nihil only) with aut (logical OR), or using vel for conversio recovery instead of ⇥
#
# See also: nihil
# =============================================================================




# vel — nullish coalescing (not logical OR)
#
# <expr> vel <expr>   -- right side only when left is nihil
#
# GRAMMAR:
#   coalesceExpr :← expr 'vel' expr
#
# EXPECTED OUTPUT:
#   ignotus, Marcus, 0, false, defectum, inventum (vel.expected).

main {
    # Basic nihil coalescing
    const string ∪ null nomen ← null
    let ostensum ← nomen coalesce "ignotus"
    # "ignotus"
    print ostensum

    # With present value
    const string ∪ null adest ← "Marcus"
    let ostensum2 ← adest coalesce "ignotus"
    # "Marcus"
    print ostensum2

    # Difference from logical aut: vel only checks nihil
    let nihilum ← 0
    let vacuus ← ""
    let falsus2 ← false

    # vel preserves non-nihil values
    # 0
    print nihilum coalesce 999
    # ""
    print vacuus coalesce "defectum"
    # falsum
    print falsus2 coalesce true

    let alter ← nomen coalesce "defectum"
    print alter

    # Chaining
    const string ∪ null a ← null
    const string ∪ null b ← null
    const string ∪ null c ← "inventum"
    let primum ← a coalesce b coalesce c coalesce "nihil"
    # "inventum"
    print primum
}

test "vel supplies a fallback for nihil" {
    const string ∪ null nomen ← null
    let ostensum ← nomen coalesce "ignotus"
    assert ostensum ≡ "ignotus"
}

test "vel preserves non-nihil values" {
    let nihilum ← 0
    let vacuus ← ""
    let falsus2 ← false
    assert (nihilum coalesce 999) ≡ 0
    assert (vacuus coalesce "defectum") ≡ ""
    assert (falsus2 coalesce true) ≡ false
}

test "vel chains to the first non-nihil value" {
    const string ∪ null a ← null
    const string ∪ null b ← null
    const string ∪ null c ← "inventum"
    let primum ← a coalesce b coalesce c coalesce "nihil"
    assert primum ≡ "inventum"
}

Expected output:

ignotus
Marcus
0

falsum
defectum
inventum