using const generic in implementation of trait for another trait causes "unconstrained const parameter" error

Question

I'm trying to implement some abstract linear algebra traits and structs as part of my practices learning rust. In the code below when I implement VectorAbstract for VectorDynamic there's no problem; but when I try to do the same for VectorStatic I get the following error :

the const parameter `DIM_COUNT` is not constrained by the impl trait, self type, or predicates
unconstrained const parameter
note: expressions using a const parameter must map each value to a distinct output value
note: proving the result of expressions other than the parameter are unique is not supported

What am I doing wrong here ?
What's the correct way to implement this ?
Here's my code :

pub trait VectorAbstract: VectorSpaceElement + // a dozen std traits
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue;
}

pub trait VectorDynamic: VectorAbstract {
    fn dim_count(&self) -> usize;
    fn from_list(arr: Vec) -> Self;
}

pub trait VectorStatic: VectorAbstract {
    fn from_array(arr: [TValue; DIM_COUNT]) -> Self;
}

impl> VectorAbstract for TVector {
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        // ... dot product body for dynamic vectors ...
    }
}

impl>
    VectorAbstract for TVector
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        // ... dot product body for static vectors ...
    }
}

UPDATE 1

I also tried the following :

pub trait VectorStatic: VectorAbstract {
    const DIM_COUNT: usize;
    fn from_array(arr: [TValue; Self::DIM_COUNT]) -> Self;
}
impl> VectorAbstract for TVector {
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        // ... dot product body for static vectors ...
    }
}

But I get the following error where I'm declaring the from_array function :

generic parameters may not be used in const operations  
cannot perform const operation using `Self`  
note: type parameters may not be used in const expressions

Note : I want the DIM_COUNT to be obtained in compile time somehow, so no fn dim_count() for VectorStatic.

UPDATE 2

Also when I completely remove the implementation for VectorStatic, I get another error in another file where I have a Vector2 struct and try to implement VectorStatic for that:

pub struct Vector2 {
    pub x: TValue,
    pub y: TValue,
}
impl VectorStatic for Vector2 {
    // ... implementation ...
}

And here's the error :

the trait bound `math::algebra::vectors::vector2::Vector2: math::algebra::abstractions::VectorDynamic` is not satisfied
the trait `math::algebra::abstractions::VectorDynamic` is not implemented for `math::algebra::vectors::vector2::Vector2`

Note that this Vector2 struct is not supposed to be a VectorDynamic at all. There's definitely something I have not understood clearly here, maybe rust thinks I'm trying to make every VectorAbstract a VectorDynamic or something like that ?
What is it that I'm missing ?

UPDATE 3

Perhaps I should also mention that I already tried the following :

impl VectorAbstract for dyn VectorDynamic
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        // ... dot product body for dynamic vectors ...
    }
}
impl VectorAbstract for dyn VectorStatic
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        // ... dot product body for static vectors ...
    }
}

But in that case I get this error for both :

the trait `math::algebra::abstractions::VectorDynamic/VectorStatic` cannot be made into an object

and then a dozen lines that say because they used Self as a type parameter.

user_9014553 · Answer

The problem with your original code is that there are no guarantees that a type TVector will only implement VectorStatic and not implement VectorStatic which would give conflicting implementations of VectorAbstract.

Update 1 is the way to go, since that way a type cannot implement VectorStatic more than once. Currently this requires nightly rust with #![feature(generic_const_exprs)] added at the start of lib.rs/main.rs

The next problem will be the 2 impl-s of VectorAbstract. Again there is nothing to guarantee that TVector does not implement both VectorDynamic and VectorStatic which would give conflicting implementations of VectorAbstarct. As far as I know this cannot be done even with unstable features. The best way do it is to use wrapper structs.

VectorStatic1 + VectorStaticWrapper1 requires the added feature and works only in nightly rust version, VectorStatic2 + VectorStaticWrapper2 works in stable.

#![feature(generic_const_exprs)]

pub trait Scalar {}

pub trait VectorAbstract: 
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue;
}

pub trait VectorDynamic: VectorAbstract {
    fn dim_count(&self) -> usize;
    fn from_list(arr: Vec) -> Self;
}

pub trait VectorStatic1: VectorAbstract {
    const DIM_COUNT: usize;
    fn from_array(arr: [TValue; Self::DIM_COUNT]) -> Self;
}

pub trait VectorStatic2: VectorAbstract {
    fn from_array(arr: [TValue; DIM_COUNT]) -> Self;
}

struct VectorDynamicWrapper(T);
struct VectorStaticWrapper1(T);
struct VectorStaticWrapper2(T);

impl> VectorAbstract for VectorDynamicWrapper {
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        let lhs = &lhs.0;
        let rhs = &rhs.0;
        todo!()
    }
}

impl>
    VectorAbstract for VectorStaticWrapper1
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        let lhs = &lhs.0;
        let rhs = &rhs.0;
        let dim_count = TVector::DIM_COUNT;
        todo!()
    }
}

impl>
    VectorAbstract for VectorStaticWrapper2
{
    fn dot(lhs: &Self, rhs: &Self) -> TValue {
        let lhs = &lhs.0;
        let rhs = &rhs.0;
        todo!()
    }
}

using const generic in implementation of trait for another trait causes "unconstrained const parameter" error

1 Answers