feat: add if-chain interpreter support and update documentation

Interpreter:
- Add Statement::IfChain handler for if/elif/else chains

README:
- Clarify that RPython does not support comments in source code
- Fix if/elif/else syntax examples (each branch needs own 'end')
- Document semicolon requirement after 'end' for consecutive statements
- Note that Maybe/Result constructors cannot be parsed from source yet
- Update limitations list with comments and Maybe/Result parsing

Examples:
- Add comprehensive demo program (examples/hello_io.rpy) testing:
  variables, literals, arithmetic, comparisons, conditionals,
  while/for loops, break/continue, functions, and metabuiltins

Author: RafaelLopes23

README.md

@@ -47,14 +47,16 @@ The language surface resembles Python to lower the barrier for students, while t
 ### Variables
 
 ```text
-val pi = 3.14159;          # immutable binding
-var counter = 0;           # mutable binding
-counter = counter + 1;     # reassignment allowed for var
+val pi = 3.14159;
+var counter = 0;
+counter = counter + 1;
 ```
 
 - `val` declares an immutable variable; reassignment is a compile-time error.
 - `var` declares a mutable variable.
 
+> **Note:** RPython does not support comments in source code. The examples in this README omit comments for accuracy.
+
 ### Literals
 
 | Type      | Example                        |
@@ -106,14 +108,14 @@ RPython uses explicit, static types for function parameters and return values. V
 ```text
 if score >= 90:
     grade = "A";
-elif score >= 80:
+end elif score >= 80:
     grade = "B";
-else:
+end else:
     grade = "C";
 end
 ```
 
-All branches must be terminated with `end`.
+Each branch in an if-chain has its own block terminated by `end`. The `elif` and `else` keywords follow the preceding `end`.
 
 ### Loops
 
@@ -142,14 +144,17 @@ Functions require type annotations for parameters and return type.
 def factorial(n: Int) -> Int:
     if n <= 1:
         return 1;
-    end
-    return n * factorial(n - 1);
+    end else:
+        return n * factorial(n - 1);
+    end;
 end;
 
 val result = factorial(5);
-asserttrue(result == 120, "5! should be 120");
+assertrue(result == 120, "5! should be 120");
 ```
 
+> **Syntax note:** Block statements (`if`, `while`, `for`, `def`) require a semicolon after the closing `end` when followed by additional statements at the same level.
+
 ### Lambdas
 
 Anonymous functions can be assigned to variables or passed as arguments.
@@ -202,37 +207,21 @@ Metabuiltins are functions implemented in Rust and exposed to user code. They ha
 
 ## Error Handling
 
-RPython provides two monadic types for representing optional or fallible values.
-
-### `Maybe[T]`
+RPython provides two monadic types for representing optional or fallible values: `Maybe[T]` and `Result[Ok, Err]`.
 
-```text
-val name = Just("Alice");
-val empty = Nothing;
+### Type Definitions
 
-if isNothing(empty):
-    print("No value");
-end
+- `Maybe[T]` — Optional value: `Just(value)` or `Nothing`
+- `Result[Ok, Err]` — Success/failure: `Ok(value)` or `Err(error)`
 
