Crate hybrid_array

RustCrypto: Hybrid Const Generic / Typenum Arrays

Hybrid array type combining const generics with the expressiveness of typenum-based constraints, providing an alternative to generic-array and a incremental transition path to const generics.

About

This crate uses typenum to enable the following features which aren’t yet possible with the stable implementation of const generics:

• #60551: Associated constants in traits can not be used in const generics
• #76560: Complex generic constants: feature(generic_const_exprs)

Internally the crate is built on const generics and provides traits which make it possible to convert between const generic types and typenum types.

Features

This crate exposes the following feature flags. The default is NO features.

• zeroize - Implements Zeroize for Array<T: Zeroize, U>

License

Licensed under either of:

• Apache License, Version 2.0
• MIT license

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Usage

The two core types in this crate are as follows:

• Array<T, U>: wrapper for [T; N] where U is an ArraySize provided by typenum whose associated ArraySize::ArrayType<T> determines the inner array size.
• ArrayN<T, N>: type alias for Array which is const generic around const N: usize. This provides a linkage between const generics and typenum.

The Array type has an inner pub [T; N] field, which means writing a literal can be expressed as follows:

use hybrid_array::{Array, consts::U4};

let arr: Array<u8, U4> = Array([1, 2, 3, 4]);

Relationship with generic-array

hybrid-array is directly inspired by the generic-array crate.

However, where generic-array predates const generics and uses a core which is built on unsafe code, hybrid-array’s core implementation is built on safe code and const generic implementations. This allows the inner [T; N] field of an Array to be pub as noted above, and in general for the implementation to be significantly simpler and easier-to-audit.

The only places hybrid-array uses unsafe are where it is absolutely necessary, primarily for reference conversions between Array<T, U> and [T; N], and also to provide features which are not yet stable in core/std, such as Array::try_from_fn.

Migrating from generic-array

NOTE: this guide assumes a migration from generic-array v0.14

hybrid-array has been designed to largely be a drop-in replacement for generic-array, albeit with a public inner array type and significantly less unsafe code.

Migrating should hopefully be relatively painless with the following substitutions in your .rs files:

• Replace generic_array with hybrid_array
• Replace GenericArray<T, U> with Array<T, U>
• Replace ArrayLength<T> with ArraySize
• Replace <U as ArrayLength<T>>::ArrayType with <U as ArraySize>::ArrayType<T>
• Replace usages of the arr![N; A, B, C] macro with Array([A, B, C])

If you have any questions, please start a discussion.

Re-exports

• pub use typenum;

Modules

• consts
  Type aliases for many constants.

Structs

• Array
  Array is a newtype for an inner [T; N] array where N is determined by a generic ArraySize parameter, which is a marker trait for a numeric value determined by ZSTs that impl the typenum::Unsigned trait.
• TryFromIteratorError
  Couldn’t construct an array from an iterator because the number of items in the iterator didn’t match the array size.

Traits

• ArraySize
  Trait which associates a usize size and ArrayType with a typenum-provided Unsigned integer.
• AssocArraySize
  Associates an ArraySize with a given type.

Type Aliases

• ArrayN
  Type alias for Array which is const generic around a size N, ala [T; N].