diff --git a/src/binary_heap.rs b/src/binary_heap.rs
index 7e676a3851..a72e099599 100644
--- a/src/binary_heap.rs
+++ b/src/binary_heap.rs
@@ -17,10 +17,7 @@ use core::{
     ptr, slice,
 };
 
-use crate::{
-    storage::{OwnedStorage, Storage, ViewStorage},
-    vec::{Vec, VecInner},
-};
+use crate::vec::{OwnedVecStorage, Vec, VecInner, VecStorage, ViewVecStorage};
 
 /// Min-heap
 pub enum Min {}
@@ -58,7 +55,7 @@ impl private::Sealed for Min {}
 ///
 /// In most cases you should use [`BinaryHeap`] or [`BinaryHeapView`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct BinaryHeapInner<T, K, S: Storage> {
+pub struct BinaryHeapInner<T, K, S: VecStorage<T> + ?Sized> {
     pub(crate) _kind: PhantomData<K>,
     pub(crate) data: VecInner<T, S>,
 }
@@ -109,7 +106,7 @@ pub struct BinaryHeapInner<T, K, S: Storage> {
 /// // The heap should now be empty.
 /// assert!(heap.is_empty())
 /// ```
-pub type BinaryHeap<T, K, const N: usize> = BinaryHeapInner<T, K, OwnedStorage<N>>;
+pub type BinaryHeap<T, K, const N: usize> = BinaryHeapInner<T, K, OwnedVecStorage<T, N>>;
 
 /// A priority queue implemented with a binary heap.
 ///
@@ -158,7 +155,7 @@ pub type BinaryHeap<T, K, const N: usize> = BinaryHeapInner<T, K, OwnedStorage<N
 /// // The heap should now be empty.
 /// assert!(heap.is_empty())
 /// ```
-pub type BinaryHeapView<T, K> = BinaryHeapInner<T, K, ViewStorage>;
+pub type BinaryHeapView<T, K> = BinaryHeapInner<T, K, ViewVecStorage<T>>;
 
 impl<T, K, const N: usize> BinaryHeap<T, K, N> {
     /* Constructors */
@@ -198,7 +195,7 @@ impl<T, K, const N: usize> BinaryHeap<T, K, N> {
     }
 }
 
-impl<T, K, S: Storage> BinaryHeapInner<T, K, S>
+impl<T, K, S: VecStorage<T> + ?Sized> BinaryHeapInner<T, K, S>
 where
     T: Ord,
     K: Kind,
@@ -519,7 +516,7 @@ pub struct PeekMutInner<'a, T, K, S>
 where
     T: Ord,
     K: Kind,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     heap: &'a mut BinaryHeapInner<T, K, S>,
     sift: bool,
@@ -530,20 +527,20 @@ where
 ///
 /// This `struct` is created by [`BinaryHeap::peek_mut`].
 /// See its documentation for more.
-pub type PeekMut<'a, T, K, const N: usize> = PeekMutInner<'a, T, K, OwnedStorage<N>>;
+pub type PeekMut<'a, T, K, const N: usize> = PeekMutInner<'a, T, K, OwnedVecStorage<T, N>>;
 
 /// Structure wrapping a mutable reference to the greatest item on a
 /// `BinaryHeap`.
 ///
 /// This `struct` is created by [`BinaryHeapView::peek_mut`].
 /// See its documentation for more.
-pub type PeekMutView<'a, T, K> = PeekMutInner<'a, T, K, ViewStorage>;
+pub type PeekMutView<'a, T, K> = PeekMutInner<'a, T, K, ViewVecStorage<T>>;
 
 impl<T, K, S> Drop for PeekMutInner<'_, T, K, S>
 where
     T: Ord,
     K: Kind,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     fn drop(&mut self) {
         if self.sift {
@@ -556,7 +553,7 @@ impl<T, K, S> Deref for PeekMutInner<'_, T, K, S>
 where
     T: Ord,
     K: Kind,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     type Target = T;
     fn deref(&self) -> &T {
@@ -570,7 +567,7 @@ impl<T, K, S> DerefMut for PeekMutInner<'_, T, K, S>
 where
     T: Ord,
     K: Kind,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     fn deref_mut(&mut self) -> &mut T {
         debug_assert!(!self.heap.is_empty());
@@ -583,7 +580,7 @@ impl<'a, T, K, S> PeekMutInner<'a, T, K, S>
 where
     T: Ord,
     K: Kind,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     /// Removes the peeked value from the heap and returns it.
     pub fn pop(mut this: PeekMutInner<'a, T, K, S>) -> T {
@@ -631,7 +628,7 @@ impl<T, K, S> fmt::Debug for BinaryHeapInner<T, K, S>
 where
     K: Kind,
     T: Ord + fmt::Debug,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
@@ -642,7 +639,7 @@ impl<'a, T, K, S> IntoIterator for &'a BinaryHeapInner<T, K, S>
 where
     K: Kind,
     T: Ord,
-    S: Storage,
+    S: VecStorage<T> + ?Sized,
 {
     type Item = &'a T;
     type IntoIter = slice::Iter<'a, T>;
@@ -656,7 +653,7 @@ where
 mod tests {
     use static_assertions::assert_not_impl_any;
 
-    use super::{BinaryHeap, Max, Min};
+    use super::{BinaryHeap, BinaryHeapView, Max, Min};
 
     // Ensure a `BinaryHeap` containing `!Send` values stays `!Send` itself.
     assert_not_impl_any!(BinaryHeap<*const (), Max, 4>: Send);
@@ -829,4 +826,13 @@ mod tests {
         assert_eq!(heap.pop(), Some(1));
         assert_eq!(heap.pop(), None);
     }
+
+    fn _test_variance<'a: 'b, 'b>(x: BinaryHeap<&'a (), Max, 42>) -> BinaryHeap<&'b (), Max, 42> {
+        x
+    }
+    fn _test_variance_view<'a: 'b, 'b, 'c>(
+        x: &'c BinaryHeapView<&'a (), Max>,
+    ) -> &'c BinaryHeapView<&'b (), Max> {
+        x
+    }
 }
diff --git a/src/deque.rs b/src/deque.rs
index 5f09756f75..695630142c 100644
--- a/src/deque.rs
+++ b/src/deque.rs
@@ -33,19 +33,21 @@
 //! }
 //! ```
 
-use core::borrow::{Borrow, BorrowMut};
 use core::fmt;
 use core::iter::FusedIterator;
+use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use core::{ptr, slice};
 
-use crate::storage::{OwnedStorage, Storage, ViewStorage};
+use crate::vec::{OwnedVecStorage, VecStorage, VecStorageInner, ViewVecStorage};
 
 /// Base struct for [`Deque`] and [`Deque`], generic over the [`Storage`].
 ///
 /// In most cases you should use [`Deque`] or [`Deque`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct DequeInner<T, S: Storage> {
+pub struct DequeInner<T, S: VecStorage<T> + ?Sized> {
+    // This phantomdata is required because otherwise rustc thinks that `T` is not used
+    phantom: PhantomData<T>,
     /// Front index. Always 0..=(N-1)
     front: usize,
     /// Back index. Always 0..=(N-1).
@@ -54,7 +56,7 @@ pub struct DequeInner<T, S: Storage> {
     /// Used to distinguish "empty" and "full" cases when `front == back`.
     /// May only be `true` if `front == back`, always `false` otherwise.
     full: bool,
-    buffer: S::Buffer<MaybeUninit<T>>,
+    buffer: S,
 }
 
 /// A fixed capacity double-ended queue.
@@ -91,7 +93,7 @@ pub struct DequeInner<T, S: Storage> {
 ///     println!("{}", x);
 /// }
 /// ```
-pub type Deque<T, const N: usize> = DequeInner<T, OwnedStorage<N>>;
+pub type Deque<T, const N: usize> = DequeInner<T, OwnedVecStorage<T, N>>;
 
 /// A double-ended queue with dynamic capacity.
 ///
@@ -130,7 +132,7 @@ pub type Deque<T, const N: usize> = DequeInner<T, OwnedStorage<N>>;
 ///     println!("{}", x);
 /// }
 /// ```
-pub type DequeView<T> = DequeInner<T, ViewStorage>;
+pub type DequeView<T> = DequeInner<T, ViewVecStorage<T>>;
 
 impl<T, const N: usize> Deque<T, N> {
     const INIT: MaybeUninit<T> = MaybeUninit::uninit();
@@ -153,7 +155,10 @@ impl<T, const N: usize> Deque<T, N> {
         crate::sealed::greater_than_0::<N>();
 
         Self {
-            buffer: [Self::INIT; N],
+            phantom: PhantomData,
+            buffer: VecStorageInner {
+                buffer: [Self::INIT; N],
+            },
             front: 0,
             back: 0,
             full: false,
@@ -191,7 +196,7 @@ impl<T, const N: usize> Deque<T, N> {
     }
 }
 
-impl<T, S: Storage> DequeInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> DequeInner<T, S> {
     /// Returns the maximum number of elements the deque can hold.
     pub fn storage_capacity(&self) -> usize {
         self.buffer.borrow().len()
@@ -794,7 +799,7 @@ impl<T, const N: usize> Default for Deque<T, N> {
     }
 }
 
-impl<T, S: Storage> Drop for DequeInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> Drop for DequeInner<T, S> {
     fn drop(&mut self) {
         // safety: `self` is left in an inconsistent state but it doesn't matter since
         // it's getting dropped. Nothing should be able to observe `self` after drop.
@@ -802,21 +807,21 @@ impl<T, S: Storage> Drop for DequeInner<T, S> {
     }
 }
 
-impl<T: fmt::Debug, S: Storage> fmt::Debug for DequeInner<T, S> {
+impl<T: fmt::Debug, S: VecStorage<T> + ?Sized> fmt::Debug for DequeInner<T, S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self).finish()
     }
 }
 
 /// As with the standard library's `VecDeque`, items are added via `push_back`.
-impl<T, S: Storage> Extend<T> for DequeInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> Extend<T> for DequeInner<T, S> {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         for item in iter {
             self.push_back(item).ok().unwrap();
         }
     }
 }
-impl<'a, T: 'a + Copy, S: Storage> Extend<&'a T> for DequeInner<T, S> {
+impl<'a, T: 'a + Copy, S: VecStorage<T> + ?Sized> Extend<&'a T> for DequeInner<T, S> {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.extend(iter.into_iter().copied())
     }
@@ -846,7 +851,7 @@ impl<T, const N: usize> IntoIterator for Deque<T, N> {
     }
 }
 
-impl<'a, T, S: Storage> IntoIterator for &'a DequeInner<T, S> {
+impl<'a, T, S: VecStorage<T> + ?Sized> IntoIterator for &'a DequeInner<T, S> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -855,7 +860,7 @@ impl<'a, T, S: Storage> IntoIterator for &'a DequeInner<T, S> {
     }
 }
 
-impl<'a, T, S: Storage> IntoIterator for &'a mut DequeInner<T, S> {
+impl<'a, T, S: VecStorage<T> + ?Sized> IntoIterator for &'a mut DequeInner<T, S> {
     type Item = &'a mut T;
     type IntoIter = IterMut<'a, T>;
 
diff --git a/src/histbuf.rs b/src/histbuf.rs
index 93e79fbe33..ec8d45ebe4 100644
--- a/src/histbuf.rs
+++ b/src/histbuf.rs
@@ -31,8 +31,6 @@
 //! assert_eq!(avg, 4);
 //! ```
 
-use core::borrow::Borrow;
-use core::borrow::BorrowMut;
 use core::fmt;
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
@@ -40,18 +38,84 @@ use core::ops::Deref;
 use core::ptr;
 use core::slice;
 
-use crate::storage::OwnedStorage;
-use crate::storage::Storage;
-use crate::storage::ViewStorage;
+mod storage {
+    use core::mem::MaybeUninit;
+
+    /// Trait defining how data for a container is stored.
+    ///
+    /// There's two implementations available:
+    ///
+    /// - [`OwnedHistBufStorage`]: stores the data in an array `[T; N]` whose size is known at compile time.
+    /// - [`ViewHistBufStorage`]: stores the data in an unsized `[T]`.
+    ///
+    /// This allows containers to be generic over either sized or unsized storage. For example,
+    /// the [`vec`](crate::vec) module contains a [`HistBufInner`](crate::vec::HistBufInner) struct
+    /// that's generic on [`Storage`], and two type aliases for convenience:
+    ///
+    /// - [`HistBuf<T, N>`](crate::vec::HistBuf) = `HistBufInner<T, OwnedHistBufStorage<T, N>>`
+    /// - [`HistBufView<T>`](crate::vec::HistBufView) = `HistBufInner<T, ViewHistBufStorage<T>>`
+    ///
+    /// `HistBuf` can be unsized into `HistBufView`, either by unsizing coercions such as `&mut HistBuf -> &mut HistBufView` or
+    /// `Box<HistBuf> -> Box<HistBufView>`, or explicitly with [`.as_view()`](crate::vec::HistBuf::as_view) or [`.as_mut_view()`](crate::vec::HistBuf::as_mut_view).
+    ///
+    /// This trait is sealed, so you cannot implement it for your own types. You can only use
+    /// the implementations provided by this crate.
+    #[allow(private_bounds)]
+    pub trait HistBufStorage<T>: HistBufSealedStorage<T> {}
+
+    pub trait HistBufSealedStorage<T> {
+        // part of the sealed trait so that no trait is publicly implemented by `OwnedHistBufStorage` besides `Storage`
+        fn borrow(&self) -> &[MaybeUninit<T>];
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>];
+    }
+
+    // One sealed layer of indirection to hide the internal details (The MaybeUninit).
+    pub struct HistBufStorageInner<T: ?Sized> {
+        pub(crate) buffer: T,
+    }
+
+    /// Implementation of [`HistBufStorage`] that stores the data in an array `[T; N]` whose size is known at compile time.
+    pub type OwnedHistBufStorage<T, const N: usize> = HistBufStorageInner<[MaybeUninit<T>; N]>;
+    /// Implementation of [`HistBufStorage`] that stores the data in an unsized `[T]`.
+    pub type ViewHistBufStorage<T> = HistBufStorageInner<[MaybeUninit<T>]>;
+
+    impl<T, const N: usize> HistBufSealedStorage<T> for OwnedHistBufStorage<T, N> {
+        fn borrow(&self) -> &[MaybeUninit<T>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>] {
+            &mut self.buffer
+        }
+    }
+    impl<T, const N: usize> HistBufStorage<T> for OwnedHistBufStorage<T, N> {}
+
+    impl<T> HistBufSealedStorage<T> for ViewHistBufStorage<T> {
+        fn borrow(&self) -> &[MaybeUninit<T>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>] {
+            &mut self.buffer
+        }
+    }
+    impl<T> HistBufStorage<T> for ViewHistBufStorage<T> {}
+}
+
+pub use storage::{HistBufStorage, OwnedHistBufStorage, ViewHistBufStorage};
+
+use storage::HistBufStorageInner;
+
+use self::storage::HistBufSealedStorage;
 
 /// Base struct for [`HistoryBuffer`] and [`HistoryBufferView`], generic over the [`Storage`].
 ///
 /// In most cases you should use [`HistoryBuffer`] or [`HistoryBufferView`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct HistoryBufferInner<T, S: Storage> {
+pub struct HistoryBufferInner<T, S: HistBufStorage<T> + ?Sized> {
+    // This phantomdata is required because otherwise rustc thinks that `T` is not used
+    phantom: PhantomData<T>,
     write_at: usize,
     filled: bool,
-    data: S::Buffer<MaybeUninit<T>>,
+    data: S,
 }
 
 /// A "history buffer", similar to a write-only ring buffer of fixed length.
@@ -86,7 +150,7 @@ pub struct HistoryBufferInner<T, S: Storage> {
 /// let avg = buf.as_slice().iter().sum::<usize>() / buf.len();
 /// assert_eq!(avg, 4);
 /// ```
-pub type HistoryBuffer<T, const N: usize> = HistoryBufferInner<T, OwnedStorage<N>>;
+pub type HistoryBuffer<T, const N: usize> = HistoryBufferInner<T, OwnedHistBufStorage<T, N>>;
 
 /// A "view" into a [`HistoryBuffer`]
 ///
@@ -119,7 +183,7 @@ pub type HistoryBuffer<T, const N: usize> = HistoryBufferInner<T, OwnedStorage<N
 /// let avg = buf.as_slice().iter().sum::<usize>() / buf.len();
 /// assert_eq!(avg, 4);
 /// ```
-pub type HistoryBufferView<T> = HistoryBufferInner<T, ViewStorage>;
+pub type HistoryBufferView<T> = HistoryBufferInner<T, ViewHistBufStorage<T>>;
 
 impl<T, const N: usize> HistoryBuffer<T, N> {
     const INIT: MaybeUninit<T> = MaybeUninit::uninit();
@@ -143,7 +207,10 @@ impl<T, const N: usize> HistoryBuffer<T, N> {
         crate::sealed::greater_than_0::<N>();
 
         Self {
-            data: [Self::INIT; N],
+            phantom: PhantomData,
+            data: HistBufStorageInner {
+                buffer: [Self::INIT; N],
+            },
             write_at: 0,
             filled: false,
         }
@@ -169,13 +236,16 @@ where
     #[inline]
     pub fn new_with(t: T) -> Self {
         Self {
-            data: [MaybeUninit::new(t); N],
+            phantom: PhantomData,
+            data: HistBufStorageInner {
+                buffer: [MaybeUninit::new(t); N],
+            },
             write_at: 0,
             filled: true,
         }
     }
 }
-impl<T: Copy, S: Storage> HistoryBufferInner<T, S> {
+impl<T: Copy, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
     /// Clears the buffer, replacing every element with the given value.
     pub fn clear_with(&mut self, t: T) {
         // SAFETY: we reset the values just after
@@ -189,7 +259,7 @@ impl<T: Copy, S: Storage> HistoryBufferInner<T, S> {
     }
 }
 
-impl<T, S: Storage> HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
     /// Clears the buffer
     pub fn clear(&mut self) {
         // SAFETY: we reset the values just after
@@ -199,7 +269,7 @@ impl<T, S: Storage> HistoryBufferInner<T, S> {
     }
 }
 
-impl<T, S: Storage> HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> HistoryBufferInner<T, S> {
     unsafe fn drop_contents(&mut self) {
         unsafe {
             ptr::drop_in_place(ptr::slice_from_raw_parts_mut(
@@ -407,7 +477,7 @@ impl<T, S: Storage> HistoryBufferInner<T, S> {
     }
 }
 
-impl<T, S: Storage> Extend<T> for HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> Extend<T> for HistoryBufferInner<T, S> {
     fn extend<I>(&mut self, iter: I)
     where
         I: IntoIterator<Item = T>,
@@ -418,7 +488,7 @@ impl<T, S: Storage> Extend<T> for HistoryBufferInner<T, S> {
     }
 }
 
-impl<'a, T, S: Storage> Extend<&'a T> for HistoryBufferInner<T, S>
+impl<'a, T, S: HistBufStorage<T> + ?Sized> Extend<&'a T> for HistoryBufferInner<T, S>
 where
     T: 'a + Clone,
 {
@@ -436,7 +506,7 @@ where
 {
     fn clone(&self) -> Self {
         let mut ret = Self::new();
-        for (new, old) in ret.data.iter_mut().zip(self.as_slice()) {
+        for (new, old) in ret.data.borrow_mut().iter_mut().zip(self.as_slice()) {
             new.write(old.clone());
         }
         ret.filled = self.filled;
@@ -445,13 +515,13 @@ where
     }
 }
 
-impl<T, S: Storage> Drop for HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> Drop for HistoryBufferInner<T, S> {
     fn drop(&mut self) {
         unsafe { self.drop_contents() }
     }
 }
 
-impl<T, S: Storage> Deref for HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> Deref for HistoryBufferInner<T, S> {
     type Target = [T];
 
     fn deref(&self) -> &[T] {
@@ -459,14 +529,14 @@ impl<T, S: Storage> Deref for HistoryBufferInner<T, S> {
     }
 }
 
-impl<T, S: Storage> AsRef<[T]> for HistoryBufferInner<T, S> {
+impl<T, S: HistBufStorage<T> + ?Sized> AsRef<[T]> for HistoryBufferInner<T, S> {
     #[inline]
     fn as_ref(&self) -> &[T] {
         self
     }
 }
 
-impl<T, S: Storage> fmt::Debug for HistoryBufferInner<T, S>
+impl<T, S: HistBufStorage<T> + ?Sized> fmt::Debug for HistoryBufferInner<T, S>
 where
     T: fmt::Debug,
 {
@@ -481,7 +551,7 @@ impl<T, const N: usize> Default for HistoryBuffer<T, N> {
     }
 }
 
-impl<T, S: Storage> PartialEq for HistoryBufferInner<T, S>
+impl<T, S: HistBufStorage<T> + ?Sized> PartialEq for HistoryBufferInner<T, S>
 where
     T: PartialEq,
 {
@@ -494,7 +564,7 @@ where
 ///
 /// In most cases you should use [`OldestOrdered`] or [`OldestOrderedView`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct OldestOrderedInner<'a, T, S: Storage> {
+pub struct OldestOrderedInner<'a, T, S: HistBufStorage<T> + ?Sized> {
     phantom: PhantomData<S>,
     inner: core::iter::Chain<core::slice::Iter<'a, T>, core::slice::Iter<'a, T>>,
 }
@@ -502,11 +572,12 @@ pub struct OldestOrderedInner<'a, T, S: Storage> {
 /// Double ended iterator on the underlying buffer ordered from the oldest data
 /// to the newest
 /// This type exists for backwards compatibility. It is always better to convert it to an [`OldestOrderedView`] with [`into_view`](OldestOrdered::into_view)
-pub type OldestOrdered<'a, T, const N: usize> = OldestOrderedInner<'a, T, OwnedStorage<N>>;
+pub type OldestOrdered<'a, T, const N: usize> =
+    OldestOrderedInner<'a, T, OwnedHistBufStorage<T, N>>;
 
 /// Double ended iterator on the underlying buffer ordered from the oldest data
 /// to the newest
-pub type OldestOrderedView<'a, T> = OldestOrderedInner<'a, T, ViewStorage>;
+pub type OldestOrderedView<'a, T> = OldestOrderedInner<'a, T, ViewHistBufStorage<T>>;
 
 impl<'a, T, const N: usize> OldestOrdered<'a, T, N> {
     /// Remove the `N` const-generic parameter from the iterator
@@ -534,7 +605,7 @@ impl<'a, T> OldestOrderedView<'a, T> {
     }
 }
 
-impl<'a, T, S: Storage> Clone for OldestOrderedInner<'a, T, S> {
+impl<'a, T, S: HistBufStorage<T> + ?Sized> Clone for OldestOrderedInner<'a, T, S> {
     fn clone(&self) -> Self {
         Self {
             phantom: PhantomData,
@@ -543,7 +614,7 @@ impl<'a, T, S: Storage> Clone for OldestOrderedInner<'a, T, S> {
     }
 }
 
-impl<'a, T, S: Storage> Iterator for OldestOrderedInner<'a, T, S> {
+impl<'a, T, S: HistBufStorage<T> + ?Sized> Iterator for OldestOrderedInner<'a, T, S> {
     type Item = &'a T;
 
     fn next(&mut self) -> Option<&'a T> {
@@ -568,7 +639,7 @@ mod tests {
 
     use static_assertions::assert_not_impl_any;
 
-    use super::HistoryBuffer;
+    use super::{HistoryBuffer, HistoryBufferView};
 
     // Ensure a `HistoryBuffer` containing `!Send` values stays `!Send` itself.
     assert_not_impl_any!(HistoryBuffer<*const (), 4>: Send);
@@ -855,4 +926,13 @@ mod tests {
         x.clear();
         assert_eq!(DROP_COUNT.load(Ordering::SeqCst), 3);
     }
+
+    fn _test_variance<'a: 'b, 'b>(x: HistoryBuffer<&'a (), 42>) -> HistoryBuffer<&'b (), 42> {
+        x
+    }
+    fn _test_variance_view<'a: 'b, 'b, 'c>(
+        x: &'c HistoryBufferView<&'a ()>,
+    ) -> &'c HistoryBufferView<&'b ()> {
+        x
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 17f6056dc3..ee56732ce2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -144,7 +144,7 @@ pub mod mpmc;
     )
 ))]
 pub mod pool;
-pub mod sorted_linked_list;
+// pub mod sorted_linked_list;
 #[cfg(any(
     // assume we have all atomics available if we're using portable-atomic
     feature = "portable-atomic",
diff --git a/src/linear_map.rs b/src/linear_map.rs
index 28f4e83d42..40fd94dca2 100644
--- a/src/linear_map.rs
+++ b/src/linear_map.rs
@@ -4,26 +4,22 @@
 
 use core::{borrow::Borrow, fmt, mem, ops, slice};
 
-use crate::{
-    storage::{OwnedStorage, Storage, ViewStorage},
-    vec::VecInner,
-    Vec,
-};
+use crate::vec::{OwnedVecStorage, Vec, VecInner, VecStorage, ViewVecStorage};
 
 /// Base struct for [`LinearMap`] and [`LinearMapView`]
-pub struct LinearMapInner<K, V, S: Storage> {
+pub struct LinearMapInner<K, V, S: VecStorage<(K, V)> + ?Sized> {
     pub(crate) buffer: VecInner<(K, V), S>,
 }
 
 /// A fixed capacity map/dictionary that performs lookups via linear search.
 ///
 /// Note that as this map doesn't use hashing so most operations are *O*(n) instead of *O*(1).
-pub type LinearMap<K, V, const N: usize> = LinearMapInner<K, V, OwnedStorage<N>>;
+pub type LinearMap<K, V, const N: usize> = LinearMapInner<K, V, OwnedVecStorage<(K, V), N>>;
 
 /// A dynamic capacity map/dictionary that performs lookups via linear search.
 ///
 /// Note that as this map doesn't use hashing so most operations are *O*(n) instead of *O*(1).
-pub type LinearMapView<K, V> = LinearMapInner<K, V, ViewStorage>;
+pub type LinearMapView<K, V> = LinearMapInner<K, V, ViewVecStorage<(K, V)>>;
 
 impl<K, V, const N: usize> LinearMap<K, V, N> {
     /// Creates an empty `LinearMap`.
@@ -54,7 +50,7 @@ impl<K, V, const N: usize> LinearMap<K, V, N> {
     }
 }
 
-impl<K, V, S: Storage> LinearMapInner<K, V, S>
+impl<K, V, S: VecStorage<(K, V)> + ?Sized> LinearMapInner<K, V, S>
 where
     K: Eq,
 {
@@ -371,7 +367,7 @@ where
     }
 }
 
-impl<'a, K, V, Q, S: Storage> ops::Index<&'a Q> for LinearMapInner<K, V, S>
+impl<'a, K, V, Q, S: VecStorage<(K, V)> + ?Sized> ops::Index<&'a Q> for LinearMapInner<K, V, S>
 where
     K: Borrow<Q> + Eq,
     Q: Eq + ?Sized,
@@ -383,7 +379,7 @@ where
     }
 }
 
-impl<'a, K, V, Q, S: Storage> ops::IndexMut<&'a Q> for LinearMapInner<K, V, S>
+impl<'a, K, V, Q, S: VecStorage<(K, V)> + ?Sized> ops::IndexMut<&'a Q> for LinearMapInner<K, V, S>
 where
     K: Borrow<Q> + Eq,
     Q: Eq + ?Sized,
@@ -414,7 +410,7 @@ where
     }
 }
 
-impl<K, V, S: Storage> fmt::Debug for LinearMapInner<K, V, S>
+impl<K, V, S: VecStorage<(K, V)> + ?Sized> fmt::Debug for LinearMapInner<K, V, S>
 where
     K: Eq + fmt::Debug,
     V: fmt::Debug,
@@ -472,7 +468,7 @@ where
     }
 }
 
-impl<'a, K, V, S: Storage> IntoIterator for &'a LinearMapInner<K, V, S>
+impl<'a, K, V, S: VecStorage<(K, V)> + ?Sized> IntoIterator for &'a LinearMapInner<K, V, S>
 where
     K: Eq,
 {
@@ -519,8 +515,8 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> {
     }
 }
 
-impl<K, V, S1: Storage, S2: Storage> PartialEq<LinearMapInner<K, V, S2>>
-    for LinearMapInner<K, V, S1>
+impl<K, V, S1: VecStorage<(K, V)> + ?Sized, S2: VecStorage<(K, V)> + ?Sized>
+    PartialEq<LinearMapInner<K, V, S2>> for LinearMapInner<K, V, S1>
 where
     K: Eq,
     V: PartialEq,
@@ -533,7 +529,7 @@ where
     }
 }
 
-impl<K, V, S: Storage> Eq for LinearMapInner<K, V, S>
+impl<K, V, S: VecStorage<(K, V)> + ?Sized> Eq for LinearMapInner<K, V, S>
 where
     K: Eq,
     V: PartialEq,
@@ -544,7 +540,7 @@ where
 mod test {
     use static_assertions::assert_not_impl_any;
 
-    use super::LinearMap;
+    use super::{LinearMap, LinearMapView};
 
     // Ensure a `LinearMap` containing `!Send` keys stays `!Send` itself.
     assert_not_impl_any!(LinearMap<*const (), (), 4>: Send);
@@ -619,4 +615,23 @@ mod test {
             assert_eq!(v, src.remove(k).unwrap());
         }
     }
+
+    fn _test_variance_value<'a: 'b, 'b>(
+        x: LinearMap<u32, &'a (), 42>,
+    ) -> LinearMap<u32, &'b (), 42> {
+        x
+    }
+    fn _test_variance_value_view<'a: 'b, 'b, 'c>(
+        x: &'c LinearMapView<u32, &'a ()>,
+    ) -> &'c LinearMapView<u32, &'b ()> {
+        x
+    }
+    fn _test_variance_key<'a: 'b, 'b>(x: LinearMap<&'a (), u32, 42>) -> LinearMap<&'b (), u32, 42> {
+        x
+    }
+    fn _test_variance_key_view<'a: 'b, 'b, 'c>(
+        x: &'c LinearMapView<&'a (), u32>,
+    ) -> &'c LinearMapView<&'b (), u32> {
+        x
+    }
 }
diff --git a/src/sorted_linked_list.rs b/src/sorted_linked_list.rs
index a3c9cb502f..fbbe114ed4 100644
--- a/src/sorted_linked_list.rs
+++ b/src/sorted_linked_list.rs
@@ -26,7 +26,6 @@
 //!
 //! [`BinaryHeap`]: `crate::binary_heap::BinaryHeap`
 
-use core::borrow::{Borrow, BorrowMut};
 use core::cmp::Ordering;
 use core::fmt;
 use core::marker::PhantomData;
@@ -34,7 +33,76 @@ use core::mem::MaybeUninit;
 use core::ops::{Deref, DerefMut};
 use core::ptr;
 
-use crate::storage::{OwnedStorage, Storage, ViewStorage};
+mod storage {
+    use super::Node;
+
+    /// Trait defining how data for a container is stored.
+    ///
+    /// There's two implementations available:
+    ///
+    /// - [`OwnedSortedLinkedListStorage`]: stores the data in an array `[T; N]` whose size is known at compile time.
+    /// - [`ViewSortedLinkedListStorage`]: stores the data in an unsized `[T]`.
+    ///
+    /// This allows containers to be generic over either sized or unsized storage. For example,
+    /// the [`vec`](crate::vec) module contains a [`SortedLinkedListInner`](crate::vec::SortedLinkedListInner) struct
+    /// that's generic on [`Storage`], and two type aliases for convenience:
+    ///
+    /// - [`SortedLinkedList<T, N>`](crate::vec::SortedLinkedList) = `SortedLinkedListInner<T, OwnedStorage<T, N>>`
+    /// - [`SortedLinkedListView<T>`](crate::vec::SortedLinkedListView) = `SortedLinkedListInner<T, ViewStorage<T>>`
+    ///
+    /// `SortedLinkedList` can be unsized into `SortedLinkedListView`, either by unsizing coercions such as `&mut SortedLinkedList -> &mut SortedLinkedListView` or
+    /// `Box<SortedLinkedList> -> Box<SortedLinkedListView>`, or explicitly with [`.as_view()`](crate::vec::SortedLinkedList::as_view) or [`.as_mut_view()`](crate::vec::SortedLinkedList::as_mut_view).
+    ///
+    /// This trait is sealed, so you cannot implement it for your own types. You can only use
+    /// the implementations provided by this crate.
+    #[allow(private_bounds)]
+    pub trait SortedLinkedListStorage<T, Idx>: SortedLinkedListSealedStorage<T, Idx> {}
+
+    pub trait SortedLinkedListSealedStorage<T, Idx> {
+        // part of the sealed trait so that no trait is publicly implemented by `OwnedSortedLinkedListStorage` besides `Storage`
+        fn borrow(&self) -> &[Node<T, Idx>];
+        fn borrow_mut(&mut self) -> &mut [Node<T, Idx>];
+    }
+
+    // One sealed layer of indirection to hide the internal details (The MaybeUninit).
+    pub struct SortedLinkedListStorageInner<T: ?Sized> {
+        pub(crate) buffer: T,
+    }
+
+    /// Implementation of [`SortedLinkedListStorage`] that stores the data in an array `[T; N]` whose size is known at compile time.
+    pub type OwnedSortedLinkedListStorage<T, Idx, const N: usize> =
+        SortedLinkedListStorageInner<[Node<T, Idx>; N]>;
+    /// Implementation of [`SortedLinkedListStorage`] that stores the data in an unsized `[T]`.
+    pub type ViewSortedLinkedListStorage<T, Idx> = SortedLinkedListStorageInner<[Node<T, Idx>]>;
+
+    impl<T, Idx, const N: usize> SortedLinkedListSealedStorage<T, Idx>
+        for OwnedSortedLinkedListStorage<T, Idx, N>
+    {
+        fn borrow(&self) -> &[Node<T, Idx>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [Node<T, Idx>] {
+            &mut self.buffer
+        }
+    }
+    impl<T, Idx, const N: usize> SortedLinkedListStorage<T, Idx>
+        for OwnedSortedLinkedListStorage<T, Idx, N>
+    {
+    }
+
+    impl<T, Idx> SortedLinkedListSealedStorage<T, Idx> for ViewSortedLinkedListStorage<T, Idx> {
+        fn borrow(&self) -> &[Node<T, Idx>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [Node<T, Idx>] {
+            &mut self.buffer
+        }
+    }
+    impl<T, Idx> SortedLinkedListStorage<T, Idx> for ViewSortedLinkedListStorage<T, Idx> {}
+}
+pub use storage::{
+    OwnedSortedLinkedListStorage, SortedLinkedListStorage, ViewSortedLinkedListStorage,
+};
 
 /// Trait for defining an index for the linked list, never implemented by users.
 pub trait SortedLinkedListIndex: Copy {
@@ -93,20 +161,21 @@ pub struct Node<T, Idx> {
 pub struct SortedLinkedListInner<T, Idx, K, S>
 where
     Idx: SortedLinkedListIndex,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     head: Idx,
     free: Idx,
-    _kind: PhantomData<K>,
-    list: S::Buffer<Node<T, Idx>>,
+    phantom: PhantomData<(K, T)>,
+    list: S,
 }
 
 /// The linked list.
 pub type SortedLinkedList<T, Idx, K, const N: usize> =
-    SortedLinkedListInner<T, Idx, K, OwnedStorage<N>>;
+    SortedLinkedListInner<T, Idx, K, OwnedSortedLinkedListStorage<T, Idx, N>>;
 
 /// The linked list.
-pub type SortedLinkedListView<T, Idx, K> = SortedLinkedListInner<T, Idx, K, ViewStorage>;
+pub type SortedLinkedListView<T, Idx, K> =
+    SortedLinkedListInner<T, Idx, K, ViewSortedLinkedListStorage<T, Idx>>;
 
 // Internal macro for generating indexes for the linkedlist and const new for the linked list
 macro_rules! impl_index_and_const_new {
@@ -168,10 +237,12 @@ macro_rules! impl_index_and_const_new {
                 crate::sealed::smaller_than::<N, $max_val>();
 
                 let mut list = SortedLinkedList {
-                    list: [Self::UNINIT; N],
+                    list: OwnedSortedLinkedListStorage {
+                        buffer: [Self::UNINIT; N],
+                    },
                     head: $name::none(),
                     free: unsafe { $name::new_unchecked(0) },
-                    _kind: PhantomData,
+                    phantom: PhantomData,
                 };
 
                 if N == 0 {
@@ -183,7 +254,7 @@ macro_rules! impl_index_and_const_new {
 
                 // Initialize indexes
                 while free < N - 1 {
-                    list.list[free].next = unsafe { $name::new_unchecked(free as $ty + 1) };
+                    list.list.buffer[free].next = unsafe { $name::new_unchecked(free as $ty + 1) };
                     free += 1;
                 }
 
@@ -215,7 +286,7 @@ where
 impl<T, Idx, K, S> SortedLinkedListInner<T, Idx, K, S>
 where
     Idx: SortedLinkedListIndex,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     /// Internal access helper
     #[inline(always)]
@@ -267,7 +338,7 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     /// Pushes a value onto the list without checking if the list is full.
     ///
@@ -554,23 +625,24 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     list: &'a SortedLinkedListInner<T, Idx, K, S>,
     index: Idx,
 }
 
 /// Iterator for the linked list.
-pub type Iter<'a, T, Idx, K, const N: usize> = IterInner<'a, T, Idx, K, OwnedStorage<N>>;
+pub type Iter<'a, T, Idx, K, const N: usize> =
+    IterInner<'a, T, Idx, K, OwnedSortedLinkedListStorage<T, Idx, N>>;
 /// Iterator for the linked list.
-pub type IterView<'a, T, Idx, K, const N: usize> = IterInner<'a, T, Idx, K, ViewStorage>;
+pub type IterView<'a, T, Idx, K> = IterInner<'a, T, Idx, K, ViewSortedLinkedListStorage<T, Idx>>;
 
 impl<'a, T, Idx, K, S> Iterator for IterInner<'a, T, Idx, K, S>
 where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     type Item = &'a T;
 
@@ -593,7 +665,7 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     list: &'a mut SortedLinkedListInner<T, Idx, K, S>,
     is_head: bool,
@@ -603,16 +675,18 @@ where
 }
 
 /// Comes from [`SortedLinkedList::find_mut`].
-pub type FindMut<'a, T, Idx, K, const N: usize> = FindMutInner<'a, T, Idx, K, OwnedStorage<N>>;
+pub type FindMut<'a, T, Idx, K, const N: usize> =
+    FindMutInner<'a, T, Idx, K, OwnedSortedLinkedListStorage<T, Idx, N>>;
 /// Comes from [`SortedLinkedList::find_mut`].
-pub type FindMutView<'a, T, Idx, K, const N: usize> = FindMutInner<'a, T, Idx, K, ViewStorage>;
+pub type FindMutView<'a, T, Idx, K, const N: usize> =
+    FindMutInner<'a, T, Idx, K, ViewSortedLinkedListStorage<T, Idx>>;
 
 impl<'a, T, Idx, K, S> FindMutInner<'a, T, Idx, K, S>
 where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     fn pop_internal(&mut self) -> T {
         if self.is_head {
@@ -701,7 +775,7 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     fn drop(&mut self) {
         // Only resort the list if the element has changed
@@ -717,7 +791,7 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     type Target = T;
 
@@ -732,7 +806,7 @@ where
     T: Ord,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.maybe_changed = true;
@@ -771,7 +845,7 @@ where
     T: Ord + core::fmt::Debug,
     Idx: SortedLinkedListIndex,
     K: Kind,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
@@ -781,7 +855,7 @@ where
 impl<T, Idx, K, S> Drop for SortedLinkedListInner<T, Idx, K, S>
 where
     Idx: SortedLinkedListIndex,
-    S: Storage,
+    S: SortedLinkedListStorage<T, Idx> + ?Sized,
 {
     fn drop(&mut self) {
         let mut index = self.head;
@@ -927,4 +1001,15 @@ mod tests {
 
         assert_eq!(ll.peek().unwrap(), &1001);
     }
+
+    fn _test_variance<'a: 'b, 'b>(
+        x: SortedLinkedList<&'a (), LinkedIndexUsize, Max, 42>,
+    ) -> SortedLinkedList<&'b (), LinkedIndexUsize, Max, 42> {
+        x
+    }
+    fn _test_variance_view<'a: 'b, 'b, 'c>(
+        x: &'c SortedLinkedListView<&'a (), LinkedIndexUsize, Max>,
+    ) -> &'c SortedLinkedListView<&'b (), LinkedIndexUsize, Max> {
+        x
+    }
 }
diff --git a/src/string/mod.rs b/src/string/mod.rs
index d88dbf0fd0..bf4fff058a 100644
--- a/src/string/mod.rs
+++ b/src/string/mod.rs
@@ -11,11 +11,7 @@ use core::{
     str::{self, Utf8Error},
 };
 
-use crate::{
-    storage::{OwnedStorage, Storage, ViewStorage},
-    vec::VecInner,
-    Vec,
-};
+use crate::vec::{OwnedVecStorage, Vec, VecInner, VecStorage, ViewVecStorage};
 
 mod drain;
 pub use drain::Drain;
@@ -46,15 +42,15 @@ impl fmt::Display for FromUtf16Error {
 ///
 /// In most cases you should use [`String`] or [`StringView`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct StringInner<S: Storage> {
+pub struct StringInner<S: VecStorage<u8> + ?Sized> {
     vec: VecInner<u8, S>,
 }
 
 /// A fixed capacity [`String`](https://doc.rust-lang.org/std/string/struct.String.html).
-pub type String<const N: usize> = StringInner<OwnedStorage<N>>;
+pub type String<const N: usize> = StringInner<OwnedVecStorage<u8, N>>;
 
 /// A dynamic capacity [`String`](https://doc.rust-lang.org/std/string/struct.String.html).
-pub type StringView = StringInner<ViewStorage>;
+pub type StringView = StringInner<ViewVecStorage<u8>>;
 
 impl StringView {
     /// Removes the specified range from the string in bulk, returning all
@@ -349,7 +345,7 @@ impl<const N: usize> String<N> {
     }
 }
 
-impl<S: Storage> StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> StringInner<S> {
     /// Extracts a string slice containing the entire string.
     ///
     /// # Examples
@@ -690,26 +686,26 @@ impl<const N: usize> Clone for String<N> {
     }
 }
 
-impl<S: Storage> fmt::Debug for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> fmt::Debug for StringInner<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         <str as fmt::Debug>::fmt(self, f)
     }
 }
 
-impl<S: Storage> fmt::Display for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> fmt::Display for StringInner<S> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         <str as fmt::Display>::fmt(self, f)
     }
 }
 
-impl<S: Storage> hash::Hash for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> hash::Hash for StringInner<S> {
     #[inline]
     fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
         <str as hash::Hash>::hash(self, hasher)
     }
 }
 
-impl<S: Storage> fmt::Write for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> fmt::Write for StringInner<S> {
     fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
         self.push_str(s).map_err(|_| fmt::Error)
     }
@@ -719,7 +715,7 @@ impl<S: Storage> fmt::Write for StringInner<S> {
     }
 }
 
-impl<S: Storage> ops::Deref for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> ops::Deref for StringInner<S> {
     type Target = str;
 
     fn deref(&self) -> &str {
@@ -727,45 +723,47 @@ impl<S: Storage> ops::Deref for StringInner<S> {
     }
 }
 
-impl<S: Storage> ops::DerefMut for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> ops::DerefMut for StringInner<S> {
     fn deref_mut(&mut self) -> &mut str {
         self.as_mut_str()
     }
 }
 
-impl<S: Storage> borrow::Borrow<str> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> borrow::Borrow<str> for StringInner<S> {
     fn borrow(&self) -> &str {
         self.as_str()
     }
 }
-impl<S: Storage> borrow::BorrowMut<str> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> borrow::BorrowMut<str> for StringInner<S> {
     fn borrow_mut(&mut self) -> &mut str {
         self.as_mut_str()
     }
 }
 
-impl<S: Storage> AsRef<str> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> AsRef<str> for StringInner<S> {
     #[inline]
     fn as_ref(&self) -> &str {
         self
     }
 }
 
-impl<S: Storage> AsRef<[u8]> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> AsRef<[u8]> for StringInner<S> {
     #[inline]
     fn as_ref(&self) -> &[u8] {
         self.as_bytes()
     }
 }
 
-impl<S1: Storage, S2: Storage> PartialEq<StringInner<S1>> for StringInner<S2> {
+impl<S1: VecStorage<u8> + ?Sized, S2: VecStorage<u8> + ?Sized> PartialEq<StringInner<S1>>
+    for StringInner<S2>
+{
     fn eq(&self, rhs: &StringInner<S1>) -> bool {
         str::eq(&**self, &**rhs)
     }
 }
 
 // String<N> == str
-impl<S: Storage> PartialEq<str> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> PartialEq<str> for StringInner<S> {
     #[inline]
     fn eq(&self, other: &str) -> bool {
         str::eq(self, other)
@@ -773,7 +771,7 @@ impl<S: Storage> PartialEq<str> for StringInner<S> {
 }
 
 // String<N> == &'str
-impl<S: Storage> PartialEq<&str> for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> PartialEq<&str> for StringInner<S> {
     #[inline]
     fn eq(&self, other: &&str) -> bool {
         str::eq(self, &other[..])
@@ -781,7 +779,7 @@ impl<S: Storage> PartialEq<&str> for StringInner<S> {
 }
 
 // str == String<N>
-impl<S: Storage> PartialEq<StringInner<S>> for str {
+impl<S: VecStorage<u8> + ?Sized> PartialEq<StringInner<S>> for str {
     #[inline]
     fn eq(&self, other: &StringInner<S>) -> bool {
         str::eq(self, &other[..])
@@ -789,23 +787,25 @@ impl<S: Storage> PartialEq<StringInner<S>> for str {
 }
 
 // &'str == String<N>
-impl<S: Storage> PartialEq<StringInner<S>> for &str {
+impl<S: VecStorage<u8> + ?Sized> PartialEq<StringInner<S>> for &str {
     #[inline]
     fn eq(&self, other: &StringInner<S>) -> bool {
         str::eq(self, &other[..])
     }
 }
 
-impl<S: Storage> Eq for StringInner<S> {}
+impl<S: VecStorage<u8> + ?Sized> Eq for StringInner<S> {}
 
-impl<S1: Storage, S2: Storage> PartialOrd<StringInner<S1>> for StringInner<S2> {
+impl<S1: VecStorage<u8> + ?Sized, S2: VecStorage<u8> + ?Sized> PartialOrd<StringInner<S1>>
+    for StringInner<S2>
+{
     #[inline]
     fn partial_cmp(&self, other: &StringInner<S1>) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
 
-impl<S: Storage> Ord for StringInner<S> {
+impl<S: VecStorage<u8> + ?Sized> Ord for StringInner<S> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         Ord::cmp(&**self, &**other)
diff --git a/src/vec/mod.rs b/src/vec/mod.rs
index 1e1583a43e..d85d114693 100644
--- a/src/vec/mod.rs
+++ b/src/vec/mod.rs
@@ -1,8 +1,8 @@
 //! A fixed capacity [`Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html).
 
 use core::borrow;
+use core::marker::PhantomData;
 use core::{
-    borrow::{Borrow, BorrowMut},
     cmp::Ordering,
     fmt, hash,
     mem::{self, ManuallyDrop, MaybeUninit},
@@ -11,18 +11,84 @@ use core::{
     slice,
 };
 
-use crate::storage::{OwnedStorage, Storage, ViewStorage};
-
 mod drain;
+
+mod storage {
+    use core::mem::MaybeUninit;
+
+    /// Trait defining how data for a container is stored.
+    ///
+    /// There's two implementations available:
+    ///
+    /// - [`OwnedVecStorage`]: stores the data in an array `[T; N]` whose size is known at compile time.
+    /// - [`ViewVecStorage`]: stores the data in an unsized `[T]`.
+    ///
+    /// This allows containers to be generic over either sized or unsized storage. For example,
+    /// the [`vec`](crate::vec) module contains a [`VecInner`](crate::vec::VecInner) struct
+    /// that's generic on [`Storage`], and two type aliases for convenience:
+    ///
+    /// - [`Vec<T, N>`](crate::vec::Vec) = `VecInner<T, OwnedStorage<T, N>>`
+    /// - [`VecView<T>`](crate::vec::VecView) = `VecInner<T, ViewStorage<T>>`
+    ///
+    /// `Vec` can be unsized into `VecView`, either by unsizing coercions such as `&mut Vec -> &mut VecView` or
+    /// `Box<Vec> -> Box<VecView>`, or explicitly with [`.as_view()`](crate::vec::Vec::as_view) or [`.as_mut_view()`](crate::vec::Vec::as_mut_view).
+    ///
+    /// This trait is sealed, so you cannot implement it for your own types. You can only use
+    /// the implementations provided by this crate.
+    #[allow(private_bounds)]
+    pub trait VecStorage<T>: VecSealedStorage<T> {}
+
+    pub trait VecSealedStorage<T> {
+        // part of the sealed trait so that no trait is publicly implemented by `OwnedVecStorage` besides `Storage`
+        fn borrow(&self) -> &[MaybeUninit<T>];
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>];
+    }
+
+    // One sealed layer of indirection to hide the internal details (The MaybeUninit).
+    pub struct VecStorageInner<T: ?Sized> {
+        pub(crate) buffer: T,
+    }
+
+    /// Implementation of [`VecStorage`] that stores the data in an array `[T; N]` whose size is known at compile time.
+    pub type OwnedVecStorage<T, const N: usize> = VecStorageInner<[MaybeUninit<T>; N]>;
+    /// Implementation of [`VecStorage`] that stores the data in an unsized `[T]`.
+    pub type ViewVecStorage<T> = VecStorageInner<[MaybeUninit<T>]>;
+
+    impl<T, const N: usize> VecSealedStorage<T> for OwnedVecStorage<T, N> {
+        fn borrow(&self) -> &[MaybeUninit<T>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>] {
+            &mut self.buffer
+        }
+    }
+    impl<T, const N: usize> VecStorage<T> for OwnedVecStorage<T, N> {}
+
+    impl<T> VecSealedStorage<T> for ViewVecStorage<T> {
+        fn borrow(&self) -> &[MaybeUninit<T>] {
+            &self.buffer
+        }
+        fn borrow_mut(&mut self) -> &mut [MaybeUninit<T>] {
+            &mut self.buffer
+        }
+    }
+    impl<T> VecStorage<T> for ViewVecStorage<T> {}
+}
+pub use storage::{OwnedVecStorage, VecStorage, ViewVecStorage};
+
+pub(crate) use storage::VecStorageInner;
+
 pub use drain::Drain;
 
 /// Base struct for [`Vec`] and [`VecView`], generic over the [`Storage`].
 ///
 /// In most cases you should use [`Vec`] or [`VecView`] directly. Only use this
 /// struct if you want to write code that's generic over both.
-pub struct VecInner<T, S: Storage> {
+pub struct VecInner<T, S: VecStorage<T> + ?Sized> {
+    // This phantomdata is required because otherwise rustc thinks that `T` is not used
+    phantom: PhantomData<T>,
     len: usize,
-    buffer: S::Buffer<MaybeUninit<T>>,
+    buffer: S,
 }
 
 /// A fixed capacity [`Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html).
@@ -62,7 +128,7 @@ pub struct VecInner<T, S: Storage> {
 /// let vec: Vec<u8, 10> = Vec::from_slice(&[1, 2, 3, 4]).unwrap();
 /// let view: &VecView<_> = &vec;
 /// ```
-pub type Vec<T, const N: usize> = VecInner<T, OwnedStorage<N>>;
+pub type Vec<T, const N: usize> = VecInner<T, OwnedVecStorage<T, N>>;
 
 /// A [`Vec`] with dynamic capacity
 ///
@@ -85,7 +151,7 @@ pub type Vec<T, const N: usize> = VecInner<T, OwnedStorage<N>>;
 /// mut_view.push(5);
 /// assert_eq!(vec, [1, 2, 3, 4, 5]);
 /// ```
-pub type VecView<T> = VecInner<T, ViewStorage>;
+pub type VecView<T> = VecInner<T, ViewVecStorage<T>>;
 
 impl<T, const N: usize> Vec<T, N> {
     const ELEM: MaybeUninit<T> = MaybeUninit::uninit();
@@ -106,8 +172,9 @@ impl<T, const N: usize> Vec<T, N> {
     /// ```
     pub const fn new() -> Self {
         Self {
+            phantom: PhantomData,
             len: 0,
-            buffer: Self::INIT,
+            buffer: VecStorageInner { buffer: Self::INIT },
         }
     }
 
@@ -152,6 +219,7 @@ impl<T, const N: usize> Vec<T, N> {
 
         if N == M {
             Self {
+                phantom: PhantomData,
                 len: N,
                 // NOTE(unsafe) ManuallyDrop<[T; M]> and [MaybeUninit<T>; N]
                 // have the same layout when N == M.
@@ -160,7 +228,7 @@ impl<T, const N: usize> Vec<T, N> {
         } else {
             let mut v = Vec::<T, N>::new();
 
-            for (src_elem, dst_elem) in src.iter().zip(v.buffer.iter_mut()) {
+            for (src_elem, dst_elem) in src.iter().zip(v.buffer.buffer.iter_mut()) {
                 // NOTE(unsafe) src element is not going to drop as src itself
                 // is wrapped in a ManuallyDrop.
                 dst_elem.write(unsafe { ptr::read(src_elem) });
@@ -296,7 +364,7 @@ impl<T, const N: usize> Vec<T, N> {
     ///
     /// This method is not available on a `VecView`, use [`storage_len`](VecInner::storage_capacity) instead
     pub const fn capacity(&self) -> usize {
-        self.buffer.len()
+        self.buffer.buffer.len()
     }
 }
 
@@ -365,7 +433,7 @@ impl<T> VecView<T> {
     }
 }
 
-impl<T, S: Storage> VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> VecInner<T, S> {
     /// Returns a raw pointer to the vector’s buffer.
     pub fn as_ptr(&self) -> *const T {
         self.buffer.borrow().as_ptr() as *const T
@@ -993,14 +1061,14 @@ impl<T, S: Storage> VecInner<T, S> {
         // 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, S: Storage> {
+        struct BackshiftOnDrop<'a, T, S: VecStorage<T> + ?Sized> {
             v: &'a mut VecInner<T, S>,
             processed_len: usize,
             deleted_cnt: usize,
             original_len: usize,
         }
 
-        impl<'a, T, S: Storage> Drop for BackshiftOnDrop<'a, T, S> {
+        impl<'a, T, S: VecStorage<T> + ?Sized> Drop for BackshiftOnDrop<'a, T, S> {
             fn drop(&mut self) {
                 if self.deleted_cnt > 0 {
                     // SAFETY: Trailing unchecked items must be valid since we never touch them.
@@ -1028,7 +1096,7 @@ impl<T, S: Storage> VecInner<T, S> {
             original_len,
         };
 
-        fn process_loop<F, T, S: Storage, const DELETED: bool>(
+        fn process_loop<F, T, S: VecStorage<T> + ?Sized, const DELETED: bool>(
             original_len: usize,
             f: &mut F,
             g: &mut BackshiftOnDrop<'_, T, S>,
@@ -1114,7 +1182,7 @@ impl<T, const N: usize> Default for Vec<T, N> {
     }
 }
 
-impl<T, S: Storage> fmt::Debug for VecInner<T, S>
+impl<T, S: VecStorage<T> + ?Sized> fmt::Debug for VecInner<T, S>
 where
     T: fmt::Debug,
 {
@@ -1123,7 +1191,7 @@ where
     }
 }
 
-impl<S: Storage> fmt::Write for VecInner<u8, S> {
+impl<S: VecStorage<u8> + ?Sized> fmt::Write for VecInner<u8, S> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         match self.extend_from_slice(s.as_bytes()) {
             Ok(()) => Ok(()),
@@ -1138,7 +1206,7 @@ impl<T, const N: usize, const M: usize> From<[T; M]> for Vec<T, N> {
     }
 }
 
-impl<T, S: Storage> Drop for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> Drop for VecInner<T, S> {
     fn drop(&mut self) {
         let mut_slice = self.as_mut_slice();
         // We drop each element used in the vector by turning into a `&mut [T]`.
@@ -1155,7 +1223,7 @@ impl<'a, T: Clone, const N: usize> TryFrom<&'a [T]> for Vec<T, N> {
     }
 }
 
-impl<T, S: Storage> Extend<T> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> Extend<T> for VecInner<T, S> {
     fn extend<I>(&mut self, iter: I)
     where
         I: IntoIterator<Item = T>,
@@ -1164,7 +1232,7 @@ impl<T, S: Storage> Extend<T> for VecInner<T, S> {
     }
 }
 
-impl<'a, T, S: Storage> Extend<&'a T> for VecInner<T, S>
+impl<'a, T, S: VecStorage<T> + ?Sized> Extend<&'a T> for VecInner<T, S>
 where
     T: 'a + Copy,
 {
@@ -1176,7 +1244,7 @@ where
     }
 }
 
-impl<T, S: Storage> hash::Hash for VecInner<T, S>
+impl<T, S: VecStorage<T> + ?Sized> hash::Hash for VecInner<T, S>
 where
     T: core::hash::Hash,
 {
@@ -1185,7 +1253,7 @@ where
     }
 }
 
-impl<'a, T, S: Storage> IntoIterator for &'a VecInner<T, S> {
+impl<'a, T, S: VecStorage<T> + ?Sized> IntoIterator for &'a VecInner<T, S> {
     type Item = &'a T;
     type IntoIter = slice::Iter<'a, T>;
 
@@ -1194,7 +1262,7 @@ impl<'a, T, S: Storage> IntoIterator for &'a VecInner<T, S> {
     }
 }
 
-impl<'a, T, S: Storage> IntoIterator for &'a mut VecInner<T, S> {
+impl<'a, T, S: VecStorage<T> + ?Sized> IntoIterator for &'a mut VecInner<T, S> {
     type Item = &'a mut T;
     type IntoIter = slice::IterMut<'a, T>;
 
@@ -1228,7 +1296,14 @@ impl<T, const N: usize> Iterator for IntoIter<T, N> {
     type Item = T;
     fn next(&mut self) -> Option<Self::Item> {
         if self.next < self.vec.len() {
-            let item = unsafe { self.vec.buffer.get_unchecked_mut(self.next).as_ptr().read() };
+            let item = unsafe {
+                self.vec
+                    .buffer
+                    .buffer
+                    .get_unchecked_mut(self.next)
+                    .as_ptr()
+                    .read()
+            };
             self.next += 1;
             Some(item)
         } else {
@@ -1247,7 +1322,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.buffer.as_ptr() as *const T).add(self.next),
                     self.vec.len() - self.next,
                 )
             };
@@ -1278,7 +1353,8 @@ impl<T, const N: usize> IntoIterator for Vec<T, N> {
     }
 }
 
-impl<A, B, SA: Storage, SB: Storage> PartialEq<VecInner<B, SB>> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized, SB: VecStorage<B> + ?Sized> PartialEq<VecInner<B, SB>>
+    for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1287,7 +1363,7 @@ where
     }
 }
 
-impl<A, B, const M: usize, SB: Storage> PartialEq<VecInner<B, SB>> for [A; M]
+impl<A, B, const M: usize, SB: VecStorage<B> + ?Sized> PartialEq<VecInner<B, SB>> for [A; M]
 where
     A: PartialEq<B>,
 {
@@ -1296,7 +1372,7 @@ where
     }
 }
 
-impl<A, B, SB: Storage, const M: usize> PartialEq<VecInner<B, SB>> for &[A; M]
+impl<A, B, SB: VecStorage<B> + ?Sized, const M: usize> PartialEq<VecInner<B, SB>> for &[A; M]
 where
     A: PartialEq<B>,
 {
@@ -1305,7 +1381,7 @@ where
     }
 }
 
-impl<A, B, SB: Storage> PartialEq<VecInner<B, SB>> for [A]
+impl<A, B, SB: VecStorage<B> + ?Sized> PartialEq<VecInner<B, SB>> for [A]
 where
     A: PartialEq<B>,
 {
@@ -1314,7 +1390,7 @@ where
     }
 }
 
-impl<A, B, SB: Storage> PartialEq<VecInner<B, SB>> for &[A]
+impl<A, B, SB: VecStorage<B> + ?Sized> PartialEq<VecInner<B, SB>> for &[A]
 where
     A: PartialEq<B>,
 {
@@ -1323,7 +1399,7 @@ where
     }
 }
 
-impl<A, B, SB: Storage> PartialEq<VecInner<B, SB>> for &mut [A]
+impl<A, B, SB: VecStorage<B> + ?Sized> PartialEq<VecInner<B, SB>> for &mut [A]
 where
     A: PartialEq<B>,
 {
@@ -1332,7 +1408,7 @@ where
     }
 }
 
-impl<A, B, SA: Storage, const N: usize> PartialEq<[B; N]> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized, const N: usize> PartialEq<[B; N]> for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1342,7 +1418,7 @@ where
     }
 }
 
-impl<A, B, SA: Storage, const N: usize> PartialEq<&[B; N]> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized, const N: usize> PartialEq<&[B; N]> for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1352,7 +1428,7 @@ where
     }
 }
 
-impl<A, B, SA: Storage> PartialEq<[B]> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized> PartialEq<[B]> for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1362,7 +1438,7 @@ where
     }
 }
 
-impl<A, B, SA: Storage> PartialEq<&[B]> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized> PartialEq<&[B]> for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1372,7 +1448,7 @@ where
     }
 }
 
-impl<A, B, SA: Storage> PartialEq<&mut [B]> for VecInner<A, SA>
+impl<A, B, SA: VecStorage<A> + ?Sized> PartialEq<&mut [B]> for VecInner<A, SA>
 where
     A: PartialEq<B>,
 {
@@ -1383,9 +1459,10 @@ where
 }
 
 // Implements Eq if underlying data is Eq
-impl<T, S: Storage> Eq for VecInner<T, S> where T: Eq {}
+impl<T, S: VecStorage<T> + ?Sized> Eq for VecInner<T, S> where T: Eq {}
 
-impl<T, SA: Storage, SB: Storage> PartialOrd<VecInner<T, SA>> for VecInner<T, SB>
+impl<T, SA: VecStorage<T> + ?Sized, SB: VecStorage<T> + ?Sized> PartialOrd<VecInner<T, SA>>
+    for VecInner<T, SB>
 where
     T: PartialOrd,
 {
@@ -1394,7 +1471,7 @@ where
     }
 }
 
-impl<T, S: Storage> Ord for VecInner<T, S>
+impl<T, S: VecStorage<T> + ?Sized> Ord for VecInner<T, S>
 where
     T: Ord,
 {
@@ -1404,7 +1481,7 @@ where
     }
 }
 
-impl<T, S: Storage> ops::Deref for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> ops::Deref for VecInner<T, S> {
     type Target = [T];
 
     fn deref(&self) -> &Self::Target {
@@ -1412,45 +1489,45 @@ impl<T, S: Storage> ops::Deref for VecInner<T, S> {
     }
 }
 
-impl<T, S: Storage> ops::DerefMut for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> ops::DerefMut for VecInner<T, S> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.as_mut_slice()
     }
 }
 
-impl<T, S: Storage> borrow::Borrow<[T]> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> borrow::Borrow<[T]> for VecInner<T, S> {
     fn borrow(&self) -> &[T] {
         self.as_slice()
     }
 }
-impl<T, S: Storage> borrow::BorrowMut<[T]> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> borrow::BorrowMut<[T]> for VecInner<T, S> {
     fn borrow_mut(&mut self) -> &mut [T] {
         self.as_mut_slice()
     }
 }
 
-impl<T, S: Storage> AsRef<VecInner<T, S>> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> AsRef<VecInner<T, S>> for VecInner<T, S> {
     #[inline]
     fn as_ref(&self) -> &Self {
         self
     }
 }
 
-impl<T, S: Storage> AsMut<VecInner<T, S>> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> AsMut<VecInner<T, S>> for VecInner<T, S> {
     #[inline]
     fn as_mut(&mut self) -> &mut Self {
         self
     }
 }
 
-impl<T, S: Storage> AsRef<[T]> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> AsRef<[T]> for VecInner<T, S> {
     #[inline]
     fn as_ref(&self) -> &[T] {
         self
     }
 }
 
-impl<T, S: Storage> AsMut<[T]> for VecInner<T, S> {
+impl<T, S: VecStorage<T> + ?Sized> AsMut<[T]> for VecInner<T, S> {
     #[inline]
     fn as_mut(&mut self) -> &mut [T] {
         self
@@ -1959,4 +2036,11 @@ mod tests {
 
         assert!(v.spare_capacity_mut().is_empty());
     }
+
+    fn _test_variance<'a: 'b, 'b>(x: Vec<&'a (), 42>) -> Vec<&'b (), 42> {
+        x
+    }
+    fn _test_variance_view<'a: 'b, 'b, 'c>(x: &'c VecView<&'a ()>) -> &'c VecView<&'b ()> {
+        x
+    }
 }