Renderingla

∴

Introduces a compact statement consequent.

Aliases: ergo, therefore

Syntax: <head> ergo <statement>

Category

control-flow

Related

Examples

examples/corpus/operatores/control.fab (canonical · operator-group)

Compact consequent after si/dum heads via ergo, with ∴ reserved for closure bodies.

# operatores/control — ergo therefore consequent
#
# GRAMMAR:
#   consequentStmt :← ('si' | 'sin' | 'secus' | 'dum') expr 'ergo' stmt
#
# EXPECTED OUTPUT:
#   0, 100, 42
#
# BACKEND:
#   Cross-ref si/ergo-redde.fab for ergo-redde guard-return spelling.

functio clamp(numerus x) → numerus {
    si x < 0 ergo redde 0
    si x > 100 ergo redde 100
    redde x
}

functio inveni(lista<numerus> res, numerus quaesitum) → numerus ∪ nihil {
    itera ex res fixum item {
        si item ≡ quaesitum ergo redde item
    }
    redde nihil
}

incipit {
    nota clamp(-5)
    nota clamp(150)
    nota inveni([10, 20, 42], 42)
}

Expected output:

0
100
42

examples/corpus/si/ergo-redde.fab (canonical · operator-group)

Introduces a compact statement consequent.

# Si with ergo redde syntax
#
# si <conditio> ergo redde <expressio>     -- guard return
# sin <conditio> ergo redde <expressio>    -- else-if guard
# secus ergo redde <expressio>             -- else return
#
# GRAMMAR:
#   guardReturn :← ('si' | 'sin' | 'secus') expr 'ergo' 'redde' expr
#
# EXPECTED OUTPUT:
#   Sign classes, division results, grades, and search hits.

functio classis(numerus x) → textus {
    si x < 0 ergo redde "negativus"
    si x ≡ 0 ergo redde "nihil"
    redde "positivus"
}

# Optional return: nihil when divisor is zero
functio divide(numerus a, numerus b) → numerus ∪ nihil {
    si b ≡ 0 ergo redde nihil
    redde a / b
}

# sin chain with secus ergo redde fallback
functio gradus(numerus puncta) → textus {
    si puncta ≥ 90 ergo redde "A"
    sin puncta ≥ 80 ergo redde "B"
    sin puncta ≥ 70 ergo redde "C"
    sin puncta ≥ 60 ergo redde "D"
    secus ergo redde "F"
}

# Early return inside itera ex loop
functio inveni(lista<numerus> res, numerus quaesitum) → numerus ∪ nihil {
    itera ex res fixum item {
        si item ≡ quaesitum ergo redde item
    }
    redde nihil
}

functio habet(tabula<textus, numerus> tabula, textus clavis) → bivalens {
    itera de tabula fixum k {
        si k ≡ clavis ergo redde verum
    }
    redde falsum
}

incipit {
    # Sign classification
    nota classis(-5)
    nota classis(0)
    nota classis(10)

    # Optional return on invalid divisor
    # 5
    nota divide(10, 2)
    # nihil
    nota divide(10, 0)

    # Letter grades via sin chain
    nota gradus(95)
    nota gradus(85)
    nota gradus(55)

    # Linear search with early redde
    fixum _ numeri ← [1, 2, 3, 4, 5]
    nota inveni(numeri, 3)
    nota inveni(numeri, 9)
}

Expected output:

negativus
nihil
positivus
5
nihil
A
B
F
3
nihil

examples/corpus/si/ergo.fab (canonical · operator-group)

Introduces a compact statement consequent.

# One-liner conditionals with ergo
#
# si <condition> ergo <statement>                              -- single consequent
# si <condition> ergo <statement> secus ergo <statement>     -- if-else one-liner
#
# GRAMMAR:
#   ifStmt :← 'si' expr 'ergo' stmt ('secus' 'ergo' stmt)?
#
# EXPECTED OUTPUT:
#   Validation and grading lines for sample x, aetas, and puncta values.

incipit {
    # ergo replaces a one-statement block body
    fixum _ x ← 10

    si x > 5 ergo nota "x magnum est"

    # secus ergo pairs else with a single consequent
    fixum _ aetas ← 25
    si aetas ≥ 18 ergo nota "adultus"
    secus ergo nota "minor"

    # Two-way one-liner (85 < 90 → "non A")
    fixum _ puncta ← 85
    si puncta ≥ 90 ergo nota "A"
    secus ergo nota "non A"

    # bivalens condition used directly
    fixum _ valet ← verum
    si valet ergo nota "Recte"
}

Expected output:

x magnum est
adultus
non A
Recte