Funciones

Funciones Básicas¶

fn greet(name: str) -> str {
    "Hello, {name}!"
}

fn add(a: int, b: int) -> int {
    a + b   // retorno implícito — la última expresión es el valor devuelto
}

Retorno Explícito¶

fn absolute(x: int) -> int {
    if x < 0 {
        return -x
    }
    x
}

Sin Tipo de Retorno¶

Las funciones que no devuelven un valor omiten el -> Type:

fn say_hello(name: str) {
    print("Hello, {name}!")
}

Parámetros¶

Anotaciones de Tipo¶

fn process(x: int, y: f64, name: str) -> str {
    "{name}: {x}, {y}"
}

Argumentos con Nombre¶

fn create_user(name: str, age: int, email: str) -> User {
    User { name, age, email }
}

// Call with named arguments
create_user(name: "Alice", age: 30, email: "[email protected]")

Valores por Defecto¶

Los parámetros pueden tener valores por defecto en campos de struct y patrones builder.

Lambdas y funciones anónimas¶

Las lambdas usan la sintaxis |params| expr:

// Single expression
let double = |x| x * 2
let add = |a, b| a + b

// With type annotations
let square = |x: int| -> int { x * x }

// Multi-line body
let process = |x: int| -> int {
    let y = x * 2
    y + 1
}

Las funciones anónimas capturan variables¶

let multiplier = 3
let multiply = |x| x * multiplier  // captures `multiplier`
print(multiply(5))  // 15

Funciones de Orden Superior¶

Las funciones pueden recibir funciones como parámetros y devolver funciones:

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

fn make_adder(n: int) -> fn(int) -> int {
    |x| x + n
}

let add5 = make_adder(5)
print(add5(10))  // 15

Métodos¶

Los métodos se definen dentro de bloques impl. Consulta Estructuras de Datos para más detalles.

struct Circle {
    radius: f64,
}

impl Circle {
    fn area(self) -> f64 {
        3.14159 * self.radius * self.radius
    }

    fn new(radius: f64) -> Circle {
        Circle { radius }
    }
}

let c = Circle { radius: 5.0 }
print(c.area())

Decoradores¶

Las funciones pueden anotarse con decoradores:

@test
fn test_addition() {
    assert_eq(2 + 2, 4, "basic addition")
}

@memoize
fn fibonacci(n: int) -> int {
    if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) }
}

@deprecated("use new_function() instead")
fn old_function() {
    // ...
}

Consulta Decoradores para la lista completa.