-val unwrapped = name!;   # unwrap: panics if Nothing
-```
+### Available Operations
 
-### `Result[Ok, Err]`
-
-```text
-def divide(a: Int, b: Int) -> Result[Int, String]:
-    if b == 0:
-        return Err("division by zero");
-    end
-    return Ok(a / b);
-end;
-
-val result = divide(10, 2)?;  # propagate Err automatically
-```
+- `isNothing(maybe)` — returns `True` if the value is `Nothing`
+- `isError(result)` — returns `True` if the value is `Err`
+- `unwrap(value)` — extracts the inner value (panics if `Nothing` or `Err`)
+- `tryUnwrap(value)` — extracts or propagates errors automatically
 
-- `isError(result)` checks if a `Result` is an `Err`.
-- `isNothing(maybe)` checks if a `Maybe` is `Nothing`.
-- The `?` operator (propagate) returns early if the value is `Err`.
+> **Current limitation:** The parser does not yet support `Just()`, `Nothing`, `Ok()`, and `Err()` as expression syntax. These types exist in the AST and type system, and are used internally by the interpreter and type checker. Parser support for constructing these values from source code is planned for a future release.
 
 ---
 
@@ -350,9 +339,11 @@ The interpreter reads from stdin and writes to stdout, making it suitable for au
 
 1. **No module system:** all code lives in a single file.
 2. **No pattern matching:** ADT constructors can be built but not destructured.
-3. **No interactive REPL:** only file-based execution is supported.
-4. **Limited error messages:** parser and type checker errors are functional but not always user-friendly.
-5. **No tail-call optimization:** deep recursion may overflow the stack.
+3. **No comments:** the parser does not support `#` or any comment syntax.
+4. **No interactive REPL:** only file-based execution is supported.
+5. **Limited error messages:** parser and type checker errors are functional but not always user-friendly.
+6. **No tail-call optimization:** deep recursion may overflow the stack.
+7. **Maybe/Result constructors:** `Just()`, `Nothing`, `Ok()`, `Err()` cannot be parsed from source code yet.
 
 ---
 

examples/hello_io.rpy

@@ -1,4 +1,151 @@
-var _ = print("Hello from R-Python");
-var _ = print("2 + 3 = ");
-var resultado = 2 + 3;
-var _ = print(resultado);
+var _ = print_line("=== RPython Demo ===");
+
+var _ = print_line("=== 1. Variables ===");
+val pi = 3.14159;
+var counter = 1;
+var _ = print("pi = ");
+var _ = print_line(pi);
+var _ = print("counter = ");
+var _ = print_line(counter);
+
+var _ = print_line("=== 2. Literals ===");
+var _ = print("Int: ");
+var _ = print_line(42);
+var _ = print("Real: ");
+var _ = print_line(3.14);
+var _ = print("String: ");
+var _ = print_line("hello");
+var _ = print("Bool: ");
+var _ = print_line(True);
+
+var _ = print_line("=== 3. Arithmetic ===");
+var _ = print("10 + 5 = ");
+var _ = print_line(10 + 5);
+var _ = print("10 - 3 = ");
+var _ = print_line(10 - 3);
+var _ = print("6 * 7 = ");
+var _ = print_line(6 * 7);
+var _ = print("20 / 4 = ");
+var _ = print_line(20 / 4);
+
+var _ = print_line("=== 4. Comparisons ===");
+var _ = print("5 == 5: ");
+var _ = print_line(5 == 5);
+var _ = print("10 > 3: ");
+var _ = print_line(10 > 3);
+var _ = print("True and True: ");
+var _ = print_line(True and True);
+var _ = print("False or True: ");
+var _ = print_line(False or True);
+var _ = print("not False: ");
+var _ = print_line(not False);
+
+var _ = print_line("=== 5. Conditionals ===");
+val score = 85;
+var _ = print("Score 85 gets grade: ");
+if score >= 90:
+    var _ = print_line("A");
+end elif score >= 80:
+    var _ = print_line("B");
+end elif score >= 70:
+    var _ = print_line("C");
+end else:
+    var _ = print_line("F");
+end;
+
+var _ = print_line("=== 6. While Loop ===");
+var _ = print("Counting: ");
+var i = 0;
+while i < 5:
+    var _ = print(i);
+    var _ = print(" ");
+    i = i + 1;
+end;
+var _ = print_line("");
+
+var _ = print_line("=== 7. For Loop ===");
+var _ = print("List items: ");
+val items = [10, 20, 30];
+for item in items:
+    var _ = print(item);
+    var _ = print(" ");
+end;
+var _ = print_line("");
+
+var _ = print_line("=== 8. Break/Continue ===");
+var _ = print("Break at 3: ");
+var j = 0;
+while j < 10:
+    if j == 3:
+        break;
+    end;
+    var _ = print(j);
+    var _ = print(" ");
+    j = j + 1;
+end;
+var _ = print_line("");
+
+var _ = print("Skip evens: ");
+for k in [0, 1, 2, 3, 4, 5]:
+    if k == 0:
+        continue;
+    end elif k == 2:
+        continue;
+    end elif k == 4:
+        continue;
+    end;
+    var _ = print(k);
+    var _ = print(" ");
+end;
+var _ = print_line("");
+
+var _ = print_line("=== 9. Functions ===");
+def factorial(n: Int) -> Int:
+    if n <= 1:
+        return 1;
+    end else:
+        return n * factorial(n - 1);
+    end;
+end;
+
+def add(a: Int, b: Int) -> Int:
+    return a + b;
+end;
+
+var _ = print("factorial(5) = ");
+var _ = print_line(factorial(5));
+var _ = print("add(17, 25) = ");
+var _ = print_line(add(17, 25));
+
+var _ = print_line("=== 10. len() ===");
+var _ = print("len(hello) = ");
+var _ = print_line(len("hello"));
+var _ = print("len([1,2,3,4]) = ");
+var _ = print_line(len([1, 2, 3, 4]));
+
+var _ = print_line("=== 11. Conversions ===");
+var _ = print("to_string(123) = ");
+var _ = print_line(to_string(123));
+var _ = print("to_int(456) = ");
+var _ = print_line(to_int("456"));
+var _ = print("to_real(42) = ");
+var _ = print_line(to_real(42));
+
+var _ = print_line("=== 12. Fixed-point formatting ===");
+var _ = print("to_string_fixed(3.14159, 2) = ");
+var _ = print_line(to_string_fixed(3.14159, 2));
+
+var _ = print_line("=== 13. String operations ===");
+var _ = print("str_concat: ");
+var _ = print_line(str_concat("Hello, ", "World!"));
+var _ = print("join([a,b,c], -) = ");
+var _ = print_line(join(["a", "b", "c"], "-"));
+
+var _ = print_line("=== 14. Assertions ===");
+asserttrue(1 + 1 == 2, "1 + 1 should equal 2");
+assertfalse(1 > 2, "1 should not be greater than 2");
+asserteq(5 * 5, 25, "5 * 5 should equal 25");
+assertneq(10, 20, "10 should not equal 20");
+var _ = print_line("All assertions passed!");
+
+var _ = print_line("=== Demo Complete ===");

