أو

Combines boolean expressions with logical or.

Aliases: or

Syntax: <expression> أو <expression>

Category#

logic

Related#

• و
• عوض
• ⊻

Examples#

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

Combines boolean expressions with logical or.

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

# =============================================================================
# أو — Combines boolean expressions with logical or.
# =============================================================================
#
# What this teaches:
#   • Complete binary operator tour — arithmetic (`+ − * / %`), comparison
#     (`≡ ≠ < >`), logic (`et أو`), nullish coalescing (`vel`), ternary
#     (`sic/secus`), and bitwise (`∧ ∨ ⊻ ⇐ ⇒`)
#   • Assignment patterns — explicit assignment (`←`) and postfix increment
#     (`↑ ↓` statements)
#   • `ليكن` sugar — compact inference syntax alongside explicit `ثابت _`
#     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 أو),
# 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 ثابت _ (explicit infer marker) with ليكن
# (compact sugar) so both spellings stay visible in one tour.
#
# EXPECTED OUTPUT:
#   binarius.expected

main {
    # Arithmetica: + - * / %
    const int المجموع ← 10 + 5
    print المجموع
    const int 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 int 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 ∪ none اسم ← null
    let solutum ← اسم coalesce "defectum"
    print solutum
    const string ∪ none primum ← null
    const string ∪ none secundum ← null
    const string tertium ← "inventum"
    let inventum ← (primum coalesce secundum) coalesce tertium
    print inventum

    # ✓ ✗ — value conditional, one level only
    let aetas ← 25
    let condicio ← aetas ≥ 18 ✓ "adultus" ✗ "minor"
    print condicio
    let puncta ← 85
    let gradus ← puncta ≥ 80 ✓ "B" ✗ "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
}

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