typetui 0.2.0

fn iterator_basics() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();
    
    for val in v1_iter {
        println!("Got: {}", val);
    }
}

fn iterator_adaptors() {
    let v1: Vec<i32> = vec![1, 2, 3];
    
    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
    println!("{:?}", v2);
    
    let sum: i32 = v1.iter().sum();
    println!("Sum: {}", sum);
    
    let evens: Vec<_> = v1.iter().filter(|x| *x % 2 == 0).collect();
    println!("Evens: {:?}", evens);
    
    let first_even = v1.iter().find(|x| *x % 2 == 0);
    println!("First even: {:?}", first_even);
}

fn consuming_adaptors() {
    let v = vec![1, 2, 3, 4, 5];
    
    let sum = v.iter().fold(0, |acc, x| acc + x);
    println!("Fold sum: {}", sum);
    
    let product = v.iter().product::<i32>();
    println!("Product: {}", product);
    
    let count = v.iter().count();
    println!("Count: {}", count);
    
    let max = v.iter().max();
    println!("Max: {:?}", max);
    
    let min = v.iter().min();
    println!("Min: {:?}", min);
}

fn iterator_methods() {
    let v = vec![1, 2, 3, 4, 5];
    
    let all_positive = v.iter().all(|x| *x > 0);
    println!("All positive: {}", all_positive);
    
    let any_even = v.iter().any(|x| *x % 2 == 0);
    println!("Any even: {}", any_even);
    
    let first_three: Vec<_> = v.iter().take(3).collect();
    println!("First three: {:?}", first_three);
    
    let rest: Vec<_> = v.iter().skip(2).collect();
    println!("Skip 2: {:?}", rest);
    
    let enumerated: Vec<_> = v.iter().enumerate().collect();
    println!("Enumerated: {:?}", enumerated);
}

fn chaining_methods() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let result: Vec<_> = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * x)
        .take(3)
        .collect();
    
    println!("Chained: {:?}", result);
}

fn zip_example() {
    let a = vec![1, 2, 3];
    let b = vec!['a', 'b', 'c'];
    
    let zipped: Vec<_> = a.iter().zip(b.iter()).collect();
    println!("Zipped: {:?}", zipped);
}

fn flat_map_example() {
    let words = vec!["hello", "world"];
    
    let chars: Vec<char> = words.iter()
        .flat_map(|word| word.chars())
        .collect();
    
    println!("Chars: {:?}", chars);
}

fn peekable_example() {
    let v = vec![1, 2, 3];
    let mut iter = v.iter().peekable();
    
    while let Some(&val) = iter.peek() {
        println!("Peeking at: {}", val);
        iter.next();
    }
}

fn fuse_example() {
    struct Flaky(bool);
    
    impl Iterator for Flaky {
        type Item = i32;
        
        fn next(&mut self) -> Option<Self::Item> {
            if self.0 {
                self.0 = false;
                Some(1)
            } else {
                self.0 = true;
                None
            }
        }
    }
    
    let flaky = Flaky(true);
    let mut fused = flaky.fuse();
    
    println!("{:?}", fused.next());
    println!("{:?}", fused.next());
    println!("{:?}", fused.next()); // Will always be None after first None
}

fn inspect_example() {
    let v = vec![1, 2, 3, 4, 5];
    
    let sum: i32 = v.iter()
        .inspect(|x| println!("About to filter: {}", x))
        .filter(|x| **x > 2)
        .inspect(|x| println!("Made it through filter: {}", x))
        .fold(0, |acc, x| acc + x);
    
    println!("Sum: {}", sum);
}

fn cycle_example() {
    let v = vec![1, 2, 3];
    
    let cycled: Vec<_> = v.iter().cycle().take(10).collect();
    println!("Cycled: {:?}", cycled);
}

fn step_by_example() {
    let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let stepped: Vec<_> = v.iter().step_by(2).collect();
    println!("Step by 2: {:?}", stepped);
}

fn rev_example() {
    let v = vec![1, 2, 3, 4, 5];
    
    let reversed: Vec<_> = v.iter().rev().collect();
    println!("Reversed: {:?}", reversed);
}

fn partition_example() {
    let v = vec![1, 2, 3, 4, 5, 6];
    
    let (evens, odds): (Vec<_>, Vec<_>) = v.iter().partition(|x| *x % 2 == 0);
    println!("Evens: {:?}, Odds: {:?}", evens, odds);
}

fn position_example() {
    let v = vec![1, 2, 3, 4, 5];
    
    let pos = v.iter().position(|x| *x == 3);
    println!("Position of 3: {:?}", pos);
    
    let rpos = v.iter().rposition(|x| *x == 3);
    println!("Reverse position of 3: {:?}", rpos);
}

fn nth_example() {
    let v = vec![1, 2, 3, 4, 5];
    
    let third = v.iter().nth(2);
    println!("Third element: {:?}", third);
}

fn compare_example() {
    let a = vec![1, 2, 3];
    let b = vec![1, 2, 4];
    
    println!("a < b: {}", a.iter().lt(b.iter()));
    println!("a == [1, 2, 3]: {}", a.iter().eq(vec![1, 2, 3].iter()));
}

fn main() {
    iterator_basics();
    iterator_adaptors();
    consuming_adaptors();
    iterator_methods();
    chaining_methods();
    zip_example();
    flat_map_example();
    peekable_example();
    fuse_example();
    inspect_example();
    cycle_example();
    step_by_example();
    rev_example();
    partition_example();
    position_example();
    nth_example();
    compare_example();
}