Add IntoIterator
for Box<[T]>
🚧 The 2024 Edition has not yet been released and hence this section is still "under construction". More information may be found in the tracking issue at https://github.com/rust-lang/rust/issues/123759.
Summary
- Boxed slices implement
IntoIterator
in all editions. - Calls to
IntoIterator::into_iter
are hidden in editions prior to 2024 when using method call syntax (i.e.,boxed_slice.into_iter()
). So,boxed_slice.into_iter()
still resolves to(&(*boxed_slice)).into_iter()
as it has before. boxed_slice.into_iter()
changes meaning to callIntoIterator::into_iter
in Rust 2024.
Details
Until Rust 1.80, IntoIterator
was not implemented for boxed slices. In prior versions, if you called .into_iter()
on a boxed slice, the method call would automatically dereference from Box<[T]>
to &[T]
, and return an iterator that yielded references of &T
. For example, the following worked in prior versions:
#![allow(unused)] fn main() { // Example of behavior in previous editions. let my_boxed_slice: Box<[u32]> = vec![1, 2, 3].into_boxed_slice(); // Note: .into_iter() was required in versions older than 1.80 for x in my_boxed_slice.into_iter() { // x is of type &u32 in editions prior to 2024 } }
In Rust 1.80, implementations of IntoIterator
were added for boxed slices. This allows iterating over elements of the slice by-value instead of by-reference:
#![allow(unused)] fn main() { // NEW as of 1.80, all editions let my_boxed_slice: Box<[u32]> = vec![1, 2, 3].into_boxed_slice(); for x in my_boxed_slice { // notice no need for calling .into_iter() // x is of type u32 } }
This example is allowed on all editions because previously this was an error since for
loops do not automatically dereference like the .into_iter()
method call does.
However, this would normally be a breaking change because existing code that manually called .into_iter()
on a boxed slice would change from having an iterator over references to an iterator over values. To resolve this problem, method calls of .into_iter()
on boxed slices have edition-dependent behavior. In editions before 2024, it continues to return an iterator over references, and starting in Edition 2024 it returns an iterator over values.
#![allow(unused)] fn main() { // Example of changed behavior in Edition 2024 let my_boxed_slice: Box<[u32]> = vec![1, 2, 3].into_boxed_slice(); // Example of old code that still manually calls .into_iter() for x in my_boxed_slice.into_iter() { // x is now type u32 in Edition 2024 } }
Migration
The boxed_slice_into_iter
lint will automatically modify any calls to .into_iter()
on boxed slices to call .iter()
instead to retain the old behavior of yielding references. This lint is part of the rust-2024-compatibility
lint group, which will automatically be applied when running cargo fix --edition
. To migrate your code to be Rust 2024 Edition compatible, run:
cargo fix --edition
For example, this will change:
fn main() { let my_boxed_slice: Box<[u32]> = vec![1, 2, 3].into_boxed_slice(); for x in my_boxed_slice.into_iter() { // x is of type &u32 } }
to be:
fn main() { let my_boxed_slice: Box<[u32]> = vec![1, 2, 3].into_boxed_slice(); for x in my_boxed_slice.iter() { // x is of type &u32 } }
The boxed_slice_into_iter
lint is defaulted to warn on all editions, so unless you have manually silenced the lint, you should already see it before you migrate.