diff --git a/CHANGELOG.md b/CHANGELOG.md
index 848a81a507..63d43becb1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `format` macro.
 - Added `String::from_utf16`.
 - Added `is_full`, `recent_index`, `oldest`, and `oldest_index` to `HistoryBuffer`
+- Added an optional generic parameter to `Vec` to specify the alignment of the backing array.
 - Added infallible conversions from arrays to `Vec`.
 
 ### Changed
diff --git a/cfail/ui/not-send.stderr b/cfail/ui/not-send.stderr
index 40645b7a6d..c1820775c5 100644
--- a/cfail/ui/not-send.stderr
+++ b/cfail/ui/not-send.stderr
@@ -80,10 +80,15 @@ note: required because it appears within the type `ManuallyDrop<PhantomData<*con
 note: required because it appears within the type `MaybeUninit<PhantomData<*const ()>>`
   --> $RUST/core/src/mem/maybe_uninit.rs
    = note: required because it appears within the type `[MaybeUninit<PhantomData<*const ()>>; 4]`
+note: required because it appears within the type `VecBuf<PhantomData<*const ()>, 4, u8>`
+  --> $HEAPLESS/src/vec.rs
+   |
+   | struct VecBuf<T, const N: usize, A> {
+   |        ^^^^^^
 note: required because it appears within the type `Vec<PhantomData<*const ()>, 4>`
   --> $HEAPLESS/src/vec.rs
    |
-   | pub struct Vec<T, const N: usize> {
+   | pub struct Vec<T, const N: usize, A = u8> {
    |            ^^^
 note: required by a bound in `is_send`
   --> ui/not-send.rs:14:8
diff --git a/src/vec.rs b/src/vec.rs
index 2df7d86c1c..34bdab5727 100644
--- a/src/vec.rs
+++ b/src/vec.rs
@@ -7,6 +7,12 @@ use core::{
     ops, ptr, slice,
 };
 
+#[repr(C)]
+struct VecBuf<T, const N: usize, A> {
+    alignment_field: [A; 0],
+    buffer: [MaybeUninit<T>; N],
+}
+
 /// A fixed capacity [`Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html).
 ///
 /// # Examples
