Difference between revisions of "Rust-Programming-Language/C2/Iterators-and-Closures/English"

Learning Objectives

• Iterators
• Types of Iterators
• Closures

System Requirements To record this tutorial I’m using

Code Files

• The following code file is required to practise this tutorial.
• iterators.rs
• This file is provided in the Code Files link of this tutorial page.

Iterators

• Iterators are powerful and flexible tools.
• They process sequences of data one at a time.
• They help to iterate over a collection of values such as arrays, vectors, maps, etc.

Type of Iterators

• Basic & Range Iterators
• Iterator Adapters and
• Iterator Consumers/Collectors

Let’s learn about Basic and Range Iterators with an example.

Type the command cargo new iterators and press Enter.

Open the created project as shown.

let numbers = vec![1, 2, 3];

let mut iter = numbers.iter();

println!("{:?}", iter.next()); // Some(1)

println!("{:?}", iter.next()); // Some(2)

println!("{:?}", iter.next()); // Some(3)

println!("{:?}", iter.next()); // None

}

numbers.iter() method creates an iterator named iter.

iterator can safely access vector elements without looping.

next() method is used to traverse through the items.

It returns a value None when it reaches the end of the collection.

Save the program.

Clear the previous code.

Copy paste the code from the code file.

let numbers = vec![1, 2, 3, 4, 5];

let squared: Vec<i32> = numbers

.iter()

.map(|x| x * x)

.collect();

println!("{:?}", squared); // [1, 4, 9, 16, 25]

}

We then create an iterator using the .iter() method.

It gives us immutable references to each element in the vector.

.map() method uses a closure that takes each element x and returns its square

This doesn't immediately compute the square.

It builds a new iterator pipeline that knows how to compute them when needed.

Finally, .collect() consumes the iterator and gathers the squares into a new vector

The result is printed as a new vector [1, 4, 9, 16, 25]

These methods consume an iterator and return results like Vec, bool, or a single value.

let numbers = vec![1, 2, 3, 4, 5, 6];

let evens: Vec<_> = numbers

.iter()

.filter(|x| *x % 2 == 0)

.collect();

println!("{:?}", evens); // [2, 4, 6]

}

Filter() method which takes a closure that returns true or false for each element.

The condition that we’ve used here will check if the number is even or not.

Only the elements that satisfy this condition are passed forward in the iterator pipeline.

Lastly, .collect() method gathers the remaining elements into new vector evens.

Save the program.

The result is [2, 4, 6], it contains only even numbers from the original list.

Closures

• In Rust, closure is a function without names
• It can capture variables from its environment, which is a key difference from regular functions.

• Closure is a function without names
• It can capture variables from its environment, which is a key difference from regular functions.

Switch back to the visual code editor.

Clear the window and copy and paste the code from the codefile.

// define a closure and store it in a variable

let add_one = |x: i32| x + 1;

// call closure and store the result in a variable

let result = add_one(2);

println!("Result = {}", result);

}

We have defined a closure and binded it to the add_one variable.

We then call the closure with add_one(2) and bind the return value to the result variable.

Closures can omit type annotations and return types, as Rust is capable of type inference

Save the program.

// define a multi-line closure

let squared_sum = |x: i32, y: i32| {

// find the sum of two parameters

let mut sum: i32 = x + y;

// find the squared value of the sum

let mut result: i32 = sum * sum;

return result;

};

// call the closure

let result = squared_sum(5, 3);

println!("Result = {}", result);

}

First we calculate the sum of two parameters.

Then we find the squared value of the sum.

Save the program.

We can see the output as 64.

That is the sum of 5 and 3 is 8. The squared value is 64.

Let us summarize.

• Write a Rust program that takes a vector of integers:

let numbers = vec![10, 15, 20, 25, 30, 35, 40];

• Using iterators, perform the following steps:

• • Filter out the numbers that are divisible by 10
  • Collect the result into a new vector.
  • Finally, print the resulting vector.

• Write a Rust program that takes a vector of integers:
• Using iterators, perform the following steps: