aut

Combines boolean expressions with logical or.

Aliases: or

Syntax: <expression> aut <expression>

Category#

logic

Related#

• et
• vel
• ⊻

Examples#

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

Combines boolean expressions with logical or.

# =============================================================================
# aut — Combines boolean expressions with logical or.
# =============================================================================
#
# What this teaches:
#   • Complete binary operator tour — arithmetic (`+ − * / %`), comparison
#     (`≡ ≠ < >`), logic (`et aut`), nullish coalescing (`vel`), ternary
#     (`sic/secus`), and bitwise (`∧ ∨ ⊻ ⇐ ⇒`)
#   • Assignment patterns — explicit assignment (`←`) and postfix increment
#     (`⊕ ⊖` statements)
#   • `sit` sugar — compact inference syntax alongside explicit `fixum _`
#     type inference
#
# Common mistakes:
#   • confusing `≡` (equality comparison) with `=` (structural field init) or `←` (assignment) — each operator has a distinct role
#
# See also: et, vel, ⊻
# =============================================================================

# binarius — binary operators and explicit assignment
#
# Covers arithmetic (+ − * / %), comparison (≡ ≠ < >), logic (et aut),
# nullish coalescing (vel), ternary (sic/secus), bitwise (∧ ∨ ⊻ ⇐ ⇒),
# explicit assignment (←), and postfix increment (⊕ ⊖ statements).
#
# GRAMMAR:
#   binaryExpr :← expr (arithOp | cmpOp | logicOp | bitwiseOp) expr
#
# Inferred result locals below mix fixum _ (explicit infer marker) with sit
# (compact sugar) so both spellings stay visible in one tour.
#
# EXPECTED OUTPUT:
#   binarius.expected

main {
    # Arithmetica: + - * / %
    const _ summa ← 10 + 5
    print summa

    const _ differentia ← 10 - 5
    print differentia

    let productum ← 10 * 5
    print productum

    let quotiens ← 10 / 5
    print quotiens

    let reliquum ← 10 % 3
    print reliquum

    # Assignatio explicita (compound glyphs removed)
    var _ index ← 0
    index ← index + 10
    index ⊕
    index ⊖
    index ← index * 2
    print index

    # Comparationes
    let aequalis ← 10 ≡ 10
    print aequalis

    let diversus ← 10 ≠ 5
    print diversus

    let minor ← 5 < 10
    print minor

    let maior ← 10 > 5
    print maior

    let medius ← 0 < 5 and 5 < 10
    print medius

    # Logica
    let ambo ← true and true
    print ambo

    let alterutrum ← false or true
    print alterutrum

    let neutrum ← false and false
    print neutrum

    let short ← false and carum()
    print short

    # vel
    const string ∪ null nomen ← null
    let solutum ← nomen coalesce "defectum"
    print solutum

    const string ∪ null primum ← null
    const string ∪ null secundum ← null
    const string tertium ← "inventum"
    let inventum ← primum coalesce secundum coalesce tertium
    print inventum

    # sic/secus — ternary conditional (sic = "thus", secus = "otherwise")
    let aetas ← 25
    let condicio ← aetas ≥ 18 yields "adultus" else "minor"
    print condicio

    let puncta ← 85
    let gradus ← puncta ≥ 90 yields "A" else puncta ≥ 80 yields "B" else puncta ≥ 70 yields "C" else "F"
    print gradus

    # Bit per bit
    let vexilla ← 0b1010
    let persona ← 0b1100

    let coniuncta ← vexilla ∧ persona
    print coniuncta

    let velata ← vexilla ∨ persona
    print velata

    let diversa ← vexilla ⊻ persona
    print diversa

    # Motus bit
    let sinistra ← 1 ⇐ 4
    print sinistra

    let dextra ← 16 ⇒ 2
    print dextra

    let persona_vacua ← (vexilla ∧ persona) ≡ 0
    print persona_vacua
}

fn carum() → bool {
    print "hoc non videatur"
    return true
}

Expected output:

15
5
50
2
1
20
verum
verum
verum
verum
verum
verum
verum
falsum
falsum
defectum
inventum
adultus
B
8
14
6
16
4
falsum