array-append

array-append exports a small family of functions for working with const-generic array types:

• concat which concatenates two arrays
• push_right and push_left which add an element to the end or beginning of an array respectively
• split and split_end which split an array into two arrays
• pop_right and pop_left which separate the last or first element respectively from an array

And a few aliases:

• push/pop for push_right/pop_right respectively
• unshift/shift for push_left/pop_left respectively

This library requires a nightly compiler due to the use of #![feature(generic_const_exprs)]. All unsafe code has been verified to be sound by manual proof and Miri.

This library does not yet require the standard library, but it is brought in anyway unless the std default feature is disabled. This is for forward-compatibility in case std-dependent code is ever added.

Example

Create a no-alloc builder:

```rust

![allow(incomplete_features)]

![feature(genericconstexprs)]

use array_append::push;

[derive(PartialEq, Debug)]

struct Built { whatever: [usize; N] }

struct Builder { whatever: [usize; N] }

impl Builder<0> { pub fn new() -> Self { Self { whatever: [] } } }

impl Builder { pub fn from_array(array: [usize; N]) -> Self { Self { whatever: array } }

pub fn with_usize(self, new: usize) -> Builder<{N + 1}> {
    // Can't use `Self` here, because `Self` is `Builder<N>`
    Builder { whatever: push(self.whatever, new) }
}

pub fn build(self) -> Built<N> {
    Built { whatever: self.whatever }
}

}

asserteq!( Builder::new() .withusize(1) .withusize(2) .withusize(3) .build(), Builder::from_array([1, 2, 3]).build() ); ```