added return statement support

docs/return_statement.md

@@ -0,0 +1,86 @@
+# The `return` statement
+
+The `return` statement is used to terminate the execution of the innermost enclosing callable (a function or a lambda) and optionally return a value to the caller.
+
+## Basic Usage
+
+By default, Lyng functions and blocks return the value of their last expression. However, `return` allows you to exit early, which is particularly useful for guard clauses.
+
+```lyng
+fun divide(a, b) {
+    if (b == 0) return null // Guard clause: early exit
+    a / b
+}
+```
+
+If no expression is provided, `return` returns `void`:
+
+```lyng
+fun logIfDebug(msg) {
+    if (!DEBUG) return
+    println("[DEBUG] " + msg)
+}
+```
+
+## Scoping Rules
+
+In Lyng, `return` always exits the **innermost enclosing callable**. Callables include:
+*   Named functions (`fun` or `fn`)
+*   Anonymous functions/lambdas (`{ ... }`)
+
+Standard control flow blocks like `if`, `while`, `do`, and `for` are **not** callables; `return` inside these blocks will return from the function or lambda that contains them.
+
+```lyng
+fun findFirstPositive(list) {
+    list.forEach { 
+        if (it > 0) return it // ERROR: This returns from the lambda, not findFirstPositive!
+    }
+    null
+}
+```
+*Note: To return from an outer scope, use [Non-local Returns](#non-local-returns).*
+
+## Non-local Returns
+
+Lyng supports returning from outer scopes using labels. This is a powerful feature for a closure-intensive language.
+
+### Named Functions as Labels
+Every named function automatically provides its name as a label.
+
+```lyng
+fun findFirstPositive(list) {
+    list.forEach { 
+        if (it > 0) return@findFirstPositive it // Returns from findFirstPositive
+    }
+    null
+}
+```
+
+### Labeled Lambdas
+You can explicitly label a lambda using the `@label` syntax to return from it specifically when nested.
+
+```lyng
+val process = @outer { x ->
+    val result = {
+        if (x < 0) return@outer "negative" // Returns from the outer lambda
+        x * 2
+    }()
+    "Result: " + result
+}
+```
+
+## Restriction on Shorthand Functions
+
+To maintain Lyng's clean, expression-oriented style, the `return` keyword is **forbidden** in shorthand function definitions (those using `=`).
+
+```lyng
+fun square(x) = x * x          // Correct
+fun square(x) = return x * x   // Syntax Error: 'return' not allowed here
+```
+
+## Summary
+*   `return [expression]` exits the innermost `fun` or `{}`.
+*   Use `return@label` for non-local returns.
+*   Named functions provide automatic labels.
+*   Cannot be used in `=` shorthand functions.
+*   Consistency: Mirrors the syntax and behavior of `break@label expression`.

docs/tutorial.md

@@ -8,7 +8,7 @@ __Other documents to read__ maybe after this one:
 
 - [Advanced topics](advanced_topics.md), [declaring arguments](declaring_arguments.md), [Scopes and Closures](scopes_and_closures.md)
 - [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
-- [math in Lyng](math.md), [the `when` statement](when.md)
+- [math in Lyng](math.md), [the `when` statement](when.md), [return statement](return_statement.md)
 - [Testing and Assertions](Testing.md)
 - [time](time.md) and [parallelism](parallelism.md)
 - [parallelism] - multithreaded code, coroutines, etc.
@@ -32,6 +32,15 @@ any block also returns it's last expression:
     }
     >>> 6
 
+If you want to exit a function or lambda earlier, use the `return` statement:
+
+    fn divide(a, b) {
+        if( b == 0 ) return null
+        a / b
+    }
+
+See [return statement](return_statement.md) for more details on scoping and non-local returns.
+
 If you don't want block to return anything, use `void`:
 
     fn voidFunction() {