clippy::iter_without_into_iter: Looks for iter and iter_mut methods without an associated IntoIterator for (&|&mut) Type implementation

struct MySlice<'a>(&'a [u8]);
impl<'a> MySlice<'a> {
    pub fn iter(&self) -> std::slice::Iter<'a, u8> {
        self.0.iter()
    }
}

struct MySlice<'a>(&'a [u8]);
impl<'a> MySlice<'a> {
    pub fn iter(&self) -> std::slice::Iter<'a, u8> {
        self.0.iter()
    }
}
impl<'a> IntoIterator for &MySlice<'a> {
    type Item = &'a u8;
    type IntoIter = std::slice::Iter<'a, u8>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

[lints.clippy]
iter_without_into_iter = "warn"

#![warn(clippy::iter_without_into_iter)]

cargo clippy -- -W clippy::iter-without-into-iter

Clippy's own documentation

What it does

Looks for iter and iter_mut methods without an associated IntoIterator for (&|&mut) Type implementation.

Why is this bad?

It’s not bad, but having them is idiomatic and allows the type to be used in for loops directly (for val in &iter {}), without having to first call iter() or iter_mut().

Limitations

This lint focuses on providing an idiomatic API. Therefore, it will only lint on types which are accessible outside of the crate. For internal types, the IntoIterator trait can be implemented on demand if it is actually needed.

Example

struct MySlice<'a>(&'a [u8]);
impl<'a> MySlice<'a> {
    pub fn iter(&self) -> std::slice::Iter<'a, u8> {
        self.0.iter()
    }
}

Use instead:

struct MySlice<'a>(&'a [u8]);
impl<'a> MySlice<'a> {
    pub fn iter(&self) -> std::slice::Iter<'a, u8> {
        self.0.iter()
    }
}
impl<'a> IntoIterator for &MySlice<'a> {
    type Item = &'a u8;
    type IntoIter = std::slice::Iter<'a, u8>;
    fn into_iter(self) -> Self::IntoIter {
        self.iter()
    }
}

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Related lints

• too_many_linesChecks for functions with a large amount of lines
• missing_errors_docChecks the doc comments of publicly visible functions that return a Result type and warns if there is no # Errors section
• must_use_candidateChecks for public functions that have no #[must_use] attribute, but return something not already marked must-use, have no mutable arg and mutate no statics
• iter_filter_is_ok`filter` for `is_ok` on iterator over `Result`s
• iter_filter_is_some`filter` for `is_some` on iterator over `Option`
• iter_not_returning_iteratorthis method is named `iter` but its return type does not implement `Iterator`
• large_digit_groupsdigit groups should be smaller
• large_futureslarge future with a size of 16385 bytes
• large_stack_arraysallocating a local array larger than 16384 bytes

All 847 Clippy lints · Rust compiler errors · Cargo.toml checker