Iterator

• A type that implements into-iterator is iterable and can be used with for loop syntax.

#![allow(unused)]
fn main() {
pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator
    where
        <Self::IntoIter as Iterator>::Item == Self::Item;

    fn into_iter(self) -> Self::IntoIter;
}
}

• A type that implements iterator is iterator

#![allow(unused)]
fn main() {
trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}
}

iterator can be reterieved from iterable types using the following 3 methods:

• iter() - iterates over &T
• iter_mut() - iterates over &mut T
• into_iter() - iterates over T

iter() and iter_mut() are not the methods of any trait.

Looping with into_iter

    let v1 = vec![1, 2, 3, 4, 5];
    for v in v1 {
        println!("{v}");
    }

    // the following line will give error cause v1 is moved into the loop.
    // loop takes ownership of v1
    // println!("{:?}", v1);

    // same as above
    let v1 = vec![1, 2, 3, 4, 5];
    let mut iter = v1.into_iter();
    while let Some(i) = iter.next() {
        println!("{i}");
    }

Looping with iter

    let v1 = vec![1, 2, 3, 4, 5];
    for v in &v1 {
        println!("{v}");
    }
    // v1 is still valid here cause the loop iterates over &v1
    println!("{v1:?}");
    
    // same as above, but using iter method
    let v1 = vec![1, 2, 3, 4, 5];
    for v in v1.iter() {
        println!("{v}");
    }
    // v1 is still valid here cause the loop iterates over &v1
    println!("{v1:?}");

Looping with iter_mut

    let mut v1 = vec![1, 2, 3, 4, 5];
    for v in &mut v1 {
        *v = *v + *v
    }
    println!("{v1:?}"); // =>  [2, 4, 5, 8, 10]
    
    // same as above but using inter_mut method
    let mut v1 = vec![1, 2, 3, 4, 5];
    for v in v1.iter_mut() {
        *v = *v + *v
    }
    println!("{v1:?}"); // =>  [2, 4, 5, 8, 10]