需求：类似Iterator::chain()的懒加载链式迭代器方法，避免不必要计算

Great question! The core problem with your current code is that Iterator::chain() evaluates its argument immediately. Even though you break out of the loop before reaching elements from expensive_function(), that function still runs upfront (making you wait 5 seconds) because expensive_function().iter() is computed before chain() is even called.

To fix this, we need a lazy chain implementation that only initializes the second iterator when the first one is exhausted. Here are a couple of ways to do this in Rust:

1. Manual Lazy Chain with std::iter::from_fn #

If you want a quick solution without extra dependencies, you can build the lazy iterator manually using from_fn:

use std::{thread, time};

fn expensive_function() -> Vec<u64> {
    thread::sleep(time::Duration::from_secs(5));
    vec![4, 5, 6]
}

pub fn main() {
    let nums = [1, 2, 3];
    let mut first_iter = nums.iter();
    let mut second_iter: Option<std::slice::Iter<'_, u64>> = None;

    for &i in std::iter::from_fn(move || {
        // Try to get the next element from the first iterator
        first_iter.next().or_else(|| {
            // Only initialize the second iterator if we haven't already
            if second_iter.is_none() {
                second_iter = Some(expensive_function().iter());
            }
            // Now get elements from the second iterator
            second_iter.as_mut().unwrap().next()
        })
    }) {
        if i > 2 {
            break;
        } else {
            println!("{}", i);
        }
    }
}

In this code:

• We start with just the first iterator (nums.iter()) ready to go.
• The from_fn closure first tries to pull elements from first_iter.
• Only when first_iter is empty will we call expensive_function() to create the second iterator.
• Since your loop breaks when i > 2 (after processing 3), first_iter is never fully exhausted—so expensive_function() is never called.

2. Reusable lazy_chain Function #

For cleaner code that you can reuse across your project, wrap the logic in a generic function:

use std::{iter::Iterator, thread, time};

// Generic lazy chain function: takes the first iterator and a closure that returns the second
fn lazy_chain<I, J, F>(first: I, second_factory: F) -> impl Iterator<Item = I::Item>
where
    I: Iterator,
    J: Iterator<Item = I::Item>,
    F: FnOnce() -> J,
{
    let mut first_iter = Some(first);
    let mut second_iter: Option<J> = None;

    std::iter::from_fn(move || {
        // Check if we still have the first iterator
        if let Some(ref mut iter) = first_iter {
            match iter.next() {
                Some(item) => return Some(item),
                None => {
                    // First iterator is done—initialize the second
                    first_iter = None;
                    second_iter = Some(second_factory());
                }
            }
        }
        // Now pull from the second iterator
        second_iter.as_mut().and_then(|iter| iter.next())
    })
}

fn expensive_function() -> Vec<u64> {
    thread::sleep(time::Duration::from_secs(5));
    vec![4, 5, 6]
}

pub fn main() {
    let nums = [1, 2, 3];

    for &i in lazy_chain(nums.iter(), || expensive_function().iter()) {
        if i > 2 {
            break;
        } else {
            println!("{}", i);
        }
    }
}

This function works exactly like the manual version but is reusable with any iterator types. The second_factory closure is only executed once, and only when the first iterator is fully consumed.

Why This Works #

Unlike chain(), which requires the second iterator to exist upfront, our lazy version defers creating the second iterator until it's actually needed. In your specific case, since you break out of the loop before the first iterator is exhausted, the expensive function never runs—perfect for your use case!

内容的提问来源于stack exchange，提问作者Morten Lohne