pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
    // ... 여러 기본 구현 메서드들
}

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;
    fn into_iter(self) -> Self::IntoIter;
}

pub trait FromIterator<A> {
    fn from_iter<T>(iter: T) -> Self
    where
        T: IntoIterator<Item = A>;
}

// 범위 문법으로 반복자 생성
let range = 1..5;        // 1, 2, 3, 4
let inclusive = 1..=5;   // 1, 2, 3, 4, 5

use std::iter;
let once = iter::once(42);  // 42만 생성

let repeat = iter::repeat('a');  // 'a'를 무한히 생성

let empty: iter::Empty<i32> = iter::empty();  // 항목 없음

let v: Vec<i32> = (0..5).collect();
let s: HashSet<i32> = (0..5).collect();
let m: HashMap<char, i32> = vec![('a', 1), ('b', 2)].into_iter().collect();

let mut peekable = [1, 2, 3].iter().peekable();
if let Some(&first) = peekable.peek() {
    println!("다음 항목: {}", first);
}

let fused = [1, 2, 3].iter().fuse();

let mut cycle = [1, 2, 3].iter().cycle();
// 1, 2, 3, 1, 2, 3, ...

let enumerated = ['a', 'b', 'c'].iter().enumerate();
// (0, 'a'), (1, 'b'), (2, 'c')

let chained = [1, 2].iter().chain([3, 4].iter());
// 1, 2, 3, 4

let zipped = [1, 2].iter().zip(['a', 'b'].iter());
// (1, 'a'), (2, 'b')

struct MyCollection<T> {
    data: Vec<T>,
}

impl<T> MyCollection<T> {
    fn iter(&self) -> impl Iterator<Item = &T> {
        self.data.iter()
    }
    
    fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {
        self.data.iter_mut()
    }
}

impl<T> IntoIterator for MyCollection<T> {
    type Item = T;
    type IntoIter = std::vec::IntoIter<T>;
    
    fn into_iter(self) -> Self::IntoIter {
        self.data.into_iter()
    }
}

impl<'a, T> IntoIterator for &'a MyCollection<T> {
    type Item = &'a T;
    type IntoIter = std::slice::Iter<'a, T>;
    
    fn into_iter(self) -> Self::IntoIter {
        self.data.iter()
    }
}

impl<'a, T> IntoIterator for &'a mut MyCollection<T> {
    type Item = &'a mut T;
    type IntoIter = std::slice::IterMut<'a, T>;
    
    fn into_iter(self) -> Self::IntoIter {
        self.data.iter_mut()
    }
}

struct Fibonacci {
    curr: u32,
    next: u32,
}

impl Fibonacci {
    fn new() -> Fibonacci {
        Fibonacci { curr: 0, next: 1 }
    }
}

impl Iterator for Fibonacci {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        let new_next = self.curr + self.next;
        self.curr = self.next;
        self.next = new_next;
        Some(self.curr)
    }
}

// Vec<T> -> Vec<U>
let v: Vec<i32> = vec![1, 2, 3];
let doubled: Vec<i32> = v.iter().map(|&x| x * 2).collect();

// Vec<T> -> HashSet<T>
let set: HashSet<i32> = v.iter().cloned().collect();

// Vec<T> -> HashMap<K, V>
let map: HashMap<i32, char> = vec![(1, 'a'), (2, 'b')].into_iter().collect();

// 짝수와 홀수로 그룹화
let (even, odd): (Vec<i32>, Vec<i32>) = (1..=10).partition(|&n| n % 2 == 0);

// 조건에 따라 필터링
let positive: Vec<i32> = vec![-1, 2, -3, 4].into_iter().filter(|&x| x > 0).collect();

// 모든 결과가 Ok인지 확인
let results = vec![Ok(1), Ok(2), Ok(3)];
let all_ok = results.iter().all(|r| r.is_ok());

// Ok 값만 수집
let ok_values: Vec<i32> = results.into_iter().filter_map(Result::ok).collect();

// Some 값만 수집
let options = vec![Some(1), None, Some(2)];
let values: Vec<i32> = options.into_iter().filter_map(|o| o).collect();

// 중첩 반복자 평탄화
let nested = vec![vec![1, 2], vec![3, 4]];
let flat: Vec<i32> = nested.into_iter().flatten().collect();  // [1, 2, 3, 4]

// map과 flatten 조합
let words = vec!["hello", "world"];
let chars: Vec<char> = words.iter()
    .flat_map(|word| word.chars())
    .collect();  // ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

// 순차 처리 (표준 라이브러리)
let sum: i32 = (1..1000).sum();

// 병렬 처리 (rayon 크레이트 사용)
use rayon::prelude::*;
let sum: i32 = (1..1000).into_par_iter().sum();

// 무한 반복자 생성
let infinite = std::iter::repeat(1);

// 유한 반복자로 제한
let finite: Vec<i32> = infinite.take(5).collect();  // [1, 1, 1, 1, 1]

use itertools::Itertools;

// 그룹화
let groups = vec![1, 1, 1, 3, 3, 2, 2, 2]
    .into_iter()
    .group_by(|&x| x);

// 순열
let permutations = [1, 2, 3].iter().permutations(2);

// 조합
let combinations = [1, 2, 3, 4].iter().combinations(2);

// intersperse
let interspersed: Vec<i32> = [1, 2, 3].iter()
    .cloned()
    .intersperse(0)
    .collect();  // [1, 0, 2, 0, 3]

// 중복 항목 제거
let unique: Vec<i32> = [1, 2, 1, 3, 2].iter()
    .cloned()
    .unique()
    .collect();  // [1, 2, 3]

use rayon::prelude::*;

// 병렬 맵
let v: Vec<i32> = (0..1000)
    .into_par_iter()
    .map(|i| i * i)
    .collect();

// 병렬 필터
let evens: Vec<i32> = (0..1000)
    .into_par_iter()
    .filter(|i| i % 2 == 0)
    .collect();