Closures & Iterators

fn main() {
    let add_one = |x: i32| x + 1;          // types written out
    let square = |x| x * x;                // types inferred from first use
    let tax_rate = 0.2;
    let with_tax = |price: f64| price * (1.0 + tax_rate); // captures tax_rate

    println!("{}", add_one(4));
    println!("{}", square(7));
    println!("{:.2}", with_tax(50.0));

    let greet = |name: &str| {
        let msg = format!("Hi, {}", name);
        msg.len()
    };
    println!("{}", greet("Ferris"));
}

fn apply<F: Fn(i32) -> i32>(f: F, v: i32) -> i32 {
    f(v)
}

fn repeat<F: FnMut()>(mut f: F, times: u32) {
    for _ in 0..times {
        f();
    }
}

fn consume<F: FnOnce() -> String>(f: F) -> String {
    f()
}

fn main() {
    let offset = 10;
    println!("{}", apply(|x| x + offset, 5));      // Fn: reads offset

    let mut count = 0;
    repeat(|| count += 1, 3);                       // FnMut: changes count
    println!("count = {}", count);

    let name = String::from("report.csv");
    let taken = consume(move || name);              // FnOnce: gives name away
    println!("{}", taken);
}

fn make_multiplier(factor: i32) -> impl Fn(i32) -> i32 {
    move |x| x * factor   // factor would die at the end of this fn without move
}

fn make_counter() -> impl FnMut() -> u32 {
    let mut n = 0;
    move || {
        n += 1;
        n
    }
}

fn main() {
    let double = make_multiplier(2);
    let triple = make_multiplier(3);
    println!("{} {}", double(5), triple(5));

    let mut next_id = make_counter();
    println!("{} {} {}", next_id(), next_id(), next_id());
}

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());

    // Adapters are lazy: this closure has not run yet.
    let noisy = v.iter().map(|x| {
        println!("mapping {}", x);
        x * 2
    });
    println!("nothing mapped yet");
    let doubled: Vec<i32> = noisy.collect(); // now it runs
    println!("{:?}", doubled);
}

fn main() {
    let scores = vec![72, 95, 58, 88, 64, 99];

    let passed: Vec<i32> = scores.iter().copied().filter(|s| *s >= 65).collect();
    println!("passed: {:?}", passed);

    for (i, s) in scores.iter().enumerate().skip(1).take(2) {
        println!("#{} = {}", i, s);
    }

    let names = ["ana", "ben", "cy"];
    let ages = [31, 25, 40];
    let pairs: Vec<String> = names
        .iter()
        .zip(ages.iter())
        .map(|(n, a)| format!("{}:{}", n, a))
        .collect();
    println!("{}", pairs.join(", "));

    let all: Vec<i32> = (1..=3).chain(7..=8).rev().collect();
    println!("{:?}", all);
}

use std::collections::BTreeMap;

fn main() {
    let words = vec!["apple", "bob", "avocado", "cat", "banana"];

    let total_len: usize = words.iter().map(|w| w.len()).sum();
    let longest = words.iter().max_by_key(|w| w.len()).unwrap();
    let has_cat = words.iter().any(|w| *w == "cat");
    println!("{} {} {}", total_len, longest, has_cat);

    // fold: start with an accumulator, combine each item into it
    let csv = words.iter().fold(String::new(), |mut acc, w| {
        if !acc.is_empty() { acc.push(','); }
        acc.push_str(w);
        acc
    });
    println!("{}", csv);

    // group by first letter; BTreeMap keeps keys sorted
    let mut by_letter: BTreeMap<char, Vec<&str>> = BTreeMap::new();
    for w in &words {
        by_letter.entry(w.chars().next().unwrap()).or_default().push(*w);
    }
    println!("{:?}", by_letter);

    let parsed: Result<Vec<i32>, _> = ["1", "2", "x"].iter().map(|s| s.parse::<i32>()).collect();
    println!("{}", parsed.is_err());
}

struct Countdown {
    n: u32,
}

impl Iterator for Countdown {
    type Item = u32;

    fn next(&mut self) -> Option<u32> {
        if self.n == 0 {
            None
        } else {
            self.n -= 1;
            Some(self.n + 1)
        }
    }
}

struct Fib {
    a: u64,
    b: u64,
}

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let out = self.a;
        self.a = self.b;
        self.b += out;
        Some(out) // never ends: callers must use take()
    }
}

fn main() {
    for x in (Countdown { n: 3 }) {
        print!("{} ", x);
    }
    println!("liftoff");

    let evens: Vec<u64> = Fib { a: 0, b: 1 }.filter(|x| x % 2 == 0).take(5).collect();
    println!("{:?}", evens);
    let sum: u32 = Countdown { n: 10 }.sum();
    println!("{}", sum);
}