Ich suche derzeit inmehr Zeug mit Arrays tun, aber ich denke, die Leistung dieser Operationen könnte noch besser sein, wenn wir uns irgendwie in ein @ verwandeln könntLeaked<T> das Array von vorne, nur um es zu entleeren, wenn die Funktion endet. Dies würde es uns ermöglichen, die Leckverstärkung zu verwenden, ohne a) Unsicherheit einzuführen und b) ein @ einzurichtecatch_panic(_). Ist das irgendwie in Rust möglich?

Zum Beispiel ein generisches Array aus einem Iterator erstellen (dies funktioniert offensichtlich nicht):

#[inline]
fn map_inner<I, S, F, T, N>(list: I, f: F) -> GenericArray<T, N>
where I: IntoIterator<Item=S>, F: Fn(&S) -> T, N: ArrayLength<T> {
     unsafe {
        // pre-leak the whole array, it's uninitialized anyway
        let mut res : GenericArray<Leaked<T>, N> = std::mem::uninitialized();
        let i = list.into_iter();
        for r in res.iter_mut() {
            // this could panic anytime
            std::ptr::write(r, Leaked::new(f(i.next().unwrap())))
        }
        // transmuting un-leaks the array
        std::mem::transmute::<GenericArray<Leaked<T>, N>,
                              GenericArray<T, N>>(res)
    }
}

Ich sollte beachten, dass, wenn wir entweder zur Kompilierungszeit Zugriff auf die Größe von @ hattT oder ein Typ, der seine Innereien vor dem Ausleihen verbergen kann (wieLeaked<T> im Beispiel) ist dies durchaus machbar.