Polish guide docs

Author: Folyd

docs/guide/language/closure-lambda.md

@@ -7,7 +7,7 @@ AIScript treats functions as first-class citizens, enabling powerful functional
 A closure is a function that captures and remembers the environment in which it was created. This means it can access variables from its enclosing scope, even after that scope has completed execution.
 
 ```js
-fn create_counter(start: int) -> fn() -> int {
+fn create_counter(start: int) {
     let count = start;
 
     fn increment() -> int {
@@ -53,10 +53,6 @@ print(squared); // [1, 4, 9, 16, 25]
 // Filter example
 let even_numbers = filter(numbers, |n| n % 2 == 0);
 print(even_numbers); // [2, 4]
-
-// Reduce example
-let sum = reduce(numbers, |acc, n| acc + n, 0);
-print(sum); // 15
 ```
 
 ## Capturing Variables
@@ -87,7 +83,7 @@ print(increment()); // 2
 print(counter);     // 2 (affected by the closure)
 ```
 
-### 3. Multiple Captures
+<!-- ### 3. Multiple Captures
 
 Closures can capture multiple variables from different scopes:
 
@@ -106,9 +102,9 @@ let math = create_math_functions(10);
 print(math.add(5));      // 15
 print(math.multiply(5)); // 10
 print(math.combined(5)); // 30
-```
+``` -->
 
-## Partial Application
+<!-- ## Partial Application
 
 Use closures to create partially applied functions:
 
@@ -126,7 +122,7 @@ let goodbye = partial(greet, "Goodbye");
 
 print(hello("Alice"));  // "Hello, Alice!"
 print(goodbye("Bob"));  // "Goodbye, Bob!"
-```
+``` -->
 
 ## Immediate Invocation
 
@@ -142,39 +138,6 @@ let result = |x, y| {
 print(result); // 19 (sum: 7, product: 12)
 ```
 
-## Closures with Error Handling
-
-Closures can use AIScript's error handling mechanisms:
-
-```js
-enum MathError! {
-    DivisionByZero,
-    Overflow,
-}
-
-let safe_divide = |a, b| -> float | MathError! {
-    if b == 0 {
-        raise MathError!::DivisionByZero;
-    }
-    return a / b;
-};
-
-let result = safe_divide(10, 2) |err| {
-    match err {
-        MathError!::DivisionByZero => {
-            print("Cannot divide by zero");
-            return 0.0;
-        },
-        _ => {
-            print("Unknown error");
-            return 0.0;
-        }
-    }
-};
-
-print(result); // 5.0
-```
-
 ## Recursion with Closures
 
 Closures can call themselves recursively:
@@ -200,7 +163,7 @@ print(factorial(5)); // 120
 Closures are ideal for event-driven or asynchronous programming:
 
 ```js
-fn fetch_data(url: str, on_success: fn(data: str), on_error: fn(error: str)) {
+fn fetch_data(url: str, on_success, on_error) {
     // Simulating an async operation
     if url.starts_with("https") {
         on_success("Data from {url}");
@@ -216,6 +179,13 @@ fetch_data(
 );
 ```
 
+:::danger
+AIScript current doesn't support `fn` as type annotation.
+```rs
+fn fetch_data(url: str, on_success: fn(data: str), on_error: fn(error: str)) {}
+```
+:::
+
 ## Performance Considerations
 
 While closures provide powerful abstractions, they have memory implications since they maintain references to their captured environment. Consider these best practices:
@@ -224,69 +194,4 @@ While closures provide powerful abstractions, they have memory implications sinc
 2. **Be mindful of memory**: Large closures with many captures may impact performance
 3. **Consider alternatives**: For simple cases, regular functions might be more efficient
 
-## Practical Examples
-
-### Data Transformations
-
-```js
-// Composing transformations
-let process_data = |data| {
-    return data 
-        |> map(|x| x * 2)
-        |> filter(|x| x > 10)
-        |> reduce(|acc, x| acc + x, 0);
-};
-
-print(process_data([2, 8, 5, 10])); // 36 (8*2 + 10*2 = 16 + 20)
-```
-
-### Configuration Builder
-
-```js
-fn create_config_builder() -> fn {
-    let config = {
-        host: "localhost",
-        port: 8080,
-        debug: false,
-        timeout: 30,
-    };
-    
-    return |key, value| {
-        config[key] = value;
-        return config;
-    };
-}
-
-let builder = create_config_builder();
-let config = builder("host", "example.com")("port", 443)("debug", true);
-print(config); // {host: "example.com", port: 443, debug: true, timeout: 30}
-```
-
-### Memoization
-
-```js
-fn memoize(func) -> fn {
-    let cache = {};
-    
-    return |arg| {
-        if arg in cache {
-            return cache[arg];
-        }
-        
-        let result = func(arg);
-        cache[arg] = result;
-        return result;
-    };
-}
-
-let fibonacci = memoize(|n| {
-    if n <= 1 {
-        return n;
-    }
-    return fibonacci(n - 1) + fibonacci(n - 2);
-});
-
-print(fibonacci(30)); // Fast calculation due to memoization
-```
-
 Closures and lambdas are fundamental to many modern programming patterns, from functional programming to asynchronous workflows. By mastering these concepts in AIScript, you'll be able to write more concise, maintainable, and powerful code.