Closures in Rust
Closure is record storing a function along with it environment variables. You can read about closures in wiki
Difference between Closure and a function.
function definition:
Note: we have to explicitly pass the type and variable.
fn add (x:u32) -> u32 { x +1 }
Closure definition in Rust:
Note: We can follow any one of the following syntax to define a Closure
//explicitly defining types
let add = |x:u32| -> u32 { x +1 }
or
//the compiler dynamically type the Closure variables
let add = |x| -> {x+1}
or
//ignoring curly braces if you have only one statement
let add = |x| -> x+1
We will go through some example for Closure and discuss its features
Example#1 - passing Closure to a function
Below example shows the closure is defined with parameter ’ x ’ passed from environment where it is called. Closure is enclosed in a variable called square_x here.
We can see that value of the variable x is 2 . In the main program, first we define the Closure and then it is called from square_x(x) in println! statement.
square_x is the Closure.
When Closure looks for it's required variable's 'x' value for calculation, Closure its self will be enclosed with its required variables and understand that 'x' is parameter and it need to get its value from lexical environment which is 2 . And it perform the calculation: x*x - square of 2 which is 4.
The second print statement execute inside the function square . When we call the square(square_x) function, Closure invoked and looks for its lexical environment and find the value for parameter ‘x’ variable.The ‘x’ variable value is 3 over there, so the Closure calculate the square of 3 which is 9 .
fn square<T>(sq:T)
where T:Fn(i32) -> i32
{
let x = 3;
println!("square called from insidefn value = {}",sq(x));
}
fn main() {
let mut x = 2;
let square_x = |x| x*x;
println!("square of x = {}",square_x(x));
square(square_x);
}
From what we learned , Closure doesn’t need to specify it’s Parameters type or Return type. But in the (square) function definition, we explicitly defined ‘T’ as Fn(i32) -> i32.
Because for a function, it is necessary to define it's parameters type.
run in Rust Playground -
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=c7dafb2aa3b7f7f83fc7490be6f30925
Example 2 # What will happen if we are not passing variable
This example we remove the passing parameter, to make the Closure as no-parameters.
let sq = || x*x;
But Closure has the property to get all its variables from its lexical environment . When you pass it to a function, it actually pass the Closure and along with variables enclosed.
fn square<T>(sq:T)
where T:Fn() -> i32
{
let x = 3;
println!("square called from insidefn value = {}",sq());
}
fn main() {
let x = 2;
let square_x = || x*x;
println!("square of x = {}",square_x());
square(square_x);
}
Example 3- What will happen if you pass different variable to Closure in the above example
fn square<T>(sq:T)
where T:Fn(i32) -> i32
{
let x = 3;
println!("square called from insidefn value = {}",sq(x));
}
fn main() {
let x = 2;
let square_x = |y| x*x;
square(square_x);
println!("square of x = {}",square_x(x));
}
Can you guess the output ?Hint : Closure is record which stores function along with its environment variables.
run the example above and check out the output.
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=7763c76893f87426f975db3eafab5e0f
https://doc.rust-lang.org/book/ch13-00-functional-features.html
