Expresiones y funciones

Todo vale algo, hasta que le pones un punto y coma

En «Variables, funciones y control de flujo» ya llamaste a una función, boost(), sin nombrar por qué su última línea no llevaba ;. Aquí formalizamos eso: qué es una expresión, qué es una sentencia, y por qué esa diferencia decide si tu función compila o no.

Rust construye casi todo a partir de expresiones: un bloque {}, un if, una llamada a función, todos producen un valor. Una sentencia, en cambio, no produce nada útil. Saber en cuál de los dos casos estás es la base para leer —y escribir— cualquier función Rust con confianza.

Verás cuatro estaciones: funciones y llamadas, parámetros tipados, expresiones frente a sentencias, y las dos formas de devolver un valor.

ENTRADA · llamada6 llega como n
CUERPO · squareexpresión final sin ;
SALIDA · retornovuelve al punto de la llamada

01 / 04FN · LLAMADA · RESULTADO

fn declara una función; llamarla ejecuta su cuerpo

fn nombra un bloque de código para reutilizarlo. Definir una función no la ejecuta: solo lo hace una llamada. Al escribir square(6), Rust salta al cuerpo de square, sustituye n por 6, ejecuta las instrucciones y vuelve con el resultado al punto exacto de la llamada.

Una función no se ejecuta al definirla, solo al llamarla.

lib.rsCompila↗

/// Squares a number. The final expression, with no semicolon, is the
/// return value.
#[must_use]
pub fn square(n: i32) -> i32 {
    n * n
}

// Playground entry point for this example.
fn main() {
    println!("squared: {}", square(6));
}

Resultado

Los parámetros están tipados y siguen un orden

Una función puede recibir varios parámetros, y cada uno declara su propio tipo. power recibe base: i32 y exponent: u32; el orden importa, porque el compilador compara cada argumento con el parámetro en esa posición exacta.

Los tipos de los parámetros, junto con el tipo de retorno, forman la firma de la función: un contrato que el compilador comprueba en cada llamada, no solo al definirla.

lib.rsCompila↗

/// Raises `base` to `exponent`. Each parameter carries its own type;
/// argument order must match the signature.
#[must_use]
pub fn power(base: i32, exponent: u32) -> i32 {
    base.pow(exponent)
}

// Playground entry point for this example.
fn main() {
    println!("power: {}", power(2, 10));
}

Resultado

; convierte una expresión en sentencia

x + 1 es una expresión: produce un valor. Añádele ; y se convierte en una sentencia, que no produce ningún valor útil —vale (), el tipo unidad—. Si esa es la última línea de una función que promete devolver i32, el compilador esperaba i32 y encontró ().

lib.rsNo compila↗

fn plus_one(x: i32) -> i32 {
    x + 1; // ERROR: el `;` convierte la expresión en sentencia
}

fn main() {
    println!("{}", plus_one(5));
}

Resultado

El compilador dice (E0308)

mismatched types. La función promete i32, pero el ; convierte la última línea en una sentencia que vale ().

error[E0308]: mismatched types
--> src/main.rs:2:5
|
1 | fn plus_one(x: i32) -> i32 {
|                        --- expected `i32` because of return type
2 |     x + 1;
|     ^^^^^^- help: remove this semicolon to return this value
|     |
|     expected `i32`, found `()`

La solución es casi siempre esa: quitar el ; de la expresión final.

return sale antes; la expresión final sale al terminar

La expresión final de una función es su valor de retorno implícito. Pero a veces quieres salir antes de llegar al final, y para eso está return. En safe_divide, si b vale cero, return 0 corta la ejecución ahí mismo; si no, el control sigue hasta a / b, la expresión final, que se devuelve sin escribir return.

lib.rsCompila↗

/// Returns early with `return` when dividing by zero; otherwise the tail
/// expression is the implicit return value.
#[must_use]
pub fn safe_divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        return 0;
    }

    a / b
}

// Playground entry point for this example.
fn main() {
    println!("{} {}", safe_divide(10, 2), safe_divide(10, 0));
}

Resultado

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Objetivo

Completa fibonacci para que devuelva el n-ésimo término de la sucesión (0-indexado: fibonacci(0) == 0).

Implementa

Sustituye `todo!` por un bucle `for` que actualice dos variables en cada vuelta.

Usa dos variables mutables que avanzan una posición en cada vuelta del bucle y devuelve la primera al terminar.

/// Returns the n-th Fibonacci number (0-indexed: fibonacci(0) == 0).
pub fn fibonacci(n: u32) -> u64 {
    todo!("iterate n times, swapping a and b to compute the n-th Fibonacci number")
}

Comprueba

Ejecuta los casos visibles y usa el diagnóstico para corregir el código.

Pruebas visibles

produce los primeros términos y el décimo término correctos

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta pistas progresivas o compara con la solución.

Solución comentadaSolución↗

/// Returns the n-th Fibonacci number (0-indexed: fibonacci(0) == 0).
#[must_use]
pub fn fibonacci(n: u32) -> u64 {
    let (mut a, mut b) = (0u64, 1u64);

    for _ in 0..n {
        let next = a + b;
        a = b;
        b = next;
    }

    a
}

// Playground entry point for this example.
fn main() {
    println!("{}", fibonacci(10));
}

Resultado

Resumen

fn declara una función; llamarla ejecuta su cuerpo, definirla no.
Cada parámetro tiene su propio tipo; junto con el tipo de retorno forman la firma de la función.
Una expresión produce un valor; un ; de más la convierte en una sentencia que vale ().
Un error E0308 con expected T, found () casi siempre significa un ; sobrante en la expresión final.
La expresión final de una función es su retorno implícito; return sirve para salidas anticipadas.
El tipo unidad () no ocupa memoria: es el valor por defecto cuando una función no devuelve nada útil.

Fuentes

The Rust Programming Languagech03-03 · Klabnik, Nichols, Krycho y la comunidad de Rust
Comprehensive Rustvariable_bindings/functions · Geisler y colaboradores (Google)
D3capitulo-3
Rust by Examplefn

Todo vale algo, hasta que le pones un punto y coma

Calcula el n-ésimo término de Fibonacci de forma iterativa.

Implementa

Calcular Fibonacci iterativamente

Comprueba

Ayuda

Resumen

Fuentes