Closure Rust - Cont…
FnMut Trait
This is a continuation of the previous post ( https://naveendavisv.blogspot.com/2019/05/what-is-closures-how-can-it-be-used-in.html) on closures in rust.Last post we defined the closures as Fn(i32) -> i32 when we want to pass the closure to a function.
Fn trait borrows values from the environment immutably.
But now we will see what is FnMut? .
FnMut can change the environment because it mutably borrows values.
fn double(mut db1:T)
where T:FnMut() -> i32 {
println!("{:?}",db1());
}
fn main() {
let mut x = 10;
let db = || { x*=2; x};
double(db);
println!("{:?}",x);
}
If we want to change a value in the environment that closure is enclosing, the FnMut trait can be used to define the closure.
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=5102dff068bc256a59bc9c8c9bf3f92f
Cacher struct with closure.
We will try to build a Cacher Structure as explained in the rust book - https://doc.rust-lang.org/book/ch13-01-closures.htmlThe need for Cacher structure is explained in the book.
Final part of Cacher structure chapter , the author ask us to create the struct with HaspMap to store the calculated value
I will try to explain the Code wrote in Rust here.
How nice would it be if we can cache the computation intensive function and store it's calculated values in a struct !!
A data structure with a 'Closure' and 'Hashmap' will serve the purpose very nicely.
How do we define Cacher Structure with HashMap ?
We can call data structure as Cacher as it cache/store the result values.Normally we don’t define the parameter type or return type of a Closure in Rust. But it is must to explicitly declare the field types of a Struct , so we need to explicitly define the 'T' where T is type of the Closure .Rust Compiler needs to understand all the field types of structures in order to allocate memory
resultMap field is Box (A pointer type for heap allocation - https://doc.rust-lang.org/std/boxed/struct.Box.html) reference to Hashmap.
If you don’t know how much memory you are going to use, one option would be “Box” type. Here we defined the field resultMao as Box reference to a HaspMap .
struct Cacher
where T:Fn(u32) -> u32
{
square:T,
resultMap:Box>,
}
How do we implement the Cacher Struct ?
We defined the Cacher Struct , the next step would be we need to implement the Struct with methods.one method that we would require is “new” . This method creates Objects of the Struct. Another one would be “value” - to get the value from the resultMap. As resultMap is reference to a HashMap , we can use “insert” method to add key and value pairs to the hashmap.
Also we can use “get” method to get a value for a key from the haspmap.
impl Cacher
where T:Fn(u32) -> u32{
fn new(square:T,mut resultMap: HashMap) -> Cacher{
Cacher{
square,
resultMap:Box::new(resultMap),
}
}
fn value(&mut self,x:u32) -> u32 {
match self.resultMap.get(&x){
Some(v) => *v,
None => {
let v = (self.square)(x);
self.resultMap.insert(x,v);
v
},
}
}
}
