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
}

Condiciones de entrada y retorno¶

Una actualización de inventario debe comprobar la cantidad solicitada y el saldo restante. Use requires para las condiciones de entrada y ensures para el valor devuelto, accesible mediante el nombre result.

// A checkout must conserve the requested quantity and never overdraw stock.
fn remaining_stock(available: int, requested: int) -> int
    requires available >= 0
    requires requested >= 0 && requested <= available
    ensures result >= 0 && result + requested == available
{
    if requested == 0 { return available }
    available - requested
}

let remaining = remaining_stock(12, 5)
assert(remaining == 7)
assert(remaining_stock(12, 0) == 12)
print("Remaining stock: {remaining}")

Las condiciones deben ser booleanas y se ejecutan una vez por llamada, en el orden escrito. Escriba todos los requires antes de los ensures. Una condición falsa genera un error con la función, la expresión y la ubicación en el código.

El retorno final, return y ? pasan por la misma comprobación, después de la limpieza del cuerpo. Result::Err es un retorno normal; panic y fallo de tarea no ejecutan las poscondiciones. En async fn, result es el valor completado y la comprobación termina antes de que se complete el Future.

Las condiciones pueden leer parámetros y variables del ámbito exterior, pero no variables locales del cuerpo. Los métodos y métodos de trait con cuerpo aceptan contratos. Las declaraciones sin cuerpo y los generators se rechazan. Las funciones asíncronas con contratos no se ejecutan en comptime.

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: "alice@example.com")

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.

Ejemplos y referencia relacionados¶

Parámetros de funciones y lambdas