# L4 Operators Reference

Operators in L4 perform operations on values. Most operators have both textual (keyword) and symbolic forms to balance readability for legal professionals and conciseness for programmers.

## Overview

L4 operators are organized into categories:

- **Arithmetic** - Mathematical operations (PLUS, MINUS, TIMES, etc.)
- **Comparison** - Value comparisons (EQUALS, GREATER THAN, etc.)
- **Logical** - Boolean operations (AND, OR, NOT, IMPLIES)
- **String** - Text manipulation (CONCAT, APPEND)
- **List** - List construction and manipulation (FOLLOWED BY, EMPTY)
- **Temporal** - Time-based operations (AT, WITHIN)

---

## Arithmetic Operators

Mathematical operations on numbers.

[Details and examples on arithmetic operators](/l4/reference/operators/arithmetic.md)

### Addition

- **Keyword:** PLUS
- **Symbol:** `+`
- **Type:** `NUMBER -> NUMBER -> NUMBER`
- **Example:** `5 PLUS 3` or `5 + 3` → `8`

### Subtraction

- **Keyword:** MINUS
- **Symbol:** `-`
- **Type:** `NUMBER -> NUMBER -> NUMBER`
- **Example:** `10 MINUS 4` or `10 - 4` → `6`

### Multiplication

- **Keyword:** TIMES
- **Symbol:** `*`
- **Type:** `NUMBER -> NUMBER -> NUMBER`
- **Example:** `6 TIMES 7` or `6 * 7` → `42`

### Division

- **Keywords:** DIVIDED BY
- **Symbol:** `/`
- **Type:** `NUMBER -> NUMBER -> NUMBER`
- **Example:** `15 DIVIDED BY 3` or `15 / 3` → `5`
- **Note:** Returns rational numbers for non-integer results

### Modulo

- **Keyword:** MODULO
- **Type:** `NUMBER -> NUMBER -> NUMBER`
- **Example:** `17 MODULO 5` → `2`
- **Note:** Remainder after division

---

## Comparison Operators

Compare values and return BOOLEAN results.

[Details and examples on comparison operators](/l4/reference/operators/comparisons.md)

### Equality

- **Keyword:** EQUALS
- **Symbol:** `=`
- **Type:** `a -> a -> BOOLEAN`
- **Example:** `5 EQUALS 5` or `5 = 5` → `TRUE`

### Greater Than

- **Keywords:** GREATER THAN, ABOVE
- **Symbol:** `>`
- **Type:** `NUMBER -> NUMBER -> BOOLEAN`
- **Example:** `10 GREATER THAN 5` or `10 > 5` → `TRUE`

### Less Than

- **Keywords:** LESS THAN, BELOW
- **Symbol:** `<`
- **Type:** `NUMBER -> NUMBER -> BOOLEAN`
- **Example:** `3 LESS THAN 7` or `3 < 7` → `TRUE`

### Greater or Equal

- **Keywords:** AT LEAST
- **Symbol:** `>=`
- **Type:** `NUMBER -> NUMBER -> BOOLEAN`
- **Example:** `5 AT LEAST 5` or `5 >= 5` → `TRUE`

### Less or Equal

- **Keywords:** AT MOST
- **Symbol:** `<=`
- **Type:** `NUMBER -> NUMBER -> BOOLEAN`
- **Example:** `4 AT MOST 10` or `4 <= 10` → `TRUE`

### Inequality

- **Expression:** `NOT (x EQUALS y)`
- **Example:** `NOT (5 EQUALS 3)` → `TRUE`

---

## Logical Operators

Boolean operations for conditions and logic.

### Conjunction

- **Keyword:** [AND](/l4/reference/operators/AND.md)
- **Symbol:** `&&` / `...`
- **Type:** `BOOLEAN -> BOOLEAN -> BOOLEAN`
- **Example:** `TRUE AND FALSE` → `FALSE`
- **Truth table:**
  - `TRUE AND TRUE` → `TRUE`
  - `TRUE AND FALSE` → `FALSE`
  - `FALSE AND TRUE` → `FALSE`
  - `FALSE AND FALSE` → `FALSE`

