Remove AbortAlloc

Author: TimDiekmann

CHANGELOG.md

@@ -1,7 +1,14 @@
 # v0.7
 
 - Add `Vec`
-- **Breaking Change**: Change Parameter from `B: BuildAlloc` to `A: DeallocRef` to support type inference
+- Add `String`
+
+**Breaking Changes**: 
+
+- Change Parameter from `B: BuildAlloc` to `A: DeallocRef` to support type inference
+- Require nightly compiler
+- Remove `AbortAlloc`
+- Remove bound on `Error = !`
 
 # v0.6
 

src/alloc/abort.rs

@@ -1,10 +1,6 @@
-mod abort;
 mod layout;
 
-pub use self::{
-    abort::AbortAlloc,
-    layout::{LayoutErr, NonZeroLayout},
-};
+pub use self::layout::{LayoutErr, NonZeroLayout};
 pub use core::alloc::GlobalAlloc;
 use core::{
     cmp,

src/alloc/mod.rs

@@ -79,7 +79,7 @@
 //! [`NonZeroLayout::for_value(&*value)`]: crate::alloc::NonZeroLayout::for_value
 
 use crate::{
-    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout},
+    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout},
     clone::CloneIn,
     collections::CollectionAllocErr,
     raw_vec::RawVec,
@@ -105,7 +105,7 @@ use core::{
 /// A pointer type for heap allocation.
 ///
 /// See the [module-level documentation](index.html) for more.
-pub struct Box<T: ?Sized, A: DeallocRef = AbortAlloc<Global>> {
+pub struct Box<T: ?Sized, A: DeallocRef = Global> {
     ptr: Unique<T>,
     build_alloc: A::BuildAlloc,
 }
@@ -131,7 +131,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new(x: T) -> Self {
-        Self::new_in(x, AbortAlloc(Global))
+        Self::new_in(x, Global)
     }
 
     /// Constructs a new box with uninitialized contents.
@@ -156,7 +156,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
-        Self::new_uninit_in(AbortAlloc(Global))
+        Self::new_uninit_in(Global)
     }
 
     /// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
@@ -177,19 +177,16 @@ impl<T, A: AllocRef> Box<T, A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{
-    ///     alloc::{AbortAlloc, Global},
-    ///     boxed::Box,
-    /// };
+    /// use alloc_wg::{alloc::Global, boxed::Box};
     ///
     /// # #[allow(unused_variables)]
-    /// let five = Box::new_in(5, AbortAlloc(Global));
+    /// let five = Box::new_in(5, Global);
     /// ```
     #[allow(clippy::inline_always)]
     #[inline(always)]
     pub fn new_in(x: T, a: A) -> Self
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef,
     {
         unsafe { Self::try_new_in(x, a).unwrap_unchecked() }
     }
@@ -225,12 +222,9 @@ impl<T, A: AllocRef> Box<T, A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{
-    ///     alloc::{AbortAlloc, Global},
-    ///     boxed::Box,
-    /// };
+    /// use alloc_wg::{alloc::Global, boxed::Box};
     ///
-    /// let mut five = Box::<u32, _>::new_uninit_in(AbortAlloc(Global));
+    /// let mut five = Box::<u32, _>::new_uninit_in(Global);
     ///
     /// let five = unsafe {
     ///     // Deferred initialization:
@@ -245,7 +239,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,
     {
         unsafe { Self::try_new_uninit_in(a).unwrap_unchecked() }
     }
@@ -285,7 +279,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,
     {
         unsafe { Self::try_pin_in(x, a).unwrap_unchecked() }
     }
@@ -324,7 +318,7 @@ impl<T> Box<[T]> {
     #[inline(always)]
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
-        Self::new_uninit_slice_in(len, AbortAlloc(Global))
+        Self::new_uninit_slice_in(len, Global)
     }
 }
 
@@ -335,12 +329,9 @@ impl<T, A: AllocRef> Box<[T], A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{
-    ///     alloc::{AbortAlloc, Global},
-    ///     boxed::Box,
-    /// };
+    /// use alloc_wg::{alloc::Global, boxed::Box};
     ///
-    /// let mut values = Box::<[u32], AbortAlloc<Global>>::new_uninit_slice_in(3, AbortAlloc(Global));
+    /// let mut values = Box::<[u32], _>::new_uninit_slice_in(3, Global);
     ///
     /// let values = unsafe {
     ///     // Deferred initialization:
@@ -357,7 +348,7 @@ impl<T, A: AllocRef> Box<[T], A> {
     #[inline(always)]
     pub fn new_uninit_slice_in(len: usize, a: A) -> Box<[mem::MaybeUninit<T>], A>
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef,
     {
         unsafe { Self::try_new_uninit_slice_in(len, a).unwrap_unchecked() }
     }
@@ -524,7 +515,7 @@ impl<T: ?Sized> Box<T> {
     #[allow(clippy::inline_always)]
     #[inline(always)]
     pub unsafe fn from_raw(raw: *mut T) -> Self {
-        Self::from_raw_in(raw, AbortAlloc(Global))
+        Self::from_raw_in(raw, Global)
     }
 }
 
@@ -768,7 +759,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,
 {
     #[must_use]
     fn default() -> Self {
@@ -779,7 +770,7 @@ where
 #[allow(clippy::use_self)]
 impl<T, A> Default for Box<[T], A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef,
 {
     #[must_use]
     fn default() -> Self {
@@ -796,7 +787,7 @@ unsafe fn from_boxed_utf8_unchecked<A: DeallocRef>(v: Box<[u8], A>) -> Box<str,
 #[allow(clippy::use_self)]
 impl<A> Default for Box<str, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef,
 {
     #[must_use]
     fn default() -> Self {
@@ -806,7 +797,7 @@ where
 
 impl<T: Clone, A: Clone> Clone for Box<T, A>
 where
-    A: AllocRef<Error = !>,
+    A: AllocRef,
     A::BuildAlloc: Clone,
 {
     /// Returns a new box with a `clone()` of this box's contents.
@@ -869,7 +860,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,
     {
         Box::new_in(self.as_ref().clone(), a)
     }
@@ -973,7 +964,7 @@ impl<T: ?Sized + Hasher, A: DeallocRef> Hasher for Box<T, A> {
 
 impl<T, A> From<T> for Box<T, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef,
 {
     /// Converts a generic type `T` into a `Box<T>`
     ///
@@ -1007,7 +998,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,
 {
     /// Converts a `&[T]` into a `Box<[T], B>`
     ///
@@ -1036,7 +1027,7 @@ where
 #[allow(clippy::use_self)]
 impl<A> From<&str> for Box<str, A>
 where
-    A: Default + AllocRef<Error = !>,
+    A: Default + AllocRef,
 {
     /// Converts a `&str` into a `Box<str>`
     ///
@@ -1290,16 +1281,13 @@ macro_rules! impl_dispatch_from_dyn {
 }
 
 impl_dispatch_from_dyn!(Global);
-impl_dispatch_from_dyn!(AbortAlloc<Global>);
 #[cfg(feature = "std")]
 impl_dispatch_from_dyn!(std::alloc::System);
-#[cfg(feature = "std")]
-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,
     A::BuildAlloc: Clone,
 {
     fn clone(&self) -> Self {

src/boxed.rs

@@ -5,7 +5,7 @@ pub trait CloneIn<A: AllocRef>: Sized {
 
     fn clone_in(&self, a: A) -> Self::Cloned
     where
-        A: AllocRef<Error = !>;
+        A: AllocRef;
 
     fn try_clone_in(&self, a: A) -> Result<Self::Cloned, A::Error>;
 }

src/clone.rs

@@ -17,7 +17,7 @@ pub trait TryExtend<A> {
     /// message.try_extend(['d', 'e', 'f'].iter())?;
     ///
     /// assert_eq!(vec!['a', 'b', 'c', 'd', 'e', 'f'], message);
-    /// # Ok::<(), alloc_wg::collections::CollectionAllocErr<alloc_wg::alloc::AbortAlloc<alloc_wg::alloc::Global>>>(())
+    /// # Ok::<(), alloc_wg::collections::CollectionAllocErr<alloc_wg::alloc::Global>>(())
     /// ```
     fn try_extend<T: IntoIterator<Item = A>>(&mut self, iter: T) -> Result<(), Self::Err>;
 }