Safely initialize fix length arrays in Rust (WIP!)

init-arrays.rs

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

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

enum MakeArray<T> {
    Nothing,
    Just([T; 
}

struct MakeArray<T> {
    array: *mut T,
    filled: usize,
}

impl<T> Drop for MakeArray<T> {
    fn drop(&mut self) {
        for i in 0..self.filled {
            unsafe {
                self.array.add(i).read();
            }
        }
    }
}

fn init_array10<T, F>(mut f: F) -> [T; 10]
    where F: FnMut(usize) -> T, T: std::fmt::Debug,
{
    unsafe {
        let mut array: [T; 10] = std::mem::uninitialized();
        let array_ptr = array.as_mut_ptr();

        let mut ma: MakeArray<T> = MakeArray {
            array: array_ptr,
            filled: 0,
        };

        for i in 0..10 {
            let x = f(i);
            ma.array.add(i).write(x);
            println!("{} {:?}", i, array);
            ma.filled += 1;
        }
        ma.filled = 0;
        println!("Finished filling {:?}", array);
        array
    }
}

fn main() {
    /*
    let mut arr: [Foo; 10] = unsafe { std::mem::uninitialized() };
    for (i, element) in arr.iter_mut().enumerate() {
        unsafe {
            std::ptr::write(element, Foo(i));
        }
    }
     */

    {
        println!("{:?}", init_array10(|i| Foo(i)));
    }

    println!("\n\n\nPanic case\n\n\n");

    let _arr = init_array10(|i| {
        if i < 3 {
            Foo(i)
        } else {
            panic!("Testing panics");
        }
    });
}