### Disjunction

- **Keyword:** [OR](/l4/reference/operators/OR.md)
- **Symbol:** `||` \ `..`
- **Type:** `BOOLEAN -> BOOLEAN -> BOOLEAN`
- **Example:** `TRUE OR FALSE` → `TRUE`
- **Truth table:**
  - `TRUE OR TRUE` → `TRUE`
  - `TRUE OR FALSE` → `TRUE`
  - `FALSE OR TRUE` → `TRUE`
  - `FALSE OR FALSE` → `FALSE`

### Negation

- **Keyword:** [NOT](/l4/reference/operators/NOT.md)
- **Type:** `BOOLEAN -> BOOLEAN`
- **Example:** `NOT TRUE` → `FALSE`

### Implication

- **Keyword:** [IMPLIES](/l4/reference/operators/IMPLIES.md)
- **Symbol:** `=>`
- **Type:** `BOOLEAN -> BOOLEAN -> BOOLEAN`
- **Example:** `FALSE IMPLIES TRUE` → `TRUE`
- **Note:** `p IMPLIES q` is equivalent to `NOT p OR q`

### Exception

- **Keyword:** [UNLESS](/l4/reference/operators/UNLESS.md)
- **Type:** `BOOLEAN -> BOOLEAN -> BOOLEAN`
- **Example:** `TRUE UNLESS FALSE` → `TRUE`
- **Note:** `p UNLESS q` is equivalent to `p AND NOT q`
- **Precedence:** Binds looser than OR (applies to entire expression)
- **Truth table:**
  - `TRUE UNLESS TRUE` → `FALSE`
  - `TRUE UNLESS FALSE` → `TRUE`
  - `FALSE UNLESS TRUE` → `FALSE`
  - `FALSE UNLESS FALSE` → `FALSE`

---

## String Operators

Operations on text strings.

### Concatenation

- **Keyword:** CONCAT
- **Type:** `STRING -> STRING -> STRING`
- **Example:** `CONCAT "hello", " world"` → `"hello world"`

### Append

- **Keyword:** APPEND
- **Type:** `STRING -> STRING -> STRING`
- **Example:** `"hello" APPEND " world"` → `"hello world"`
- **Note:** Infix wrapper for CONCAT

---

## List Operators

Construct and manipulate lists.

### Cons

- **Keywords:** FOLLOWED BY
- **Type:** `a -> LIST OF a -> LIST OF a`
- **Example:** `1 FOLLOWED BY LIST 2, 3` → `LIST 1, 2, 3`
- **Note:** Prepends element to list

### Empty List

- **Keyword:** EMPTY
- **Type:** `LIST OF a`
- **Example:** `EMPTY` → Empty list
- **Note:** Used in pattern matching

---

## Temporal Operators

Time-based operations for dates and deadlines.

### At

- **Keyword:** AT
- **Type:** Used during tracing of regulative statements to track points in time
- **Example:** `event AT date`

### Within

- **Keyword:** WITHIN
- **Type:** Time duration constraint in regulative statements
- **Example:** `PARTY MUST DO action WITHIN 30 DAYS`

---

## Operator Precedence

Operators are evaluated in the following order (highest to lowest precedence):

1. **Function application** (highest)
2. **Unary operators** (NOT)
3. **Multiplicative** (TIMES, DIVIDED BY, MODULO)
4. **Additive** (PLUS, MINUS)
5. **Comparison** (EQUALS, GREATER THAN, LESS THAN, etc.)
6. **Logical AND**
7. **Logical OR**
8. **UNLESS** (exception clause)
9. **IMPLIES** (lowest)

Use parentheses `()` to override precedence.

### Examples



