Default implementation on std::iter::Fuse should not requires Default on the inner iterator

[ultimaweapon]

So it can be constructed in the following code:

let items = match std::fs::read_dir(&path) {
    Ok(v) => v.fuse(),
    Err(e) if e.kind() == ErrorKind::NotFound => Default::default(), // This line won't compile.
    Err(e) => return Err(e),
};

[ShE3py]

The problem is that Fuse::<I>::default() calls I::default(), which is free to yield some elements. Maybe we should add a Fuse::<I>::exhausted() which is guaranteed to yield no elements?

@rustbot label +T-libs-api +C-feature-request +A-iterators -needs-triage

[hanna-kruppe]

Oh no… that’s what the documentation of impl Default for Fuse says, but the current implementation actually constructs Fuse { iter: Default::default() } which is Fuse { iter: None } because the field is Option<I>.

[zachs18]

For a workaround for the original code snippet, assuming you want an empty iterator in the ErrorKind::NotFound case, there are a few things you could do.

If you don't mind an additional heap allocation and dynamic dispatch, you could use Box<dyn Iterator>:

let mut items: Box<dyn Iterator<Item = _>> = match std::fs::read_dir(&path) {
    Ok(v) => Box::new(v),
    Err(e) if e.kind() == ErrorKind::NotFound => Box::new(std::iter::empty()),
    Err(e) => return Err(e),
};

Or you could use Option::into_iter and Iterator::flatten, e.g.

let mut items = match std::fs::read_dir(&path) {
    Ok(v) => Some(v).into_iter().flatten(),
    Err(e) if e.kind() == ErrorKind::NotFound => None.into_iter().flatten(),
    Err(e) => return Err(e),
};

Or you could use either::Either:

let mut items = match std::fs::read_dir(&path) {
    Ok(v) => Either::Left(v),
    Err(e) if e.kind() == ErrorKind::NotFound => Either::Right(std::iter::empty()),
    Err(e) => return Err(e),
};

Or, if you are using Rust 1.79.0 or later and depending on how you use items, you could use dynamic dispatch with the new temporary value lifetime extension semantics in match:

let items: &mut dyn Iterator<Item = _> = match std::fs::read_dir(&path) {
    Ok(v) => &mut {v}, // the braces are required, to move `v` out of the variable into a temporary whose lifetime can be extended
    Err(e) if e.kind() == ErrorKind::NotFound => &mut std::iter::empty(),
    Err(e) => return Err(e),
};

[ultimaweapon]

Thanks for the idea. I don't mind using a workaround but I think it is better to be able to construct Fuse directly is better (e.g. provide additional method like @ShE3py said). Also I think changing the current behavior of Fuse::default is a breaking change since people might already depend on its current behavior.