Rust：向量实现问题

Question

I'm trying to write a mathematical vector library in rust, but I've encountered some problems I really want to solve. There are two issues I want to address:

• the “ Sized is not implemented for [T] ” error
• making the element of Vecor<T> dense

Minimal working example

#[derive(Debug)]
struct Vector<T> {
    elements: [T]
}

// multiple base trait implementations
impl<T> /* … */ for Vector<T> { }


// one of multiple macros
macro_rules! impl_vector_normal_arithmetic {
    ($(impl $trait:ident for Vector { $function:ident($symbol:tt) })+) => {
        $(
            //            ———————— Error: the trait `Sized` is not implemented for `[T]`
            //            vvvvvv
            impl<T : Num> $trait for Vector<T> {
                type Output = Self;
            
                #[inline(always)]
                fn $function(&self, other: Self) -> Self {
                    Self::new(
                        self.iter()
                            .zip(other.iter())
                            .map(|(&lhs, &rhs)| lhs $symbol rhs)
                            .collect()
                    )
                }
            }
        )+
    };
}

impl_vector_normal_arithmetic! {
    impl Add for Vector { add(+) }
    impl Sub for Vector { sub(-) }
    impl Mul for Vector { mul(*) }
    impl Div for Vector { div(/) }
}

the “ Sized is not implemented for [T] ” error

My implementation of a vector consists of a generic vector definition that, theoretically, should be able to contain infinitely large vectors. These vectors can only be instantiated once given a size - which implies the use of the array. A macro is then used to add some arithmetic features (Add, Sub, Div, Mul, et cetera). Yet, this causes a problem. I cannot implement those functions, because the compiler tells me that [T] does not implement the Sized trait. I do understand what the error tells me, but I do know how to tell the compiler that it doesn't matter what the size is (because the function doesn't care). What can I do to get around this compiler error?

making the elements of Vecor<T> dense

My Vector<T> struct contains / can be defined by elements of type [T] . Yesterday, I was reading up on some memory allocation and came across sparse and dense memory allocation. I was wondering if the array defined by Rust is dense (id est all items are allocated in sequential in (virtual) memory), because that's what I want to achieve with these vector definitions.

Answer 1

These vectors can only be instantiated once given a size - which implies the use of the array.

But you have not written an array; you have written a slice , which means run-time choice of size, not generic choice of size. [T] has a dynamic size; therefore Vector<T> has a dynamic size; therefore Vector<T> cannot be passed or returned on the stack, and must always be handled behind some pointer. This is probably not what you want.

To declare an array, you must write the type [T; N] [T; N] , not [T] .

#[derive(Debug)]
struct Vector<T, const N: usize> {
    elements: [T; N]
}

This way, Vector will always be Sized , avoiding the error you asked about. You will need to make your existing generic code generic over N as well as T in the same way. For example, here is an implementation of Add :

impl<T: num_traits::NumAssign, const N: usize> Add for Vector<T, N> {
    type Output = Self;
    fn add(mut self, other: Self) -> Self {
        for (self_el, other_el) in
            self.elements.iter_mut().zip(other.elements.into_iter())
        {
            *self_el += other_el;
        }
        self
    }
}

(It uses a loop instead of .collect() because Iterator::collect() can't collect into an array, since iterators in general don't have a statically known length.)