```l4-file
-- Example: Operator precedence
-- Demonstrates how operators are evaluated in order

x MEANS 3
y MEANS 4
z MEANS 5

-- Multiplication before addition
#EVAL x PLUS y TIMES z
-- Evaluates as: 3 + (4 * 5) = 23

-- Use parentheses for clarity
#EVAL (x PLUS y) TIMES z
-- Evaluates as: 7 * 5 = 35
```



---

## Associativity

### Left-Associative Operators

Most binary operators associate left-to-right.

### Right-Associative Operators

List cons (FOLLOWED BY) and IMPLIES associate right-to-left.



```l4-file
-- Example: Operator associativity
-- Demonstrates left and right associative operators

-- Left-associative: subtraction
a MEANS 10
b MEANS 3
c MEANS 2

#EVAL a MINUS b MINUS c
-- Evaluates as: (10 - 3) - 2 = 5

-- Right-associative: list cons
#EVAL 1 FOLLOWED BY 2 FOLLOWED BY 3 FOLLOWED BY EMPTY
-- Evaluates as: 1 FOLLOWED BY (2 FOLLOWED BY (3 FOLLOWED BY EMPTY))
```



---

## Overloading

Some operators work on multiple types:

### EQUALS

Works on most types:

- `5 EQUALS 5` (NUMBER)
- `"hello" EQUALS "hello"` (STRING)
- `TRUE EQUALS TRUE` (BOOLEAN)

### Comparison Operators

Work on ordered types:

- NUMBER: `5 > 3`
- STRING: `"b" > "a"` (lexicographic)
- DATE: `date1 > date2` (chronological)

### PLUS

Overloaded for different contexts:

- Arithmetic: `5 + 3`
- Can be extended via libraries

---

## Special Syntax

### Asyndetic Operators

Implicit operators using punctuation:

- **`...`** (ellipsis) - Implicit AND
- **`..`** (double dot) - Implicit OR

**Example:** 

```l4-file
-- Example: Asyndetic operators (... and ..)
-- Implicit AND and OR using punctuation

citizen MEANS TRUE
over18 MEANS TRUE
hasID MEANS TRUE

approved MEANS TRUE
pending MEANS FALSE
review MEANS FALSE

-- Ellipsis (...) = implicit AND
eligible1 MEANS citizen ... over18 ... hasID
-- Equivalent to: (citizen AND over18 AND hasID)

-- Double dot (..) = implicit OR
inProgress MEANS approved .. pending .. review
-- Equivalent to: (approved OR pending OR review)

#EVAL eligible1
#EVAL inProgress
```



### Genitive

Field access using possessive:

- **`'s`** - Record field access
- Example: `person's age`

See the syntax reference for details.

---

## Textual vs. Symbolic Forms

### Why Both?

- **Textual forms** - More readable for legal professionals unfamiliar with programming
- **Symbolic forms** - More concise for experienced developers

Both are equivalent and can be mixed.

**Example:** 

```l4-file
-- Example: Textual vs symbolic operators
-- All forms are equivalent and can be mixed

age MEANS 25
citizen MEANS TRUE

-- All equivalent forms
eligible1 MEANS (age > 18) AND (citizen EQUALS TRUE)
eligible2 MEANS (age GREATER THAN 18) AND (citizen = TRUE)
eligible3 MEANS (age > 18) && (citizen EQUALS TRUE)

#EVAL eligible1
#EVAL eligible2
#EVAL eligible3
```



### Recommendations

- **Legal documents:** Prefer textual forms
- **Technical code:** Use symbolic forms for conciseness
- **Mixed audiences:** Choose based on primary readers

---

## See Also

- **[GLOSSARY](/l4/reference/GLOSSARY.md)** - All operators indexed
- **[Functions](/l4/reference/functions.md)** - Function keywords
- **[Types](/l4/reference/types.md)** - Types used with operators
- **[Syntax](/l4/reference/syntax.md)** - Operator syntax rules