Impossibile passare la chiusura come parametro

Question

Sto imparando Rust in questo momento e sembra che non sia possibile specificare una chiusura come parametro di funzione. Ecco quello che ho:

fn foo(a: i32, f: |i32| -> i32) -> i32 { 
    f(a) 
} 

fn main() { 
    let bar = foo(5, |x| { x + 1 }); 
    println!("{}", bar); 
} 

ottengo il seguente errore:

foo.rs:1:19: 1:20 error: expected type, found `|` 
foo.rs:1 fn foo(a: i32, f: |i32| -> i32) -> i32 { 

Va bene, quindi non mi piaceva la sintassi di chiusura. Questo è un po 'fastidioso, perché ora devo scrivere questo:

fn foo(a: i32, f: Box<Fn(i32) -> i32>) -> i32 { 
    f(a) 
} 

fn main() { 
    let bar = foo(5, Box::new(|x| { x + 1 })); 
    println!("{}", bar); 
} 

Allora, che sta succedendo? Ho letto in alcuni numeri diversi places che il primo esempio è valido, quindi questa sintassi del "parametro tipo di chiusura" è stata rimossa o sto facendo qualcosa di sbagliato?

Answer 1

La ruggine è stata sviluppata all'aperto sin dall'inizio e il linguaggio si è evoluto molto da allora. L'articolo Stack Overflow a cui stai collegando ha quasi 1 anno di età, che in tempo di arrugginimento pre-1.0 è lungo come una vita ... (pun intended)

La risposta più semplice sarebbe: tieni presente che un sacco di articoli, post di blog, risposte SO ... non sono più rilevanti perché la lingua è cambiata. Se provi una soluzione e non funziona, trova la sintassi più recente (come hai fatto!) E prosegui.

In questo caso specifico, this RFC documenta la modifica da |...| -> ... a Fn/FnMut/FnOnce(...) -> ....

A proposito, c'è un piano per uno sforzo comunitario per trovare articoli obsoleti e contrassegnarli esplicitamente come deprecati, in modo che questo particolare problema sia evitato. Non riesco a trovare il collegamento ad esso, però.

Answer 2

Se qualcuno è interessato a questa domanda oggi, ecco la sintassi con i generici:

fn foo<F: Fn(i32) -> i32>(a: i32, f: F) -> i32 { 
    f(a) 
} 

fn main() { 
    let bar = foo(5, |x| { x + 1 }); 
    println!("{}", bar); 
} 

Oppure, usando tratto oggetti:

fn foo(a: i32, f: Box<Fn(i32) -> i32>) -> i32 { 
    f(a) 
} 

fn main() { 
    let bar = foo(5, Box::new(|x| { x + 1 })); 
    println!("{}", bar); 
} 

si dovrebbe preferire il primo.