Tracking Issue for `Vec::recycle`

[llogiq]

Feature gate: #![feature(vec_recycle)]

This is a tracking issue for the Vec::recycle method, which allows reusing a Vec in a loop even if the lifetime unification would otherwise disallow it.

Public API

// in alloc::vec
#![feature(transmutability)]
#![feature(trait_alias)]

use std::mem::{Assume, MaybeUninit, TransmuteFrom};

/// Implemented if the size and alignment `T` and `Self` are both equal.
trait Recyclable<T> =
    for<'a> TransmuteFrom<&'a MaybeUninit<T>, { Assume::SAFETY }> 
    where 
        T: for<'a> TransmuteFrom<&'a MaybeUninit<Self>, { Assume::SAFETY }>;

impl<T> Vec<T> {
    #[feature(vec_recycle)]
    pub fn recycle<U>(self) -> Vec<U> where U: Recyclable<T>;
}

Steps / History

• ACP: Vec::recycle libs-team#674
• Implementation: #...
• Final comment period (FCP)¹
• Stabilization PR

Unresolved Questions

• Make sure that we don't unintentionally create reliance on this as workaround for lack of stable TransmuteFrom, when this stabilizes.

Footnotes

1. https://std-dev-guide.rust-lang.org/feature-lifecycle/stabilization.html ↩

[GrigorenkoPV]

@rustbot claim
(implementation)

[GrigorenkoPV]

Unfortunately, there are some issues with the TransmuteFrom approach.

#![feature(transmutability)]

use core::mem::{Assume, TransmuteFrom};

const fn check<From, To>()
where
    To: TransmuteFrom<From, { Assume::SAFETY }>,
{
}

fn main() {
    const {
        assert!(align_of::<&[u8]>() == align_of::<&[&[u8]]>());
    }
    check::<&[&[u8]], &[u8]>();
    check::<&[u8], &[&[u8]]>();
}

When uncommenting the two lines, the latest nightly (2025-10-30) gives the following errors:

error[E0277]: `[&[u8]]` cannot be safely transmuted into `[u8]`
  --> src/main.rs:15:23
   |
15 |     check::<&[&[u8]], &[u8]>();
   |                       ^^^^^ analyzing the transmutability of `[&[u8]]` is not yet supported
   |

error[E0277]: `&[u8]` cannot be safely transmuted into `&[&[u8]]`
  --> src/main.rs:16:20
   |
16 |     check::<&[u8], &[&[u8]]>();
   |                    ^^^^^^^^ the minimum alignment of `&[u8]` (1) should be greater than that of `&[&[u8]]` (8)
   |

So in one direction it's unimplemented and in the other direction it's seemingly wrong? Maybe i don't understand what it means by "minimum alignment", but the align_of gives the same values for both types.

[jswrenn]

@GrigorenkoPV Feel free to tag me in any TransmuteFrom issues! The second error is downstream of the first one, I think. We don't yet support analyzing the transmutability of slices, because we haven't decided on how to incorporate the fact we can't analyze the metadata component statically. (Relatedly, we also don't support analyzing trait objects yet.) TransmuteFrom will let you proof-of-concept a trait bound for 'easy' types, but we'll need to be a little more sophisticated for more unusual types.

Use the TransmuteFrom-based Recyclable for now, and I'll see this week if I can whip up an intrinsic Recyclable trait that skips the validity checks that are unnecessary for this use-case.