feat(core): Add From<[T; N]> for LimitedVec

[mqxf]

Resolves #3641

• There is no way to compare M <= N in trait bounds
• static_assert!() doesnt work on const generics
• One potential solution I think could work uses where [(); {N - M}]:, however, it needs #![feature(generic_const_expr)]. If you think this is better I can change it to that

@reviewer-or-team

[mqxf]

Just threw this little test together:

#![feature(generic_const_exprs)]

#[derive(Clone, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LimitedVec<T, const N: usize>(Vec<T>);

impl<T, const M: usize, const N: usize> From<[T; M]> for LimitedVec<T, N>
    where [(); {N - M}]:
{
    fn from(value: [T; M]) -> Self {
        Self(value.into())
    }
}

fn main() {
    let a = [1, 2, 3];
    let b: LimitedVec<_, 5> = a.into();
    let c: LimitedVec<_, 3> = a.into();
    //let d: LimitedVec<_, 2> = a.into();
}

Where if the line is uncommented, compilation fails with this error:

error[E0080]: evaluation of `<LimitedVec<!0, 2> as std::convert::From<[!0; 3]>>::{constant#0}` failed
 --> src/main.rs:7:17
  |
7 |     where [(); {N - M}]:
  |                 ^^^^^ attempt to compute `2_usize - 3_usize`, which would overflow

I personally think this would be better than runtime assertion, but I do not know whether I can use this feature since it is techincally unstable, though should not arise any problems in this scenario.

[thecaralice]

Another option is using #![feature(associated_const_equality)] instead, which is, while technically still unstable, not as unstable as #![feature(generic_const_exprs)] is.
This is what I got while tinkering with this issue:

#![feature(associated_const_equality)]
use core::marker::PhantomData;

pub struct LimitedVec<T, E, const N: usize>(Vec<T>, PhantomData<E>);

macro_rules! const_conditions {
    ($($name:ident = |$($arg:ident: $argtype:ty),*| $result:expr;)*) => {
        $(
            enum $name<$(const $arg: $argtype),*> {}

            impl<$(const $arg: $argtype),*> $crate::ConstCondition for $name<$($arg),*> {
                const RESULT: bool = $result;
            }
        )*
    }
}

trait ConstCondition {
    const RESULT: bool;
}

const_conditions! {
    LessThan = |L: usize, R: usize| L < R;
}

impl<T, E, const M: usize, const N: usize> From<[T; M]> for LimitedVec<T, E, N>
where
    LessThan<N, M>: ConstCondition<RESULT = false>,
{
    fn from(value: [T; M]) -> Self {
        Self(value.into(), PhantomData)
    }
}

Or, without any macros,

#![feature(associated_const_equality)]

trait ConstCondition {
    const RESULT: bool;
}

enum LessThan<const L: usize, const R: usize> {}
impl<const L: usize, const R: usize> ConstCondition for LessThan<L, R> {
    const RESULT: bool = L < R;
}

impl<T, E, const M: usize, const N: usize> From<[T; M]> for LimitedVec<T, E, N>
where
    LessThan<N, M>: ConstCondition<RESULT = false>,
{
    fn from(value: [T; M]) -> Self {
        Self(value.into(), PhantomData)
    }
}

[mqxf]

That would probably be a better solution.

[thecaralice]

Note that there is a drawback: you can not just #[cfg] it out like in #3470, because the compiler will still complain about ACE usage (playground), unlike GCE (playground)

[techraed]

I'm against of assertions in runtime for such a type, that's mainly used in non-test code. It's not worth adding potentially not checked to be unreachable by tests panic in the trait impl that's needed only for tests.
If there's no other stable solution, then it seems better to close the PR and wait for stable.

[breathx]

+1

[mqxf]

There is no way to use static assertions without unstable features. static_assert!() doesnt work with const generics and everything else is gated behind unstable features. Unless it is fine to use them, which you have specified it isn't, then I'm going to close this PR until some feature becomes stable.

[StackOverflowExcept1on]

Try this: nvzqz/static-assertions#40 (comment)

[StackOverflowExcept1on]

Suggested change

	impl<T, E, const M: usize, const N: usize> From<[T; M]> for LimitedVec<T, E, N> {
	fn from(value: [T; M]) -> Self {
	assert!(M <= N);
	Self(value.into(), Default::default())
	}
	}
	struct LessThenOrEqual<const M: usize, const N: usize> {}
	impl<const M: usize, const N: usize> LessThenOrEqual<M, N> {
	const ASSERTION: () = assert!(M <= N);
	}
	impl<T, E, const M: usize, const N: usize> From<[T; M]> for LimitedVec<T, E, N> {
	fn from(value: [T; M]) -> Self {
	let _ = LessThenOrEqual::<M, N>::ASSERTION;
	Self(value.into(), Default::default())
	}
	}

[StackOverflowExcept1on]

please also replace places where ::from can be used

[mqxf]

this is still runtime assertion isnt it?

[breathx]

this is still runtime assertion isnt it?

No

[mqxf]

static assertions unfortunately cant work on const generics

[mqxf]

Since it is not preferable to use runtime assertions, and all static assertions I am aware of are gated behind unstable features, which I shouldn't use. I am going to close this PR.