Anonyme Funktioner
Teori
Anonyme funktioner er funktioner uden navn og forbindes ofte med det funktionelle programmeringsparadigme. De kan gemmes i variabler (som i første eksempel nedenfor) eller bruges som input til andre funktioner (som i sidste eksempel nedenfor). I nogle sprog (fx Python) er anonyme funktioner også kendt som Lambda funktioner.
I eksemplet nedenfor (fra [1]) sammenlignes en alm. funktion (dog skrevet på kun 1 linje) med 3 måder at skrive en anonym funktion.
fn add_one_v1 (x: u32) -> u32 { x + 1 } // fn
let add_one_v2 = |x: u32| -> u32 { x + 1 }; // Parametre angives mellem | |. Bemærk let og ;
let add_one_v3 = |x| { x + 1 }; // Angivelse af datatyper kan undlades.
let add_one_v4 = |x| x + 1 ; // Hvis funktionen kun består af 1 sætning/linje, så kan { } undlades.
println!("{}", add_one_v3(10));
println!("{}", add_one_v4(10));Anvendelse med iterator
Anonyme funktioner bruges ofte til at skrive ens kode kortere eller mere kompakt, fx sammen med Iterator. Nedenstående to eksempler (fra [1]) giver samme resultat.
Hvad der er nemmest at læse afhænger både af erfaring og præference. Effektivitet vil ofte være det samme, se [1] sektion 13.4.
Uden anonym funktion
let v1 = vec![1, 2, 3];
let mut v2 = Vec::new();
for x in v1 {
v2.push(x + 1);
}
println!("{:?}", v2);Med iterator og anonym funktion
let v1 = vec![1, 2, 3];
let v2: Vec<i32> = v1.iter().map(|x| x + 1).collect();
println!("{:?}", v2);Indfange værdier og ejerskab
Anonyme funktioner kan indfange variablerne fra det område hvor de defineres. Det kan gøres på de samme tre måder som funktionsparametre kan angives: (1) overtagelse af ejerskab, (2) mutabel reference eller (3) reference. Dette sker automatisk baseret på hvordan variablerne bruges i den anonyme funktion.
De anonyme funktioner vil dermed opfylde 1, 2 eller alle 3 af følgende kategorier i stigende rækkefølge (så Fn overholder også altid FnMut):
FnOnce: Kan kaldes min. 1 gang. (Gælder altid.)FnMut: Kan kaldes mere end 1 gang. Ændrer måske de indfangede variabler.Fn: Foretager ingen flytning af ejerskab eller mutation af de indfangede variabler.
Den anonyme funktion kan tvinges til at tage ejerskab vha. nøgleordet move hvilket ofte bruges i forbindelse med tråde.
I første eksempel indfanger den anonyme funktion f en mutabel reference til vektoren v og bliver dermed kategoriseret som FnMut. Den kan derfor uden problemer bruges i den sidste for_each (som kræver at funktionen tilhører kategorien FnMut).
Hvis vi brugte move for f ville det give problemer, men dog først på sidste linje hvor vektoren v ikke længere ville eksistere (da ejerskabet er overgået til f).
let mut v = vec![1, 2, 3];
let mut f = || v.iter_mut().for_each(|x| *x += 1);
(0..5).for_each(|_| f());
println!("{:?}", v);I nedenstående eksempel går det galt. Her er den anonyme funktion f kategoriseret som FnOnce da ejerskabet af vektoren v flyttes til variablen v2 inde i den anonyme funktion. Den kan derfor kun kaldes en enkelt gang og vil give en fejl ved den sidste for_each som stadig kræver at funktionen tilhører kategorien FnMut.
let v = vec![1, 2, 3];
let f = || { let v2 = v; };
(0..5).for_each(|_| f());
println!("{:?}", v);