El trait Future: un cálculo que aún no ha terminado

La palabra future engaña a quien llega de otros lenguajes. En JavaScript, en Python, en Java, un future o promise es un asa a algo que ya está corriendo en segundo plano: lo creas y la maquinaria arranca sola. En Rust es exactamente lo contrario. Un Future es un valor inerte, la descripción de un cálculo que todavía no ha terminado y que, de hecho, ni siquiera ha empezado. No es una tarea en marcha: es la receta de una tarea, un dato de tamaño conocido en compilación que no ejecuta ni una instrucción hasta que alguien lo sondea. Entender esa inversión —el future como sustantivo perezoso, no como verbo en curso— es la puerta a todo el modelo poll que este nivel abre en canal.

Un future describe; no ejecuta

La primera intuición que hay que desmontar es que llamar a una async fn hace algo. No lo hace. Llamarla construye y devuelve un future, y no corre ni una línea de su cuerpo:

async fn calcular() -> u32 {
    println!("calculando..."); // este println NO se ejecuta al llamar
    40 + 2
}

fn main() {
    let fut = calcular(); // no imprime nada: solo fabrica el future
    // El cuerpo de calcular sigue congelado. Nada ha "empezado".
    let _ = fut; // si nunca lo sondeamos, ese println jamas correra
}

Compáralo con lo que ocurriría en un lenguaje de promises ansiosas, donde escribir calcular() dispararía la ejecución de inmediato y el println aparecería en pantalla. En Rust, calcular() es tan pasivo como escribir vec![1, 2, 3]: has creado un valor, y ahí se queda hasta que alguien lo use. Ese valor tiene un tipo —anónimo, generado por el compilador— que implementa el trait Future, y su cuerpo es código en pausa esperando que lo hagan avanzar.

Da igual de dónde salga el future: siempre es perezoso. Hay tres fuentes, y las tres entregan valores inertes.

async fn una_funcion() -> u32 { 42 }   // 1) una async fn devuelve un future
let un_bloque = async { 40 + 2 };      // 2) un bloque async: igual de perezoso
// 3) implementar Future a mano para un tipo propio (leccion 5 de este nivel)

Ninguna de las tres ejecuta una sola instrucción de su cuerpo al construirse.

La definición del trait: dos líneas, una idea

Despojado de detalles de estabilidad, el trait completo es asombrosamente pequeño:

use std::pin::Pin;
use std::task::{Context, Poll};

pub trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

Dos miembros, y cada uno codifica media teoría. El tipo asociado Output declara qué valor producirá el cálculo cuando termine: para el future de calcular sería u32, para una lectura de socket sería Result<Vec<u8>, io::Error>. Es un tipo asociado, no un genérico, porque cada future concreto produce un tipo de resultado fijo, no una familia: no tiene sentido un future que sea a la vez Future<Output = u32> y Future<Output = String>.

El único método, poll, es el motor: es la pregunta “¿ya has terminado?” que el runtime le hace al future una y otra vez. Su firma tiene tres piezas que este nivel irá abriendo —el receptor Pin<&mut Self>, el Context que transporta el Waker, y el retorno Poll<Self::Output>—; por ahora basta con leer su forma: recibe una referencia a sí mismo y un contexto, y devuelve un Poll, que es un enum con dos variantes, “listo con el valor” o “todavía no”. La lección siguiente lo disecciona símbolo a símbolo.

Perezoso hasta el primer poll

Si el future no ejecuta nada por sí mismo, ¿quién lo mueve? Alguien tiene que conducirlo llamando a poll hasta que devuelva el valor. Ese alguien es el executor del runtime cuando haces spawn, o el .await que lo envuelve: .await es, en esencia, sondear un sub-future en bucle y ceder mientras diga “todavía no”. Un future al que nadie sondea es código muerto.

async fn tarea() {
    let a = paso_uno().await;  // .await sondea el future de paso_uno hasta Ready
    paso_dos(a).await;         // y luego el de paso_dos
}
// Pero tarea() en si tampoco corre sola: hay que entregarsela a un runtime.
// #[tokio::main] o un block_on son quienes hacen el primer poll de todo.

Esta pereza tiene una consecuencia enorme y hermosa: componer futures no ejecuta nada. Cuando encadenas .await, o cuando un combinador construye un future a partir de otros, solo estás anidando descripciones dentro de una descripción mayor, sin tocar el mundo. El árbol entero de llamadas async es un único valor compuesto, inerte, hasta que el runtime hace el primer poll en la raíz. Por eso el modelo escala y por eso la biblioteca estándar puede definir Future sin traer ningún motor: el lenguaje solo fija la forma del cálculo pendiente; ejecutarlo es tarea de una biblioteca externa.

async fn exterior() -> u32 {
    let a = interior_a().await;   // sin runtime que sondee, nada de esto corre
    let b = interior_b().await;
    a + b
}
// exterior() solo CONSTRUYE una maquina que anida las de interior_a e interior_b.
// Ninguna ha empezado: todo aguarda al primer poll de la raiz.

flowchart LR
C[async fn construye el future inerte] --> P[El runtime o un await llama a poll]
P --> Q{El calculo ha terminado}
Q -->|no| PEND[Devuelve Pending la tarea se aparca]
PEND --> P
Q -->|si| R[Devuelve Ready con el valor de tipo Output]
style C fill:#cba6f7,color:#11111b
style PEND fill:#fab387,color:#11111b
style R fill:#a6e3a1,color:#11111b