Trait IntoIterator

1.0.0 (const: unstable) · Source

pub trait IntoIterator {
    type Item;
    type IntoIter: Iterator<Item = Self::Item>;

    // Required method
    fn into_iter(self) -> Self::IntoIter;
}

Expand description

Conversion into an Iterator.

By implementing IntoIterator for a type, you define how it will be converted to an iterator. This is common for types which describe a collection of some kind.

One benefit of implementing IntoIterator is that your type will work with Rust’s for loop syntax.

§Examples

Basic usage:

let v = [1, 2, 3];
let mut iter = v.into_iter();

assert_eq!(Some(1), iter.next());
assert_eq!(Some(2), iter.next());
assert_eq!(Some(3), iter.next());
assert_eq!(None, iter.next());

Implementing IntoIterator for your type:

// A sample collection, that's just a wrapper over Vec<T>
#[derive(Debug)]
struct MyCollection(Vec<i32>);

// Let's give it some methods so we can create one and add things
// to it.
impl MyCollection {
    fn new() -> MyCollection {
        MyCollection(Vec::new())
    }

    fn add(&mut self, elem: i32) {
        self.0.push(elem);
    }
}

// and we'll implement IntoIterator
impl IntoIterator for MyCollection {
    type Item = i32;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

// Now we can make a new collection...
let mut c = MyCollection::new();

// ... add some stuff to it ...
c.add(0);
c.add(1);
c.add(2);

// ... and then turn it into an Iterator:
for (i, n) in c.into_iter().enumerate() {
    assert_eq!(i as i32, n);
}

It is common to use IntoIterator as a trait bound. This allows the input collection type to change, so long as it is still an iterator. Additional bounds can be specified by restricting on Item:

fn collect_as_strings<T>(collection: T) -> Vec<String>
where
    T: IntoIterator,
    T::Item: std::fmt::Debug,
{
    collection
        .into_iter()
        .map(|item| format!("{item:?}"))
        .collect()
}

Required Associated Types§

1.0.0 (const: unstable) · Source

type Item

The type of the elements being iterated over.

1.0.0 (const: unstable) · Source

type IntoIter: Iterator<Item = Self::Item>

Which kind of iterator are we turning this into?

Required Methods§

1.0.0 (const: unstable) · Source

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

See the module-level documentation for more.

§Examples

let v = [1, 2, 3];
let mut iter = v.into_iter();

assert_eq!(Some(1), iter.next());
assert_eq!(Some(2), iter.next());
assert_eq!(Some(3), iter.next());
assert_eq!(None, iter.next());

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

IntoIterator

Trait IntoIterator Copy item path

§Examples

Required Associated Types§

type Item

type IntoIter: Iterator<Item = Self::Item>

Required Methods§

fn into_iter(self) -> Self::IntoIter

§Examples

Dyn Compatibility§

Implementors§

impl IntoIterator for &FieldSet

type IntoIter = Iter

type Item = Field

impl IntoIterator for Access

type Item = Access

type IntoIter = Iter<Access>

impl IntoIterator for toml_edit::array::Array

type Item = Value

type IntoIter = Box<dyn Iterator<Item = Value>>

impl IntoIterator for ArrayOfTables

type Item = Table

type IntoIter = Box<dyn Iterator<Item = Table>>

impl IntoIterator for AtFlags

type Item = AtFlags

type IntoIter = Iter<AtFlags>

impl IntoIterator for BeginFlags

type Item = BeginFlags

type IntoIter = Iter<BeginFlags>

impl IntoIterator for ByteBuf

type Item = u8

type IntoIter = <Vec<u8> as IntoIterator>::IntoIter

impl IntoIterator for bytes::bytes::Bytes

type Item = u8

type IntoIter = IntoIter<Bytes>

impl IntoIterator for BytesMut

type Item = u8

type IntoIter = IntoIter<BytesMut>

impl IntoIterator for CMSOptions

type Item = CMSOptions

type IntoIter = Iter<CMSOptions>

impl IntoIterator for CipherCtxFlags

type Item = CipherCtxFlags

type IntoIter = Iter<CipherCtxFlags>

impl IntoIterator for ControlModes

type Item = ControlModes

type IntoIter = Iter<ControlModes>

impl IntoIterator for rustix::backend::event::epoll::CreateFlags

type Item = CreateFlags

type IntoIter = Iter<CreateFlags>

impl IntoIterator for rustix::backend::fs::inotify::CreateFlags

type Item = CreateFlags

type IntoIter = Iter<CreateFlags>

impl IntoIterator for DupFlags

type Item = DupFlags

type IntoIter = Iter<DupFlags>

impl IntoIterator for Error

type Item = Error

type IntoIter = IntoIter

impl IntoIterator for EventFlags

type Item = EventFlags

type IntoIter = Iter<EventFlags>

impl IntoIterator for EventKindMask

type Item = EventKindMask

type IntoIter = Iter<EventKindMask>

impl IntoIterator for EventMask

type Item = EventMask

type IntoIter = Iter<EventMask>

impl IntoIterator for EventfdFlags

type Item = EventfdFlags

type IntoIter = Iter<EventfdFlags>

impl IntoIterator for ExtensionContext

type Item = ExtensionContext

type IntoIter = Iter<ExtensionContext>

impl IntoIterator for FallocateFlags

type Item = FallocateFlags

type IntoIter = Iter<FallocateFlags>

impl IntoIterator for FdFlags

type Item = FdFlags

type IntoIter = Iter<FdFlags>

Trait IntoIterator