No way to use extend supported array lengths

[rozbb]

As we discussed here, there is currently no way to define an Array of a length that doesn't explicitly appear in sizes.rs (of which there are only 272). For example, a FireSaber public key cannot be created:

type U1472 = typenum::op!(U1000 + U472);
let mut pk: Array<u8, U1472> = Array::default();

This will fail with the error

    |     let mut pk: Array<u8, U1472> = Array::default();
    |                 ^^^^^^^^^^^^^^^^ the trait `traits::ArraySize` is not implemented for `UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>`

It isn't clear how to resolve this. Even with macro magic, a downstream crate is not allowed to impl ArraySize for external types (ie types from typenum).

[rozbb]

A weird far-fetched idea: Maybe we can have a wrap_uint!() macro that takes eg U1472 and turns it into a newtype that's fully compatible with the rest of typenum (this is prob either impossible or very annoying). Then hybrid-array can expose a macro that takes the resulting newtype and impls ArraySize for it. This probably would break in weird ways for concat() tho

[tarcieri]

This is a fundamental tradeoff with how hybrid-array is designed versus generic-array.

The latter's solution is to use opaque ArraySize::ArrayTypes and large gobs of unsafe code to calculate and manipulate array sizes, whereas hybrid-array is built on core arrays using ArraySize as the linkage to core arrays (which permits inner visibility of the ArraySize::ArrayType as well as safe const generic conversions between Array and core arrays), so the trait impls need to exist.

#46 extends ArraySize through U1024. It seems I'll need to further extend it, but to do that I'll need to compute typenum bit patterns for the larger sizes.

In RustCrypto/KEMs#2 I suggested we could potentially extend it for multiples of some power of two, for example through U1024-U4096 by multiples of 32.

[tarcieri]

A weird far-fetched idea: Maybe we can have a wrap_uint!() macro that takes eg U1472 and turns it into a newtype that's fully compatible with the rest of typenum

Well, there's typenum::U<N> which is built on typenum::Const<N> which I explored in #41. Unfortunately it also does not support these larger sizes and similarly ends around 1024: https://docs.rs/typenum/1.17.0/typenum/generic_const_mappings/struct.Const.html#impl-ToUInt-for-Const%3C1024%3E

Then hybrid-array can expose a macro that takes the resulting newtype and impls ArraySize for it.

I did try to use typenum::U to define the array sizes so it could simply take a list of integers as opposed to the current 256 => U256 mapping but I couldn't get it to work. See my notes in #41.

[tarcieri]

#49 adds support for U1472 among others

[tarcieri]

So really, this problem is "unfixable" in that the only way to extend support is in the hybrid-array crate itself. The ArraySize trait is bounded on Unsigned and therefore doesn't support external impls, which is somewhat deliberate.

We can add additional sizes as needed on a case-by-case basis. Perhaps the generation of sizes.rs could be fully automated.

Closing this as "won't fix": really the only alternative is what generic-array already does, which is implement the linkage between a typenum size and the underlying array size using unsafe code, whereas hybrid-array uses safe, simple, const generic code.