Code shared from the Rust Playground

playground.rs

#![feature(unsize, nll)]

use std::ptr;
use std::mem::{self, ManuallyDrop};
use std::marker::{PhantomData, Unsize};

struct PartialArray<T, A>
where
    A: Unsize<[T]>
{
    array: ManuallyDrop<A>,
    idx: usize,
    marker: PhantomData<T>
}

impl <T, A> PartialArray<T, A>
where
    A: Unsize<[T]>
{
    unsafe fn new() -> Self {
        Self {
            array: ManuallyDrop::new(mem::uninitialized()),
            idx: 0,
            marker: PhantomData,
        }
    }
    
    fn from_iter<I: Iterator<Item = T>>(mut self, iter: I) -> Result<A, ()> {
        unsafe {
            let arr: &mut A = &mut self.array;
            let slice: &mut [T] = arr; 
                
            for (dst, src) in slice.iter_mut().zip(iter) {
                ptr::write(dst, src);
                self.idx += 1;
            }
            
            if self.idx != slice.len() {
                ptr::drop_in_place(&mut slice[..self.idx]);
                mem::forget(self);
                return Err(())
            }
            
            let ret = ManuallyDrop::into_inner(ptr::read(&mut self.array));
            mem::forget(self);
            Ok(ret)
        }
    }
}

impl <T, A> Drop for PartialArray<T, A>
where
    A: Unsize<[T]>
{
    fn drop(&mut self) {
        unsafe {
            let array: &mut A = &mut self.array;
            let slice: &mut [T] = array;
            ptr::drop_in_place::<[T]>(&mut slice[..self.idx]);
        }
    }
}

#[derive(Debug)]
struct Foo(usize);

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropping foo {}", self.0);
    }
}

struct PanicIter {
    n: usize
}

impl Iterator for PanicIter {
    type Item = Foo;
    
    fn next(&mut self) -> Option<Self::Item> {
        self.n += 1;
        
        if self.n == 5 { panic!() }
        
        Some(Foo(self.n))
    }
}

fn main() {
    let mut paniciter = PanicIter { n: 0 };

    unsafe {
        let array: Result<[Foo; 10], ()> = PartialArray::new().from_iter(paniciter);
        
        println!("{:?}", array.as_ref());
    }
}