fez-lisp 1.6.38 → 1.6.40

package/README.md

@@ -1,9 +1,5 @@
 # Fez Programming Language
 
-<p align="center">
-<img width="128" src="./favicon.svg"/>
-</p>
-
 ```lisp
 (let fezz-buzz (lambda n
         (cond
@@ -50,6 +46,80 @@
 (mod ...) (let ...) (if ...) (not ...) (and ...) (or ...) (atom? ...) (lambda? ...)
 (length ...) (do ...) (array ...) (set! ...) (pop! ...) (get ...) (lambda ...) (apply ...)
 
+; Arithmetic Operators
+; +: Addition.
+(+ a b) ; → returns the sum of a and b.
+; -: Subtraction.
+(- a b) ; → returns a minus b.
+; *: Multiplication.
+(* a b) ; → returns the product of a and b.
+; /: Division.
+(/ a b) ; → returns a divided by b.
+; mod: Modulo (remainder).
+(mod a b) ; → returns the remainder of a divided by b.
+; Comparison Operators
+; =: Equality.
+(= a b) ; → returns 1 if a equals b, else 0.
+; <: Less than.
+(< a b) ; → returns 1 if a is less than b, else 0.
+; >: Greater than.
+(> a b) ; → returns 1 if a is greater than b, else 0.
+; <=: Less than or equal.
+(<= a b) ; → returns 1 if a is less than or equal to b, else 0.
+; >=: Greater than or equal.
+(>= a b) ; → returns 1 if a is greater than or equal to b, else 0.
+; Bitwise Operators
+; &: Bitwise AND.
+(& a b)
+; |: Bitwise OR.
+(| a b)
+; ^: Bitwise XOR.
+(^ a b)
+; ~: Bitwise NOT.
+(~ a)
+; <<: Bitwise left shift.
+(<< a b)
+; >>: Bitwise right shift.
+(>> a b)
+; Logical Operators
+; and: Logical AND.
+(and a b) ; → returns a if a is 0, else b.
+; or: Logical OR.
+(or a b) ; → returns 1 if a is 1, else b.
+; not: Logical NOT.
+(not a) ; → returns 1 if a is 0, else 0.
+; Control Flow
+; if: Conditional.
+(if cond then else) → evaluates then if cond is true, else else.
+; do: Sequence.
+(do expr1 expr2 ...) → evaluates each expression in order, returns the last.
+; loop: While loop.
+(loop cond body) → repeatedly evaluates body while cond is true.
+; Functions
+; lambda: Function definition.
+(lambda x y (do ...)) ; → returns a function of x and y.
+; apply: Function application.
+(apply f a b ...) → applies function f to arguments.
+; Variables
+; let: Variable definition.
+(let x 10) → defines x as 10.
+; set!: Array element assignment.
+(set! arr idx val) → sets arr[idx] to val.
+; pop!: Array pop.
+(pop! arr) → removes the last element from arr.
+; Arrays
+; array: Array creation.
+(array 1 2 3) → creates [1, 2, 3].
+; get: Array element access.
+(get arr idx) ; → returns arr[idx].
+; length: Array length.
+(length arr) ; → returns the number of elements in arr.
+; Type Predicates
+; atom?: Checks if value is a number.
+(atom? x) ; → returns 1 if x is a number, else 0.
+; lambda?: Checks if value is a function.
+(lambda? x) ; → returns 1 if x is a function, else 0.
+
 ; Important Note:
 ; In this programming language, parentheses are used to group expressions and define the structure of code.
 ; It is essential to keep the number of opening and closing parentheses balanced.
@@ -433,5 +503,4 @@
 ; - Variable redeclaration: Do not redeclare (let) a variable that already exists in the same scope. Redeclaring variables can cause bugs or unexpected behavior. Always use unique variable names within a given scope, or update the variable using the appropriate set! or var:set! helper.
 ; - (get) vs (array:get): (get) and (array:get) are the same under the hood. (get xs) with one argument is equivalent to (get xs 0), returning the first element. However, you should only use (get) for variables declared with (variable) syntactic sugar (numbers only). For arrays, always use (array:get). For booleans, use (boole:true?) or related helpers. This avoids ambiguity and makes your code clearer and less error-prone.
 
-
 ```