@@ -35,20 +41,52 @@ use core::{
 /// }
 /// assert_eq!(*vec, [7, 1, 2, 3]);
 /// ```
-pub struct Vec<T, const N: usize> {
+pub struct Vec<T, const N: usize, A = u8> {
     // NOTE order is important for optimizations. the `len` first layout lets the compiler optimize
     // `new` to: reserve stack space and zero the first word. With the fields in the reverse order
     // the compiler optimizes `new` to `memclr`-ing the *entire* stack space, including the `buffer`
     // field which should be left uninitialized. Optimizations were last checked with Rust 1.60
     len: usize,
 
-    buffer: [MaybeUninit<T>; N],
+    // self.buffer.buffer access is greatly discouraged. Use the respective methods instead.
+    buffer: VecBuf<T, N, A>,
 }
 
-impl<T, const N: usize> Vec<T, N> {
+impl<T, const N: usize, A> VecBuf<T, N, A> {
     const ELEM: MaybeUninit<T> = MaybeUninit::uninit();
     const INIT: [MaybeUninit<T>; N] = [Self::ELEM; N]; // important for optimization of `new`
 
+    const fn new() -> Self {
+        Self {
+            alignment_field: [],
+            buffer: Self::INIT,
+        }
+    }
+
+    const fn as_ptr(&self) -> *const T {
+        self.buffer.as_ptr() as *const T
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut T {
+        self.buffer.as_mut_ptr() as *mut T
+    }
+}
+
+impl<T, const N: usize, A> ops::Deref for VecBuf<T, N, A> {
+    type Target = [MaybeUninit<T>; N];
+
+    fn deref(&self) -> &[MaybeUninit<T>; N] {
+        &self.buffer
+    }
+}
+
+impl<T, const N: usize, A> ops::DerefMut for VecBuf<T, N, A> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.buffer
+    }
+}
+
+impl<T, const N: usize, A> Vec<T, N, A> {
     /// Constructs a new, empty vector with a fixed capacity of `N`
     ///
     /// # Examples
@@ -66,7 +104,7 @@ impl<T, const N: usize> Vec<T, N> {
     pub const fn new() -> Self {
         Self {
             len: 0,
-            buffer: Self::INIT,
+            buffer: VecBuf::new(),
         }
     }
 
@@ -118,8 +156,10 @@ impl<T, const N: usize> Vec<T, N> {
                 buffer: unsafe { mem::transmute_copy(&src) },
             }
         } else {
-            let mut v = Vec::<T, N>::new();
+            let mut v = Vec::<T, N, A>::new();
 
+            // `for` is not allowed in a `const fn`
+            // see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information.
             for (src_elem, dst_elem) in src.iter().zip(v.buffer.iter_mut()) {
                 // NOTE(unsafe) src element is not going to drop as src itself
                 // is wrapped in a ManuallyDrop.
@@ -148,12 +188,12 @@ impl<T, const N: usize> Vec<T, N> {
 
     /// Returns a raw pointer to the vector’s buffer.
     pub fn as_ptr(&self) -> *const T {
-        self.buffer.as_ptr() as *const T
+        self.buffer.as_ptr()
     }
 
     /// Returns a raw pointer to the vector’s buffer, which may be mutated through.
     pub fn as_mut_ptr(&mut self) -> *mut T {
-        self.buffer.as_mut_ptr() as *mut T
+        self.buffer.as_mut_ptr()
     }
 
     /// Extracts a slice containing the entire vector.
@@ -170,7 +210,7 @@ impl<T, const N: usize> Vec<T, N> {
     pub fn as_slice(&self) -> &[T] {
         // NOTE(unsafe) avoid bound checks in the slicing operation
         // &buffer[..self.len]
-        unsafe { slice::from_raw_parts(self.buffer.as_ptr() as *const T, self.len) }
+        unsafe { slice::from_raw_parts(self.as_ptr(), self.len) }
     }
 
     /// Returns the contents of the vector as an array of length `M` if the length
@@ -187,7 +227,7 @@ impl<T, const N: usize> Vec<T, N> {
     pub fn into_array<const M: usize>(self) -> Result<[T; M], Self> {
         if self.len() == M {
             // This is how the unstable `MaybeUninit::array_assume_init` method does it
-            let array = unsafe { (&self.buffer as *const _ as *const [T; M]).read() };
+            let array = unsafe { (self.as_ptr() as *const [T; M]).read() };
 
             // We don't want `self`'s destructor to be called because that would drop all the
             // items in the array
@@ -214,7 +254,7 @@ impl<T, const N: usize> Vec<T, N> {
     pub fn as_mut_slice(&mut self) -> &mut [T] {
         // NOTE(unsafe) avoid bound checks in the slicing operation
         // &mut buffer[..self.len]
-        unsafe { slice::from_raw_parts_mut(self.buffer.as_mut_ptr() as *mut T, self.len) }
+        unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
     }
 
     /// Returns the maximum number of elements the vector can hold.
@@ -787,14 +827,14 @@ impl<T, const N: usize> Vec<T, N> {
         // This drop guard will be invoked when predicate or `drop` of element panicked.
         // It shifts unchecked elements to cover holes and `set_len` to the correct length.
         // In cases when predicate and `drop` never panick, it will be optimized out.
-        struct BackshiftOnDrop<'a, T, const N: usize> {
-            v: &'a mut Vec<T, N>,
+        struct BackshiftOnDrop<'a, T, const N: usize, A> {
+            v: &'a mut Vec<T, N, A>,
             processed_len: usize,
             deleted_cnt: usize,
             original_len: usize,
         }
 
-        impl<T, const N: usize> Drop for BackshiftOnDrop<'_, T, N> {
+        impl<T, const N: usize, A> Drop for BackshiftOnDrop<'_, T, N, A> {
             fn drop(&mut self) {
                 if self.deleted_cnt > 0 {
                     // SAFETY: Trailing unchecked items must be valid since we never touch them.
@@ -822,10 +862,10 @@ impl<T, const N: usize> Vec<T, N> {
             original_len,
         };
 
-        fn process_loop<F, T, const N: usize, const DELETED: bool>(
+        fn process_loop<F, T, const N: usize, A, const DELETED: bool>(
             original_len: usize,
             f: &mut F,
-            g: &mut BackshiftOnDrop<'_, T, N>,
+            g: &mut BackshiftOnDrop<'_, T, N, A>,
         ) where
             F: FnMut(&mut T) -> bool,
         {
@@ -859,10 +899,10 @@ impl<T, const N: usize> Vec<T, N> {
         }
 
         // Stage 1: Nothing was deleted.
-        process_loop::<F, T, N, false>(original_len, &mut f, &mut g);
+        process_loop::<F, T, N, A, false>(original_len, &mut f, &mut g);
 
         // Stage 2: Some elements were deleted.
-        process_loop::<F, T, N, true>(original_len, &mut f, &mut g);
+        process_loop::<F, T, N, A, true>(original_len, &mut f, &mut g);
 
         // All item are processed. This can be optimized to `set_len` by LLVM.
         drop(g);
@@ -871,13 +911,13 @@ impl<T, const N: usize> Vec<T, N> {
 
 // Trait implementations
 
-impl<T, const N: usize> Default for Vec<T, N> {
+impl<T, const N: usize, A> Default for Vec<T, N, A> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<T, const N: usize> fmt::Debug for Vec<T, N>
+impl<T, const N: usize, A> fmt::Debug for Vec<T, N, A>
 where
     T: fmt::Debug,
 {
@@ -895,7 +935,7 @@ impl<const N: usize> fmt::Write for Vec<u8, N> {
     }
 }
 
-impl<T, const N: usize> Drop for Vec<T, N> {
+impl<T, const N: usize, A> Drop for Vec<T, N, A> {
     fn drop(&mut self) {
         // We drop each element used in the vector by turning into a `&mut [T]`.
         unsafe {
@@ -904,13 +944,13 @@ impl<T, const N: usize> Drop for Vec<T, N> {
     }
 }
 
-impl<T, const N: usize, const M: usize> From<[T; M]> for Vec<T, N> {
+impl<T, const N: usize, const M: usize, A> From<[T; M]> for Vec<T, N, A> {
     fn from(array: [T; M]) -> Self {
         Self::from_array(array)
     }
 }
 
-impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {
+impl<'a, T: Clone, const N: usize, A> TryFrom<&'a [T]> for Vec<T, N, A> {
     type Error = ();
 
     fn try_from(slice: &'a [T]) -> Result<Self, Self::Error> {
@@ -918,7 +958,7 @@ impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {
     }
 }
 
-impl<T, const N: usize> Extend<T> for Vec<T, N> {
+impl<T, const N: usize, A> Extend<T> for Vec<T, N, A> {
     fn extend<I>(&mut self, iter: I)
     where
         I: IntoIterator<Item = T>,
@@ -927,7 +967,7 @@ impl<T, const N: usize> Extend<T> for Vec<T, N> {
     }
 }
 
-impl<'a, T, const N: usize> Extend<&'a T> for Vec<T, N>
+impl<'a, T, const N: usize, A> Extend<&'a T> for Vec<T, N, A>
 where
     T: 'a + Copy,
 {
@@ -939,7 +979,7 @@ where
     }
 }
 
-impl<T, const N: usize> hash::Hash for Vec<T, N>
+impl<T, const N: usize, A> hash::Hash for Vec<T, N, A>
 where
     T: core::hash::Hash,
 {
@@ -948,7 +988,7 @@ where
     }
 }
 
-impl<'a, T, const N: usize> IntoIterator for &'a Vec<T, N> {
+impl<'a, T, const N: usize, A> IntoIterator for &'a Vec<T, N, A> {
     type Item = &'a T;
     type IntoIter = slice::Iter<'a, T>;
 
@@ -957,7 +997,7 @@ impl<'a, T, const N: usize> IntoIterator for &'a Vec<T, N> {
     }
 }
 
-impl<'a, T, const N: usize> IntoIterator for &'a mut Vec<T, N> {
+impl<'a, T, const N: usize, A> IntoIterator for &'a mut Vec<T, N, A> {
     type Item = &'a mut T;
     type IntoIter = slice::IterMut<'a, T>;
 
@@ -966,7 +1006,7 @@ impl<'a, T, const N: usize> IntoIterator for &'a mut Vec<T, N> {
     }
 }
 
-impl<T, const N: usize> FromIterator<T> for Vec<T, N> {
+impl<T, const N: usize, A> FromIterator<T> for Vec<T, N, A> {
     fn from_iter<I>(iter: I) -> Self
     where
         I: IntoIterator<Item = T>,
@@ -982,12 +1022,12 @@ impl<T, const N: usize> FromIterator<T> for Vec<T, N> {
 /// An iterator that moves out of an [`Vec`][`Vec`].
 ///
 /// This struct is created by calling the `into_iter` method on [`Vec`][`Vec`].
-pub struct IntoIter<T, const N: usize> {
-    vec: Vec<T, N>,
+pub struct IntoIter<T, const N: usize, A> {
+    vec: Vec<T, N, A>,
     next: usize,
 }
 
-impl<T, const N: usize> Iterator for IntoIter<T, N> {
+impl<T, const N: usize, A> Iterator for IntoIter<T, N, A> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
         if self.next < self.vec.len() {
@@ -1000,7 +1040,7 @@ impl<T, const N: usize> Iterator for IntoIter<T, N> {
     }
 }
 
-impl<T, const N: usize> Clone for IntoIter<T, N>
+impl<T, const N: usize, A> Clone for IntoIter<T, N, A>
 where
     T: Clone,
 {
@@ -1010,7 +1050,7 @@ where
         if self.next < self.vec.len() {
             let s = unsafe {
                 slice::from_raw_parts(
-                    (self.vec.buffer.as_ptr() as *const T).add(self.next),
+                    (self.vec.buffer.as_ptr()).add(self.next),
                     self.vec.len() - self.next,
                 )
             };
@@ -1021,7 +1061,7 @@ where
     }
 }
 
-impl<T, const N: usize> Drop for IntoIter<T, N> {
+impl<T, const N: usize, A> Drop for IntoIter<T, N, A> {
     fn drop(&mut self) {
         unsafe {
             // Drop all the elements that have not been moved out of vec
@@ -1032,141 +1072,142 @@ impl<T, const N: usize> Drop for IntoIter<T, N> {
     }
 }
 
-impl<T, const N: usize> IntoIterator for Vec<T, N> {
+impl<T, const N: usize, A> IntoIterator for Vec<T, N, A> {
     type Item = T;
-    type IntoIter = IntoIter<T, N>;
+    type IntoIter = IntoIter<T, N, A>;
 
     fn into_iter(self) -> Self::IntoIter {
         IntoIter { vec: self, next: 0 }
     }
 }
 
-impl<A, B, const N1: usize, const N2: usize> PartialEq<Vec<B, N2>> for Vec<A, N1>
+impl<T1, T2, const N1: usize, const N2: usize, A1, A2> PartialEq<Vec<T2, N2, A2>>
+    for Vec<T1, N1, A1>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<B, N2>) -> bool {
-        <[A]>::eq(self, &**other)
+    fn eq(&self, other: &Vec<T2, N2, A2>) -> bool {
+        <[T1]>::eq(self, &**other)
     }
 }
 
 // Vec<A, N> == [B]
-impl<A, B, const N: usize> PartialEq<[B]> for Vec<A, N>
+impl<T1, T2, const N: usize, A> PartialEq<[T2]> for Vec<T1, N, A>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &[B]) -> bool {
-        <[A]>::eq(self, other)
+    fn eq(&self, other: &[T2]) -> bool {
+        <[T1]>::eq(self, other)
     }
 }
 
 // [B] == Vec<A, N>
-impl<A, B, const N: usize> PartialEq<Vec<A, N>> for [B]
+impl<T1, T2, const N: usize, A> PartialEq<Vec<T1, N, A>> for [T2]
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<A, N>) -> bool {
-        <[A]>::eq(other, self)
+    fn eq(&self, other: &Vec<T1, N, A>) -> bool {
+        <[T1]>::eq(other, self)
     }
 }
 
 // Vec<A, N> == &[B]
-impl<A, B, const N: usize> PartialEq<&[B]> for Vec<A, N>
+impl<T1, T2, const N: usize, A> PartialEq<&[T2]> for Vec<T1, N, A>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &&[B]) -> bool {
-        <[A]>::eq(self, &other[..])
+    fn eq(&self, other: &&[T2]) -> bool {
+        <[T1]>::eq(self, &other[..])
     }
 }
 
 // &[B] == Vec<A, N>
-impl<A, B, const N: usize> PartialEq<Vec<A, N>> for &[B]
+impl<T1, T2, const N: usize, A> PartialEq<Vec<T1, N, A>> for &[T2]
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<A, N>) -> bool {
-        <[A]>::eq(other, &self[..])
+    fn eq(&self, other: &Vec<T1, N, A>) -> bool {
+        <[T1]>::eq(other, &self[..])
     }
 }
 
 // Vec<A, N> == &mut [B]
-impl<A, B, const N: usize> PartialEq<&mut [B]> for Vec<A, N>
+impl<T1, T2, const N: usize, A> PartialEq<&mut [T2]> for Vec<T1, N, A>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &&mut [B]) -> bool {
-        <[A]>::eq(self, &other[..])
+    fn eq(&self, other: &&mut [T2]) -> bool {
+        <[T1]>::eq(self, &other[..])
     }
 }
 
 // &mut [B] == Vec<A, N>
-impl<A, B, const N: usize> PartialEq<Vec<A, N>> for &mut [B]
+impl<T1, T2, const N: usize, A> PartialEq<Vec<T1, N, A>> for &mut [T2]
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<A, N>) -> bool {
-        <[A]>::eq(other, &self[..])
+    fn eq(&self, other: &Vec<T1, N, A>) -> bool {
+        <[T1]>::eq(other, &self[..])
     }
 }
 
 // Vec<A, N> == [B; M]
 // Equality does not require equal capacity
-impl<A, B, const N: usize, const M: usize> PartialEq<[B; M]> for Vec<A, N>
+impl<T1, T2, const N: usize, const M: usize, A> PartialEq<[T2; M]> for Vec<T1, N, A>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &[B; M]) -> bool {
-        <[A]>::eq(self, &other[..])
+    fn eq(&self, other: &[T2; M]) -> bool {
+        <[T1]>::eq(self, &other[..])
     }
 }
 
 // [B; M] == Vec<A, N>
 // Equality does not require equal capacity
-impl<A, B, const N: usize, const M: usize> PartialEq<Vec<A, N>> for [B; M]
+impl<T1, T2, const N: usize, const M: usize, A> PartialEq<Vec<T1, N, A>> for [T2; M]
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<A, N>) -> bool {
-        <[A]>::eq(other, &self[..])
+    fn eq(&self, other: &Vec<T1, N, A>) -> bool {
+        <[T1]>::eq(other, &self[..])
     }
 }
 
 // Vec<A, N> == &[B; M]
 // Equality does not require equal capacity
-impl<A, B, const N: usize, const M: usize> PartialEq<&[B; M]> for Vec<A, N>
+impl<T1, T2, const N: usize, const M: usize, A> PartialEq<&[T2; M]> for Vec<T1, N, A>
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &&[B; M]) -> bool {
-        <[A]>::eq(self, &other[..])
+    fn eq(&self, other: &&[T2; M]) -> bool {
+        <[T1]>::eq(self, &other[..])
     }
 }
 
 // &[B; M] == Vec<A, N>
 // Equality does not require equal capacity
-impl<A, B, const N: usize, const M: usize> PartialEq<Vec<A, N>> for &[B; M]
+impl<T1, T2, const N: usize, const M: usize, A> PartialEq<Vec<T1, N, A>> for &[T2; M]
 where
-    A: PartialEq<B>,
+    T1: PartialEq<T2>,
 {
-    fn eq(&self, other: &Vec<A, N>) -> bool {
-        <[A]>::eq(other, &self[..])
+    fn eq(&self, other: &Vec<T1, N, A>) -> bool {
+        <[T1]>::eq(other, &self[..])
     }
 }
 
 // Implements Eq if underlying data is Eq
-impl<T, const N: usize> Eq for Vec<T, N> where T: Eq {}
+impl<T, const N: usize, A> Eq for Vec<T, N, A> where T: Eq {}
 
-impl<T, const N1: usize, const N2: usize> PartialOrd<Vec<T, N2>> for Vec<T, N1>
+impl<T, const N1: usize, const N2: usize, A1, A2> PartialOrd<Vec<T, N2, A2>> for Vec<T, N1, A1>
 where
     T: PartialOrd,
 {
-    fn partial_cmp(&self, other: &Vec<T, N2>) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &Vec<T, N2, A2>) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
 
-impl<T, const N: usize> Ord for Vec<T, N>
+impl<T, const N: usize, A> Ord for Vec<T, N, A>
 where
     T: Ord,
 {
@@ -1176,7 +1217,7 @@ where
     }
 }
 
-impl<T, const N: usize> ops::Deref for Vec<T, N> {
+impl<T, const N: usize, A> ops::Deref for Vec<T, N, A> {
     type Target = [T];
 
     fn deref(&self) -> &[T] {
@@ -1184,41 +1225,41 @@ impl<T, const N: usize> ops::Deref for Vec<T, N> {
     }
 }
 
-impl<T, const N: usize> ops::DerefMut for Vec<T, N> {
+impl<T, const N: usize, A> ops::DerefMut for Vec<T, N, A> {
     fn deref_mut(&mut self) -> &mut [T] {
         self.as_mut_slice()
     }
 }
 
-impl<T, const N: usize> AsRef<Vec<T, N>> for Vec<T, N> {
+impl<T, const N: usize, A> AsRef<Vec<T, N, A>> for Vec<T, N, A> {
     #[inline]
     fn as_ref(&self) -> &Self {
         self
     }
 }
 
-impl<T, const N: usize> AsMut<Vec<T, N>> for Vec<T, N> {
+impl<T, const N: usize, A> AsMut<Vec<T, N, A>> for Vec<T, N, A> {
     #[inline]
     fn as_mut(&mut self) -> &mut Self {
         self
     }
 }
 
-impl<T, const N: usize> AsRef<[T]> for Vec<T, N> {
+impl<T, const N: usize, A> AsRef<[T]> for Vec<T, N, A> {
     #[inline]
     fn as_ref(&self) -> &[T] {
         self
     }
 }
 
-impl<T, const N: usize> AsMut<[T]> for Vec<T, N> {
+impl<T, const N: usize, A> AsMut<[T]> for Vec<T, N, A> {
     #[inline]
     fn as_mut(&mut self) -> &mut [T] {
         self
     }
 }
 
-impl<T, const N: usize> Clone for Vec<T, N>
+impl<T, const N: usize, A> Clone for Vec<T, N, A>
 where
     T: Clone,
 {