Explain filter method

[Amigo]

fn main() {
    let months = vec!["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];

    let filtered_months = months
        .into_iter()                     
        .filter(|month| month.len() < 5)
        .filter(|month| month.contains("u"))
        .collect::<Vec<&str>>();

    println!("{:?}", filtered_months);
}

1.what happens when calling each method describedabove

[steffahn]

Hi, make sure to take a look at

Forum Code Formatting and Syntax Highlighting

To format code in this forum you need to surround the code with three backticks (```). For example, typing this... ``` fn main() { println!() } ``` ...will be rendered as highlighted Rust code, like so: fn main() { println!() } You can also tell the forum software which language you're using by adding the language after the opening backticks. ```cpp #include <iostream> int main() { std::cout << "Hello World!"; } ``` Will appear with highlighting as: #include <iostream> int main(…

[steffahn]

For general information about iterators, if you like watching a video, I could recommend the following resource:

Crust of Rust: Iterators

[steffahn]

@Amigo

1.what happens when calling each method describedabove

The into_iter method creates an iterator for the vector months.

The filter method wraps the iterator with the Filter iterator adapter. This adapter is an iterator that only returns some of the items returned by the original/wrapped iterator, based on a predicate. It’s basically a struct

struct Filter<I, P> {
    iterator: I,
    predicate: P,
}

that implements Iterator

impl<I, P> Iterator for Filter<I, P>
where
    I: Iterator,
    P: FnMut(&I::Item) -> bool,
{
    type Item = I::Item;
    fn next(&mut self) -> Option<Self::Item> {
        loop {
            match self.iterator.next() {
                None => return None,
                Some(item) if (self.predicate)(&item) => return Some(item),
                _ => continue, // Some(item) not matching predicate
            }
        }
    }
}

This could be used directly as follows

fn main() {
    let months = vec![
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December",
    ];
    
    let months_iterator = months.into_iter();
    let first_filter = Filter {
        iterator: months_iterator,
        predicate: |month: &&str| month.len() < 5
    };
    let second_filter = Filter {
        iterator: first_filter,
        predicate: |month: &&str| month.contains("u")
    };
    let filtered_months = second_filter.collect::<Vec<&str>>();
    
    println!("{:?}", filtered_months);
}

(playground)

Or with a helper function

fn filter<I, P>(iterator: I, predicate: P) -> Filter<I, P>
where
    I: Iterator,
    P: FnMut(&I::Item) -> bool,
{
    Filter {
        iterator,
        predicate,
    }
}

[…]
let filtered_months = filter(
    filter(months.into_iter(), |month| month.len() < 5),
    |month| month.contains("u"),
)
.collect::<Vec<&str>>();

The method Iterator::filter is basically the same as such a helper function, but it supports method-call notation, i.e. iterator.filter(predicate) instead of filter(iterator, predicate).

Finally, collect walks through this iterator (of type “Filter<Filter<vec::IntoIter<&str>, {closure type …}>, {closure type …}>”) and collects all its items into a vector. Writing this manually would look something like

fn collect_vector<I>(mut iterator: I) -> Vec<I::Item>
where
    I: Iterator,
{
    let mut v = vec![];
    while let Some(item) = iterator.next() {
        v.push(item);
    }
    v
}

which could be used as

let filtered_months = collect_vector(filter(
    filter(months.into_iter(), |month| month.len() < 5),
    |month| month.contains("u"),
));

(playground)