diff --git a/src/alloc/abort.rs b/src/alloc/abort.rs
index 21678d3..d7aed1b 100644
--- a/src/alloc/abort.rs
+++ b/src/alloc/abort.rs
@@ -24,6 +24,12 @@ use core::ptr::NonNull;
 #[derive(Copy, Clone, Debug, Default)]
 pub struct AbortAlloc<Alloc>(pub Alloc);
 
+/// A synonym used to indicate the impossible case will be a panic instead.
+///
+/// `!` in rust really does mean "never" / "impossible", but nothing in the type
+/// system tracks panicking.
+pub type Panic = !;
+
 impl<A: BuildAllocRef> BuildAllocRef for AbortAlloc<A> {
     type Ref = AbortAlloc<A::Ref>;
 
@@ -49,7 +55,7 @@ impl<A: DeallocRef> DeallocRef for AbortAlloc<A> {
 }
 
 impl<A: AllocRef> AllocRef for AbortAlloc<A> {
-    type Error = !;
+    type Error = Panic;
 
     fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         self.0
diff --git a/src/alloc/mod.rs b/src/alloc/mod.rs
index 5870301..5882151 100644
--- a/src/alloc/mod.rs
+++ b/src/alloc/mod.rs
@@ -2,7 +2,7 @@ mod abort;
 mod layout;
 
 pub use self::{
-    abort::AbortAlloc,
+    abort::{AbortAlloc, Panic},
     layout::{LayoutErr, NonZeroLayout},
 };
 pub use core::alloc::GlobalAlloc;
diff --git a/src/boxed.rs b/src/boxed.rs
index f2e9285..2a4ed93 100644
--- a/src/boxed.rs
+++ b/src/boxed.rs
@@ -79,7 +79,7 @@
 //! [`NonZeroLayout::for_value(&*value)`]: crate::alloc::NonZeroLayout::for_value
 
 use crate::{
-    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout},
+    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout, Panic},
     clone::CloneIn,
     collections::CollectionAllocErr,
     raw_vec::RawVec,
@@ -188,7 +188,7 @@ impl<T, A: AllocRef> Box<T, A> {
     #[inline(always)]
     pub fn new_in(x: T, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         let Ok(b) = Self::try_new_in(x, a);
         b
@@ -245,7 +245,7 @@ impl<T, A: AllocRef> Box<T, A> {
     #[inline(always)]
     pub fn new_uninit_in(a: A) -> Box<mem::MaybeUninit<T>, A>
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         let Ok(b) = Self::try_new_uninit_in(a);
         b
@@ -286,7 +286,7 @@ impl<T, A: AllocRef> Box<T, A> {
     #[inline(always)]
     pub fn pin_in(x: T, a: A) -> Pin<Self>
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         let Ok(b) = Self::try_pin_in(x, a);
         b
@@ -331,7 +331,7 @@ impl<T> Box<[T]> {
 }
 
 #[allow(clippy::use_self)]
-impl<T, A: AllocRef<Error = !>> Box<[T], A> {
+impl<T, A: AllocRef<Error = Panic>> Box<[T], A> {
     /// Construct a new boxed slice with uninitialized contents with the spoecified allocator.
     ///
     /// # Example
@@ -775,7 +775,7 @@ unsafe impl<#[may_dangle] T: ?Sized, A: DeallocRef> Drop for Box<T, A> {
 impl<T, A> Default for Box<T, A>
 where
     T: Default,
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     #[must_use]
     fn default() -> Self {
@@ -784,9 +784,9 @@ where
 }
 
 #[allow(clippy::use_self)]
-impl<T, A: AllocRef<Error = !>> Default for Box<[T], A>
+impl<T, A: AllocRef<Error = Panic>> Default for Box<[T], A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     #[must_use]
     fn default() -> Self {
@@ -801,9 +801,9 @@ unsafe fn from_boxed_utf8_unchecked<A: DeallocRef>(v: Box<[u8], A>) -> Box<str,
 }
 
 #[allow(clippy::use_self)]
-impl<A: AllocRef<Error = !>> Default for Box<str, A>
+impl<A: AllocRef<Error = Panic>> Default for Box<str, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     #[must_use]
     fn default() -> Self {
@@ -811,9 +811,9 @@ where
     }
 }
 
-impl<T: Clone, A: AllocRef<Error = !>> Clone for Box<T, A>
+impl<T: Clone, A: AllocRef<Error = Panic>> Clone for Box<T, A>
 where
-    A: AllocRef<Error = !>,
+    A: AllocRef<Error = Panic>,
     A::BuildAlloc: Clone,
 {
     /// Returns a new box with a `clone()` of this box's contents.
@@ -876,7 +876,7 @@ impl<T: Clone, A: AllocRef, B: AllocRef> CloneIn<B> for Box<T, A> {
 
     fn clone_in(&self, a: B) -> Self::Cloned
     where
-        B: AllocRef<Error = !>,
+        B: AllocRef<Error = Panic>,
     {
         Box::new_in(self.as_ref().clone(), a)
     }
@@ -978,9 +978,9 @@ impl<T: ?Sized + Hasher, A: DeallocRef> Hasher for Box<T, A> {
     }
 }
 
-impl<T, A: AllocRef<Error = !>> From<T> for Box<T, A>
+impl<T, A: AllocRef<Error = Panic>> From<T> for Box<T, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     /// Converts a generic type `T` into a `Box<T>`
     ///
@@ -1014,7 +1014,7 @@ impl<T: ?Sized, A: DeallocRef> From<Box<T, A>> for Pin<Box<T, A>> {
 #[allow(clippy::use_self)]
 impl<T: Copy, A> From<&[T]> for Box<[T], A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     /// Converts a `&[T]` into a `Box<[T], B>`
     ///
@@ -1043,7 +1043,7 @@ where
 #[allow(clippy::use_self)]
 impl<A> From<&str> for Box<str, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef<Error = Panic>,
 {
     /// Converts a `&str` into a `Box<str>`
     ///
@@ -1306,7 +1306,7 @@ impl_dispatch_from_dyn!(AbortAlloc<std::alloc::System>);
 #[allow(clippy::items_after_statements)]
 impl<T: Clone, A: Clone> Clone for Box<[T], A>
 where
-    A: AllocRef<Error = !>,
+    A: AllocRef<Error = Panic>,
     A::BuildAlloc: Clone,
 {
     fn clone(&self) -> Self {
diff --git a/src/clone.rs b/src/clone.rs
index 18b43d5..ee4a970 100644
--- a/src/clone.rs
+++ b/src/clone.rs
@@ -1,11 +1,11 @@
-use crate::alloc::AllocRef;
+use crate::alloc::{AllocRef, Panic};
 
 pub trait CloneIn<A: AllocRef>: Sized {
     type Cloned;
 
     fn clone_in(&self, a: A) -> Self::Cloned
     where
-        A: AllocRef<Error = !>;
+        A: AllocRef<Error = Panic>;
 
     fn try_clone_in(&self, a: A) -> Result<Self::Cloned, A::Error>;
 }
diff --git a/src/iter.rs b/src/iter.rs
index d511f34..5d1421f 100644
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -1,4 +1,4 @@
-use crate::{alloc::AllocRef, collections::CollectionAllocErr};
+use crate::{alloc::{AllocRef, Panic}, collections::CollectionAllocErr};
 
 /// Extend a collection "fallibly" with the contents of an iterator.
 pub trait TryExtend<A> {
@@ -27,7 +27,7 @@ pub trait TryExtend<A> {
 pub trait FromIteratorIn<T, A: AllocRef> {
     fn from_iter_in<I: IntoIterator<Item = T>>(iter: I, allocator: A) -> Self
     where
-        A: AllocRef<Error = !>;
+        A: AllocRef<Error = Panic>;
 
     fn try_from_iter_in<I: IntoIterator<Item = T>>(
         iter: I,
@@ -42,7 +42,7 @@ pub trait IteratorExt: Iterator + Sized {
     #[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
     fn collect_in<T: FromIteratorIn<Self::Item, A>, A: AllocRef>(self, allocator: A) -> T
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         FromIteratorIn::from_iter_in(self, allocator)
     }
diff --git a/src/raw_vec.rs b/src/raw_vec.rs
index 1f41254..3ba7ab0 100644
--- a/src/raw_vec.rs
+++ b/src/raw_vec.rs
@@ -8,6 +8,7 @@ use crate::{
         Global,
         NonZeroLayout,
         ReallocRef,
+        Panic,
     },
     boxed::Box,
     collections::CollectionAllocErr,
@@ -162,7 +163,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// * on 32-bit platforms if the requested capacity exceeds `isize::MAX` bytes.
     pub fn with_capacity_in(capacity: usize, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match Self::try_with_capacity_in(capacity, a) {
             Ok(vec) => vec,
@@ -198,7 +199,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// * on 32-bit platforms if the requested capacity exceeds `isize::MAX` bytes.
     pub fn with_capacity_zeroed_in(capacity: usize, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match Self::try_with_capacity_zeroed_in(capacity, a) {
             Ok(vec) => vec,
@@ -419,7 +420,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// ```
     pub fn double(&mut self)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_double() {
             Ok(_) => (),
@@ -590,7 +591,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// ```
     pub fn reserve(&mut self, used_capacity: usize, needed_extra_capacity: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_reserve(used_capacity, needed_extra_capacity) {
             Ok(vec) => vec,
@@ -634,7 +635,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// * on 32-bit platforms if the requested capacity exceeds `isize::MAX` bytes.
     pub fn reserve_exact(&mut self, used_capacity: usize, needed_extra_capacity: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_reserve_exact(used_capacity, needed_extra_capacity) {
             Ok(_) => (),
@@ -736,7 +737,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// Panics if the given amount is *larger* than the current capacity.
     pub fn shrink_to_fit(&mut self, amount: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_shrink_to_fit(amount) {
             Ok(_) => (),
diff --git a/src/string.rs b/src/string.rs
index 71e01a4..ed0bca7 100644
--- a/src/string.rs
+++ b/src/string.rs
@@ -52,7 +52,7 @@
 //! ```
 
 use crate::{
-    alloc::{AbortAlloc, AllocRef, DeallocRef, Global, ReallocRef},
+    alloc::{AbortAlloc, AllocRef, DeallocRef, Global, ReallocRef, Panic},
     boxed::Box,
     collections::CollectionAllocErr,
     iter::TryExtend,
@@ -580,7 +580,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn with_capacity_in(capacity: usize, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match Self::try_with_capacity_in(capacity, a) {
             Ok(vec) => vec,
@@ -608,7 +608,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn from_str_in(s: &str, a: A) -> Self
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         let mut v = Self::with_capacity_in(s.len(), a);
         v.push_str(s);
@@ -708,7 +708,7 @@ impl<A: DeallocRef> String<A> {
     /// Panics if allocation fails.
     pub fn from_utf8_lossy_in(v: &[u8], a: A) -> Self
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match Self::try_from_utf8_lossy_in(v, a) {
             Ok(s) => s,
@@ -757,7 +757,7 @@ impl<A: DeallocRef> String<A> {
     /// Like `from_utf16` but parameterized over the choice of allocator for the returned `String`.
     pub fn from_utf16_in(v: &[u16], a: A) -> Result<Self, FromUtf16Error>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         // This isn't done via collect::<Result<_, _>>() for performance reasons.
         // FIXME: the function can be simplified again when #48994 is closed.
@@ -932,7 +932,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn push_str(&mut self, string: &str)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.vec.extend_from_slice(string.as_bytes())
     }
@@ -1016,7 +1016,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn reserve(&mut self, additional: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.vec.reserve(additional)
     }
@@ -1069,7 +1069,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn reserve_exact(&mut self, additional: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.vec.reserve_exact(additional)
     }
@@ -1180,7 +1180,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn shrink_to_fit(&mut self)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.vec.shrink_to_fit()
     }
@@ -1224,7 +1224,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn shrink_to(&mut self, min_capacity: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.vec.shrink_to(min_capacity)
     }
@@ -1263,7 +1263,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn push(&mut self, ch: char)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_push(ch) {
             Ok(s) => s,
@@ -1516,7 +1516,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn insert(&mut self, idx: usize, ch: char)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_insert(idx, ch) {
             Ok(s) => s,
@@ -1592,7 +1592,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn insert_str(&mut self, idx: usize, string: &str)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_insert_str(idx, string) {
             Ok(s) => s,
@@ -1606,7 +1606,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn try_insert_str(&mut self, idx: usize, string: &str) -> Result<(), CollectionAllocErr<A>>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         assert!(self.is_char_boundary(idx));
 
@@ -1716,7 +1716,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn split_off(&mut self, at: usize) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match self.try_split_off(at) {
             Ok(s) => s,
@@ -1856,7 +1856,7 @@ impl<A: DeallocRef> String<A> {
     pub fn replace_range<R>(&mut self, range: R, replace_with: &str)
     where
         R: RangeBounds<usize>,
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         // Memory safety
         //
@@ -1901,7 +1901,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn into_boxed_str(self) -> Box<str, A>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         let slice = self.vec.into_boxed_slice();
         unsafe { from_boxed_utf8_unchecked(slice) }
@@ -2007,7 +2007,7 @@ impl fmt::Display for FromUtf16Error {
     }
 }
 
-impl<A: AllocRef<Error = !>> Clone for String<A>
+impl<A: AllocRef<Error = Panic>> Clone for String<A>
 where
     A: AllocRef,
     A::BuildAlloc: Clone,
@@ -2033,7 +2033,7 @@ impl<A: AllocRef, B: AllocRef> CloneIn<B> for String<A> {
     #[must_use = "Cloning is expected to be expensive"]
     fn clone_in(&self, a: B) -> Self::Cloned
     where
-        B: AllocRef<Error = !>,
+        B: AllocRef<Error = Panic>,
     {
         String {
             vec: self.vec.clone_in(a),
@@ -2110,7 +2110,7 @@ impl<'a> FromIterator<Cow<'a, str>> for String {
 
 impl<A> Extend<char> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
         let iterator = iter.into_iter();
@@ -2134,7 +2134,7 @@ impl<A: ReallocRef> TryExtend<char> for String<A> {
 
 impl<'a, A> Extend<&'a char> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
         self.extend(iter.into_iter().cloned());
@@ -2151,7 +2151,7 @@ impl<'a, A: ReallocRef> TryExtend<&'a char> for String<A> {
 
 impl<'a, A> Extend<&'a str> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |s| self.push_str(s));
@@ -2168,7 +2168,7 @@ impl<'a, A: ReallocRef> TryExtend<&'a str> for String<A> {
 
 impl<A, B> Extend<String<B>> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
     B: DeallocRef,
 {
     fn extend<I: IntoIterator<Item = String<B>>>(&mut self, iter: I) {
@@ -2188,7 +2188,7 @@ impl<A: ReallocRef, B: DeallocRef> TryExtend<String<B>> for String<A> {
 #[cfg(feature = "std")]
 impl<'a, A> Extend<Cow<'a, str>> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |s| self.push_str(&s));
@@ -2324,7 +2324,7 @@ impl<A: DeallocRef> hash::Hash for String<A> {
 /// ```
 impl<A> Add<&str> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     type Output = Self;
 
@@ -2340,7 +2340,7 @@ where
 /// This has the same behavior as the [`push_str`][`String::push_str`] method.
 impl<A> AddAssign<&str> for String<A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     #[inline]
     fn add_assign(&mut self, other: &str) {
@@ -2516,7 +2516,7 @@ impl From<Box<str>> for String {
 
 impl<A> From<String<A>> for Box<str, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     /// Converts the given `String` to a boxed `str` slice that is owned.
     ///
diff --git a/src/vec.rs b/src/vec.rs
index 0e35199..238e938 100644
--- a/src/vec.rs
+++ b/src/vec.rs
@@ -69,7 +69,7 @@
 //! [`vec!`]: ../macro.vec.html
 
 use crate::{
-    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, ReallocRef},
+    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, ReallocRef, Panic},
     boxed::Box,
     clone::CloneIn,
     collections::CollectionAllocErr,
@@ -490,7 +490,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     #[inline]
     pub fn with_capacity_in(capacity: usize, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         Self {
             buf: RawVec::with_capacity_in(capacity, a),
@@ -612,7 +612,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn reserve(&mut self, additional: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.buf.reserve(self.len, additional);
     }
@@ -645,7 +645,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn reserve_exact(&mut self, additional: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.buf.reserve_exact(self.len, additional);
     }
@@ -759,7 +759,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn shrink_to_fit(&mut self)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         if self.capacity() != self.len {
             self.buf.shrink_to_fit(self.len);
@@ -805,7 +805,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// * Panics if the reallocation fails.
     pub fn shrink_to(&mut self, min_capacity: usize)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.buf.shrink_to_fit(cmp::max(self.len, min_capacity));
     }
@@ -852,7 +852,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn into_boxed_slice(self) -> Box<[T], A>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_into_boxed_slice() {
             Ok(vec) => vec,
@@ -1197,7 +1197,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// ```
     pub fn insert(&mut self, index: usize, element: T)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_insert(index, element) {
             Ok(vec) => vec,
@@ -1304,7 +1304,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     pub fn retain<F>(&mut self, mut f: F)
     where
         F: FnMut(&T) -> bool,
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.drain_filter(|x| !f(x));
     }
@@ -1387,7 +1387,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     #[inline]
     pub fn push(&mut self, value: T)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_push(value) {
             Ok(vec) => vec,
@@ -1473,7 +1473,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     #[inline]
     pub fn append(&mut self, other: &mut Self)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_append(other) {
             Ok(vec) => vec,
@@ -1659,7 +1659,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     #[inline]
     pub fn split_off(&mut self, at: usize) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match self.try_split_off(at) {
             Ok(vec) => vec,
@@ -1730,7 +1730,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     pub fn resize_with<F>(&mut self, new_len: usize, f: F)
     where
         F: FnMut() -> T,
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_resize_with(new_len, f) {
             Ok(vec) => vec,
@@ -1785,7 +1785,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     pub fn leak<'a>(vec: Self) -> &'a mut [T]
     where
         T: 'a, // Technically not needed, but kept to be explicit.
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         Box::leak(vec.into_boxed_slice())
     }
@@ -1834,7 +1834,7 @@ impl<T: Clone, A: ReallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn resize(&mut self, new_len: usize, value: T)
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         match self.try_resize(new_len, value) {
             Ok(_) => (),
@@ -1882,7 +1882,7 @@ impl<T: Clone, A: ReallocRef> Vec<T, A> {
     /// Panics if the reallocation fails.
     pub fn extend_from_slice(&mut self, other: &[T])
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
     {
         self.spec_extend(other.iter().cloned())
     }
@@ -2051,7 +2051,7 @@ pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
 #[doc(hidden)]
 pub fn from_elem_in<T: Clone, A>(elem: T, n: usize, a: A) -> Vec<T, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     match try_from_elem_in(elem, n, a) {
         Ok(vec) => vec,
@@ -2199,7 +2199,7 @@ unsafe impl<T: ?Sized> IsZero for Option<Box<T>> {
 // Common trait implementations for Vec
 ////////////////////////////////////////////////////////////////////////////////
 
-impl<T: Clone, A: AllocRef<Error = !>> Clone for Vec<T, A>
+impl<T: Clone, A: AllocRef<Error = Panic>> Clone for Vec<T, A>
 where
     A: AllocRef,
     A::BuildAlloc: Clone,
@@ -2224,7 +2224,7 @@ impl<T: Clone, A: AllocRef, B: AllocRef> CloneIn<B> for Vec<T, A> {
 
     fn clone_in(&self, a: B) -> Self::Cloned
     where
-        B: AllocRef<Error = !>,
+        B: AllocRef<Error = Panic>,
     {
         let Ok(v) = self.try_clone_in(a);
         v
@@ -2300,7 +2300,7 @@ impl<T, A: ReallocRef> FromIteratorIn<T, A> for Vec<T, A> {
     #[must_use]
     fn from_iter_in<I: IntoIterator<Item = T>>(iter: I, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         <Self as SpecExtend<T, I::IntoIter, A>>::from_iter_in(iter.into_iter(), a)
     }
@@ -2376,7 +2376,7 @@ impl<'a, T, A: DeallocRef> IntoIterator for &'a mut Vec<T, A> {
 
 impl<T, A> Extend<T> for Vec<T, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
@@ -2397,7 +2397,7 @@ trait SpecExtend<T, I, A: AllocRef>: Sized {
     #[inline]
     fn from_iter_in(iter: I, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match Self::try_from_iter_in(iter, a) {
             Ok(v) => v,
@@ -2412,7 +2412,7 @@ trait SpecExtend<T, I, A: AllocRef>: Sized {
     #[inline]
     fn spec_extend(&mut self, iter: I)
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = Panic>,
     {
         match self.try_spec_extend(iter) {
             Ok(_) => (),
@@ -2625,7 +2625,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     #[inline]
     pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
         R: RangeBounds<usize>,
         I: IntoIterator<Item = T>,
     {
@@ -2684,7 +2684,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// ```
     pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
     where
-        A: ReallocRef<Error = !>,
+        A: ReallocRef<Error = Panic>,
         F: FnMut(&mut T) -> bool,
     {
         let old_len = self.len();
@@ -2713,7 +2713,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
 /// [`copy_from_slice`]: ../../std/primitive.slice.html#method.copy_from_slice
 impl<'a, T: 'a + Copy, A> Extend<&'a T> for Vec<T, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.extend(iter.into_iter().cloned())
@@ -3172,7 +3172,7 @@ impl<T, A: DeallocRef> FusedIterator for Drain<'_, T, A> {}
 #[derive(Debug)]
 pub struct Splice<'a, I: Iterator + 'a, A = AbortAlloc<Global>>
 where
-    A: ReallocRef<Error = !>, // Because Drop can allocate
+    A: ReallocRef<Error = Panic>, // Because Drop can allocate
 {
     drain: Drain<'a, I::Item, A>,
     replace_with: I,
@@ -3180,7 +3180,7 @@ where
 
 impl<I: Iterator, A> Iterator for Splice<'_, I, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     type Item = I::Item;
 
@@ -3195,18 +3195,18 @@ where
 
 impl<I: Iterator, A> DoubleEndedIterator for Splice<'_, I, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.drain.next_back()
     }
 }
 
-impl<I: Iterator, A> ExactSizeIterator for Splice<'_, I, A> where A: ReallocRef<Error = !> {}
+impl<I: Iterator, A> ExactSizeIterator for Splice<'_, I, A> where A: ReallocRef<Error = Panic> {}
 
 impl<I: Iterator, A> Drop for Splice<'_, I, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     fn drop(&mut self) {
         self.drain.by_ref().for_each(drop);
@@ -3252,7 +3252,7 @@ where
 /// Private helper methods for `Splice::drop`
 impl<T, A: DeallocRef> Drain<'_, T, A>
 where
-    A: ReallocRef<Error = !>,
+    A: ReallocRef<Error = Panic>,
 {
     /// The range from `self.vec.len` to `self.tail_start` contains elements
     /// that have been moved out.