Problem

There's multiple design patterns that result in the need to declare generic array lenghts that are calculated on some other generic value.

Examples include:

impl<T, const N: usize> [T; N] {
    fn split_first(self) -> (T, [T; N - 1]) {
        ...
    }
}

or

trait Serialize<N> {
    fn serialize(self) -> [Field; N];
}

struct Foo<T> {
    a: T,
    b: T,
}

impl<T, N> Serialize<N * 2> for Foo<T> {
    fn serialize(self) -> [Field; N * 2] where T: Serialize<N> {
      ...
    }
}

Happy Case

I'd want to be able to both have numeric generics without having to resort to the workaround from #4633, and to be able to perform basic arithmetic on them. My current use case is to do addition to both other generics and constants (e.g. N + N + 1), but it seems multiplication and subtraction are common patterns as well.

Project Impact

Blocker

Impact Context

Lack of this feature blocks multiple things, such as flatten as requested by @LogvinovLeon here, or AztecProtocol/aztec-packages#5492 which is required for non-trivial aztec-nr data structures.

This is also related to #4633, since many of the above fall into scenarios where the current workaround to force a generic value to be numeric (i.e. make it an array length) don't work.

Workaround

None