src/interpreter/statement_execute.rs

@@ -327,6 +327,39 @@ pub fn execute(stmt: Statement, env: &Environment<Expression>) -> Result<Computa
             }
         }
 
+        Statement::IfChain {
+            branches,
+            else_branch,
+        } => {
+            for (cond, body) in branches {
+                let value = match eval(*cond, &new_env)? {
+                    ExpressionResult::Value(expr) => expr,
+                    ExpressionResult::Propagate(expr) => {
+                        return Ok(Computation::PropagateError(expr, new_env))
+                    }
+                };
+                match value {
+                    Expression::CTrue => {
+                        return match *body {
+                            Statement::Block(stmts) => execute_if_block(stmts, &new_env),
+                            _ => execute(*body, &new_env),
+                        };
+                    }
+                    Expression::CFalse => continue,
+                    _ => return Err("Condition must evaluate to a boolean".to_string()),
+                }
+            }
+            // No branch matched, try else
+            if let Some(else_stmt) = else_branch {
+                match *else_stmt {
+                    Statement::Block(stmts) => execute_if_block(stmts, &new_env),
+                    _ => execute(*else_stmt, &new_env),
+                }
+            } else {
+                Ok(Computation::Continue(new_env))
+            }
+        }
+
         Statement::Block(stmts) => {
             // new_env.push(); <- removing push()
             let result = execute_block(stmts, &new_env);