FnOnce, FnMut y Fn: los tres traits del closure

Un closure no implementa un trait único: implementa el conjunto de tres —FnOnce, FnMut, Fn— que su comportamiento le permite. La distinción no es burocrática. Marca cuántas veces se puede llamar, si al llamarlo cambia su estado interno, y si puede correr en paralelo. Y no la eliges tú: la deduce el compilador mirando qué hace el cuerpo con lo que capturó. Un closure que solo lee es tan flexible como se puede ser; uno que consume lo capturado, tan rígido como que solo sirve una vez. Aprender a leer esos tres traits es aprender a leer el contrato de cualquier función de orden superior en Rust.

Tres traits, tres receptores

Los tres traits describen tres maneras de invocar un valor llamable, y se diferencian en cómo toman self:

// Firmas conceptuales de la biblioteca estandar:
trait FnOnce<Args> {
    type Output;
    fn call_once(self, args: Args) -> Self::Output;      // consume el closure
}
trait FnMut<Args>: FnOnce<Args> {
    fn call_mut(&mut self, args: Args) -> Self::Output;  // presta mutable
}
trait Fn<Args>: FnMut<Args> {
    fn call(&self, args: Args) -> Self::Output;          // presta compartido
}

Léelos por el receptor, que lo dice todo:

• FnOnce toma self por valor: llamarlo consume el closure, así que solo se garantiza una invocación. Es lo que permite mover fuera lo capturado.
• FnMut toma &mut self: puede llamarse muchas veces, y cada llamada puede mutar el estado capturado.
• Fn toma &self: puede llamarse muchas veces desde referencias compartidas y solo lee lo capturado; nunca lo altera.

La jerarquía: quien puede más, puede menos

Fíjate en los : de las firmas: Fn es subtrait de FnMut, que a su vez es subtrait de FnOnce. Esto codifica una relación de inclusión:

Todo closure que implementa Fn implementa también FnMut y FnOnce. Todo FnMut implementa FnOnce. La flecha va de lo más capaz a lo más general.

Tiene sentido operacional: si puedes llamar algo a través de &self (Fn), también puedes a través de &mut self (FnMut, porque de un &mut sacas un &) y también consumiéndolo una vez (FnOnce). Lo contrario no vale: un closure que consume lo capturado no se puede llamar dos veces, así que no es FnMut ni Fn.

flowchart TB
fn[Fn con and self solo lee] -->|implica| fnmut[FnMut con and mut self muta]
fnmut -->|implica| fnonce[FnOnce con self consume]
fn -.->|se puede llamar N veces| usos1[Muchas invocaciones]
fnonce -.->|se puede llamar 1 vez| usos2[Una sola invocacion]
style fn fill:#a6e3a1,color:#11111b
style fnmut fill:#89b4fa,color:#11111b
style fnonce fill:#fab387,color:#11111b

Cómo el compilador decide

No hay palabra clave que asigne un trait. El compilador clasifica el closure por lo que su cuerpo hace con las capturas, siguiendo la misma lógica de captura de la lección anterior:

let saludo = String::from("hola");

// Solo LEE saludo  ->  implementa Fn, FnMut y FnOnce
let leer = || println!("{saludo}");

// MUTA saludo      ->  implementa FnMut y FnOnce (no Fn)
let mut anadir = || saludo.push('!');

// CONSUME saludo   ->  implementa solo FnOnce
let consumir = || { let s = saludo; s.len() };

La regla es directa:

• Si el cuerpo solo lee las capturas → el closure es Fn (y por herencia FnMut y FnOnce).
• Si muta alguna captura → es FnMut (y FnOnce), pero no Fn.
• Si mueve fuera alguna captura, o requiere posesión → es FnOnce y nada más.

El closure obtiene siempre el trait más capaz que su cuerpo justifique. Uno que solo lee cae en la cúspide (Fn); uno que consume, en el suelo (FnOnce).

Del otro lado: qué trait exigir

Cuando escribes una función que recibe un closure, eliges el bound. Y aquí la jerarquía se invierte en intuición: el trait más débil —FnOnce— es el que más closures acepta, porque todos lo implementan. El más fuerte —Fn— es el más exigente.

// La llamo una sola vez: pido FnOnce, acepto cualquier closure.
fn una_vez<F: FnOnce() -> String>(f: F) -> String { f() }

// La llamo repetidamente y toleran mutacion: pido FnMut.
fn repite<F: FnMut()>(mut f: F) { f(); f(); f(); }

// Necesito llamarla desde &self, quiza en paralelo: pido Fn.
fn comparte<F: Fn(i32) -> i32>(f: &F) -> i32 { f(1) + f(2) }

La regla de diseño: pide el trait más permisivo que tu uso tolere. ¿La llamas una vez? FnOnce. ¿Muchas veces y no te importa que mute? FnMut. ¿Necesitas invocarla solo con &self —para compartirla entre hilos o llamarla de forma reentrante—? Solo entonces Fn. Exigir Fn cuando bastaba FnOnce rechaza sin motivo closures perfectamente válidos.