let nums = vec![1, 2, 3];
 
// iter() → &T (읽기 전용, 원본 유지)
for n in nums.iter() { }       // n: &i32
println!("{:?}", nums);        // ✅ nums 살아있음
 
// iter_mut() → &mut T (수정 가능, 원본 유지)
let mut nums = vec![1, 2, 3];
for n in nums.iter_mut() { }   // n: &mut i32
println!("{:?}", nums);        // ✅ nums 살아있음
 
// into_iter() → T (소유권 이동, 원본 소비)
for n in nums.into_iter() { }  // n: i32
// println!("{:?}", nums);     // ❌ nums 소비됨

// Python: lambda x: x * 2
// Rust:
let double = |x| x * 2;
let double = |x: i32| -> i32 { x * 2 };  // 타입 명시 (선택)

let multiplier = 3;
 
// ✅ 클로저: 외부 변수 캡처 가능
let multiply = |x| x * multiplier;
println!("{}", multiply(5));  // 15
 
// ❌ fn: 외부 변수 접근 불가
fn multiply_fn(x: i32) -> i32 {
    x * multiplier  // 컴파일 에러!
}

// 1. &로 캡처 (읽기만 할 때)
let name = String::from("Rust");
let greet = || println!("{}", name);
greet();
println!("{}", name);  // ✅ 살아있음
 
// 2. &mut로 캡처 (수정할 때)
let mut count = 0;
let mut inc = || count += 1;
inc();
println!("{}", count);  // ✅ 살아있음 (값: 1)
 
// 3. move로 캡처 (소유권 이동, 명시적)
let name = String::from("Rust");
let greet = move || println!("{}", name);
greet();
// println!("{}", name);  // ❌ 소유권 이동됨

let nums = vec![1, 2, 3, 4, 5];
 
let result: Vec<i32> = nums.iter()
    .filter(|x| **x >= 3)      // 조건 필터링
    .map(|x| x * 10)           // 변환
    .collect();                 // Vec으로 수집
// [30, 40, 50]

nums.iter()           // &i32를 줌
    .filter(|x| ...)  // x는 &&i32 (참조의 참조!)
 
// 해결 방법
.filter(|x| **x >= 3)     // 방법 1: 역참조
.filter(|&&x| x >= 3)     // 방법 2: 패턴으로 벗기기

# Python
result = [x * 10 for x in nums if x >= 3]
 
# Python (map/filter 버전)
result = list(map(lambda x: x * 10, filter(lambda x: x >= 3, nums)))

// Rust
let result: Vec<i32> = nums.iter()
    .filter(|x| **x >= 3)
    .map(|x| x * 10)
    .collect();

let nums = vec![1, 2, 3, 4, 5];
 
nums.iter().sum::<i32>()     // 15 (합계, 타입 명시 필요)
nums.iter().count()          // 5 (개수)

nums.iter().any(|x| *x > 3)       // true (하나라도 만족?)
nums.iter().all(|x| *x > 0)       // true (전부 만족?)
nums.iter().find(|x| **x > 3)     // Some(&4) (첫 번째 매칭)
nums.iter().position(|x| *x > 3)  // Some(3) (인덱스)

let names = vec!["Alice", "Bob", "Carol"];
 
for (i, name) in names.iter().enumerate() {
    println!("{}: {}", i, name);
}
// 0: Alice
// 1: Bob
// 2: Carol

# Python 동일
for i, name in enumerate(names):
    print(f"{i}: {name}")

let names = vec!["Alice", "Bob"];
let scores = vec![85, 92];
 
let paired: Vec<_> = names.iter().zip(scores.iter()).collect();
// [("Alice", 85), ("Bob", 92)]

let sentences = vec!["hello world", "rust is fun"];
 
// map → 중첩
let nested: Vec<Vec<&str>> = sentences.iter()
    .map(|s| s.split_whitespace().collect())
    .collect();
// [["hello", "world"], ["rust", "is", "fun"]]
 
// flat_map → 평탄화
let flat: Vec<&str> = sentences.iter()
    .flat_map(|s| s.split_whitespace())
    .collect();
// ["hello", "world", "rust", "is", "fun"]

# Python 동일
flat = [word for s in sentences for word in s.split()]

let name = "Rust";
let version = 2026;
let msg = format!("{}: ${}", name, version);  // "Rust: $2026"

# Python 동일
msg = f"{name}: ${version}"

// fn 포인터: 외부 변수 캡처 불가
fn apply(value: i32, func: fn(i32) -> i32) -> i32 {
    func(value)
}
 
// Fn 트레이트: 캡처하는 클로저도 받을 수 있음
fn apply(value: i32, func: impl Fn(i32) -> i32) -> i32 {
    func(value)
}
 
fn main() {
    let multiplier = 3;
    let result = apply(5, |x| x * multiplier);  // Fn이면 ✅
    println!("{}", result);  // 15
}