Lambdas y Closures

Forma corta, forma tipada, forma de bloque y lambda sin parámetros (thunk).

// Feature: Anonymous functions (lambdas)

// Syntax: `|a, b| expr` or `|a: T| { ... }` (block body)

// When to use: short callbacks, inline function values,

// functional composition without naming each step.


// Short form: body is a single expression.

let double = |x| x * 2
let add = |a, b| a + b
print(double(5))  // 10

print(add(3, 4))  // 7


// Parameters can be explicitly typed.

let mul: fn(int, int) -> int = |a: int, b: int| a * b
print(mul(6, 7))  // 42


// Block form — multiple lines, requires `return`.

let process = |x: int| {
  let doubled = x * 2
  let plus_one = doubled + 1
  return plus_one
}
print(process(10))  // 21


// Lambdas are values: pass them as arguments.

fn apply(f: fn(int) -> int, x: int) -> int {
  return f(x)
}

print(apply(|n| n * n, 9))  // 81


// Lambda without parameters — useful for a "thunk" (lazy value).

let now = || 42
print(now())  // 42

make_adder, make_formatter — cada closure lleva su propio estado inmutable capturado.

// Feature: Closures — lambdas that capture lexical scope

// Syntax: `|args| body` inside an fn — captures `let`

// and `let mut` that are visible.

// When to use: remember configuration, create functions with

// embedded state, close over local helpers.


use std::Array

// Capturing a constant from the outer scope.

fn make_adder(n: int) {
  return |x| x + n  // captures `n`

}

let add5 = make_adder(5)
let add10 = make_adder(10)
print(add5(3))  // 8

print(add10(3))  // 13


// Each call creates an independent closure.

let addA = make_adder(100)
let addB = make_adder(200)
print(addA(1))  // 101

print(addB(1))  // 201


// Closures can capture multiple variables.

fn make_formatter(prefix: str, suffix: str) {
  return |s| prefix + s + suffix
}

let bracket = make_formatter("[", "]")
let bold = make_formatter("**", "**")
print(bracket("ok"))  // [ok]

print(bold("warning"))  // **warning**


// Closures naturally combine with higher-order.

let nums = [1, 2, 3, 4, 5]
let threshold = 3
let big = nums.filter(|x| x > threshold)
print(big)  // [4, 5]