Implement CloneIn and FromIteratorIn for Vec

Author: TimDiekmann

src/alloc/mod.rs

@@ -9,29 +9,10 @@ use core::{
     num::NonZeroUsize,
     ptr::{self, NonNull},
 };
-pub use liballoc::alloc::Layout;
+pub use liballoc::alloc::{handle_alloc_error, Layout};
 #[cfg(feature = "std")]
 use std::alloc::System;
 
-/// Abort on memory allocation error or failure.
-///
-/// Callers of memory allocation APIs wishing to abort computation
-/// in response to an allocation error are encouraged to call this function,
-/// rather than directly invoking `panic!` or similar.
-///
-/// The default behavior of this function is to print a message to standard error
-/// and abort the process.
-/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`].
-///
-/// [`set_alloc_error_hook`]: https://doc.rust-lang.org/nightly/std/alloc/fn.set_alloc_error_hook.html
-/// [`take_alloc_error_hook`]: https://doc.rust-lang.org/nightly/std/alloc/fn.take_alloc_error_hook.html
-#[allow(clippy::inline_always)]
-#[inline(always)]
-#[deprecated = "allocation functions returns an error, use that instead"]
-pub fn handle_alloc_error(layout: Layout) -> ! {
-    liballoc::alloc::handle_alloc_error(layout)
-}
-
 /// Allocate memory with the global allocator.
 ///
 /// This function forwards calls to the [`GlobalAlloc::alloc`] method

src/clone.rs

@@ -3,9 +3,7 @@ use crate::alloc::AllocRef;
 pub trait CloneIn<A: AllocRef>: Sized {
     type Cloned;
 
-    fn clone_in(&self, a: A) -> Self::Cloned
-    where
-        A: AllocRef;
+    fn clone_in(&self, a: A) -> Self::Cloned;
 
     fn try_clone_in(&self, a: A) -> Result<Self::Cloned, A::Error>;
 }

src/iter.rs

@@ -1,3 +1,5 @@
+use crate::{alloc::AllocRef, collections::CollectionAllocErr};
+
 /// Extend a collection "fallibly" with the contents of an iterator.
 pub trait TryExtend<A> {
     type Err;
@@ -21,3 +23,33 @@ pub trait TryExtend<A> {
     /// ```
     fn try_extend<T: IntoIterator<Item = A>>(&mut self, iter: T) -> Result<(), Self::Err>;
 }
+
+pub trait FromIteratorIn<T, A: AllocRef> {
+    fn from_iter_in<I: IntoIterator<Item = T>>(iter: I, allocator: A) -> Self;
+
+    fn try_from_iter_in<I: IntoIterator<Item = T>>(
+        iter: I,
+        allocator: A,
+    ) -> Result<Self, CollectionAllocErr<A>>
+    where
+        Self: Sized;
+}
+
+pub trait IteratorExt: Iterator + Sized {
+    #[inline]
+    #[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 {
+        FromIteratorIn::from_iter_in(self, allocator)
+    }
+
+    #[inline]
+    #[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]
+    fn try_collect_in<T: FromIteratorIn<Self::Item, A>, A: AllocRef>(
+        self,
+        allocator: A,
+    ) -> Result<T, CollectionAllocErr<A>> {
+        FromIteratorIn::try_from_iter_in(self, allocator)
+    }
+}
+
+impl<T> IteratorExt for T where T: Iterator {}

src/raw_vec.rs

@@ -1,5 +1,6 @@
 use crate::{
     alloc::{
+        handle_alloc_error,
         AllocRef,
         BuildAllocRef,
         CapacityOverflow,
@@ -167,7 +168,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
         match Self::try_with_capacity_in(capacity, a) {
             Ok(vec) => vec,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -202,7 +203,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
         match Self::try_with_capacity_zeroed_in(capacity, a) {
             Ok(vec) => vec,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -416,7 +417,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
         match self.try_double() {
             Ok(_) => (),
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -586,7 +587,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
         match self.try_reserve(used_capacity, needed_extra_capacity) {
             Ok(vec) => vec,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 

src/string.rs

@@ -80,6 +80,7 @@ use core::{
 #[cfg(feature = "std")]
 use std::borrow::Cow;
 
+use crate::alloc::handle_alloc_error;
 pub use liballoc::string::{ParseError, ToString};
 
 /// A UTF-8 encoded, growable string.
@@ -709,7 +710,7 @@ impl<A: DeallocRef> String<A> {
         match Self::try_from_utf8_lossy_in(v, a) {
             Ok(s) => s,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -1255,7 +1256,7 @@ impl<A: DeallocRef> String<A> {
         match self.try_push(ch) {
             Ok(s) => s,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -1507,7 +1508,7 @@ impl<A: DeallocRef> String<A> {
         match self.try_insert(idx, ch) {
             Ok(s) => s,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -1582,7 +1583,7 @@ impl<A: DeallocRef> String<A> {
         match self.try_insert_str(idx, string) {
             Ok(s) => s,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }
 
@@ -1705,7 +1706,7 @@ impl<A: DeallocRef> String<A> {
         match self.try_split_off(at) {
             Ok(s) => s,
             Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
-            Err(CollectionAllocErr::AllocError { .. }) => unreachable!("Infallible allocation"),
+            Err(CollectionAllocErr::AllocError { layout, .. }) => handle_alloc_error(layout.into()),
         }
     }