upd: lazily commit on June 2nd, 2026 4:32 PM UTC -0700 by lily

Author: transicle

docs/functions.md

@@ -3,15 +3,15 @@
 Declaring a function in ADAN will be like the following:
 
 ```adan
-func example(<Params>): <type>? {
+func example(<Params>): <Type>? {
 
 }
 ```
 
-- `<type>?` Refers to an *optional* type, if no type is provided, one will be inferred by the function's result.
-- - If no type is provided, `: <type>?` can be fully omitted.
+- `<Type>?` Refers to an *optional* type, if no type is provided, one will be inferred by the function's result.
+- - If no type is provided, `: <Type>?` can be fully omitted.
 
-After a function is defined, it is callable using the `<name>(<params>);` syntax:
+After a function is defined, it is callable using the `<Name>(<Params>);` syntax:
 
 ```adan
 func example(): Integer ... # Let's say this returns `1`.

docs/loops.md

@@ -13,7 +13,49 @@ A for-in loop is a kind of loop that can optionally save the `key` *and* the `va
 
 ## <...>? = <...> (local variable) OR _ (no variable)
 
-for <key>?, <value>? in <loop> {
+for <Key>?, <Value>? in <Loop> {
     ...
 }
+```
+
+### Entry-Controlled For Loop
+
+An entry-controlled for loop is a type of loop that allows you to change the starting position in the array.
+
+For example, we can do: `for var i = 0; ...; ... { ... }`, where `0` is the position we start at in the array.
+
+> If we set it to `3` for example, our loop would *start* in the *fourth* index of the array.
+
+```adan
+# Syntax
+
+for <Init>?; <Condition>?; <Iterate --/++>? {
+    ...
+}
+```
+
+If every field is left empty (for ; ; ; { ... }), the loop would run indefinitely.
+
+### While Loops
+
+While loops by design, repeat indefinitely while the condition provided equates to true. Once false, the loop will break, never repeating again.
+
+```adan
+# Syntax
+
+while <Condition> {
+    ...
+}
+```
+
+### Exit-Controlled Loop
+
+Unlike entry-controlled for loops, exit-controlled loops are styled similarly to while loops, where they check the condition first, *then*, and only if true, they run the code, exit-controlled loops run the code *first*, ***and then*** check the condition to validate if it should continue.
+
+```adan
+# Syntax
+
+repeat {
+    ...
+} until <Condition>;
 ```

docs/variables.md

@@ -9,15 +9,15 @@ Variables can be read only (immutable) using the `readonly` keyword beforehand.
 ```adan
 var a = 1;
 
-var b: <type>? = 1;
+var b: <Type>? = 1;
 
 a = 2;
 
-readonly var c: <type>? = 1;
+readonly var c: <Type>? = 1;
 ```
 
-- `<type>?` Refers to an *optional* type, if no type is provided, one will be inferred by the variable's result.
-- - If no type is provided, `: <type>?` can be fully omitted.
+- `<Type>?` Refers to an *optional* type, if no type is provided, one will be inferred by the variable's result.
+- - If no type is provided, `: <Type>?` can be fully omitted.
 
 Unlike *most modern languages* (**i.e.** JavaScript, Python, etc.), variables are capable of starting with integers.
 
@@ -55,16 +55,16 @@ In conclusion, here are all of the various ways variables may be defined:
 ```adan
 var a = 1;
 
-var b: <type>? = 1;
+var b: <Type>? = 1;
 
 a = 2; # Assigning an existing variable a new value.
        # Cannot declare variables this way.
 
-readonly var c: <type>? = 1;
+readonly var c: <Type>? = 1;
 
-global var d: <type>? = 1;
+global var d: <Type>? = 1;
 
-global readonly var e: <type>? = 1;
+global readonly var e: <Type>? = 1;
 
 global d = 2;
 ```