diff --git a/src/rb/local.rs b/src/rb/local.rs
index c2d383e..1145d52 100644
--- a/src/rb/local.rs
+++ b/src/rb/local.rs
@@ -25,7 +25,7 @@ struct End {
 }
 
 impl End {
-    const fn new(index: usize) -> Self {
+    fn new(index: usize) -> Self {
         Self {
             index: Cell::new(index),
             held: Cell::new(false),
@@ -49,9 +49,8 @@ impl<S: Storage> LocalRb<S> {
     ///
     /// The items in storage inside `read..write` range must be initialized, items outside this range must be uninitialized.
     /// `read` and `write` positions must be valid (see implementation details).
-    ///
-    /// `storage` length must be non-zero.
-    pub const unsafe fn from_raw_parts(storage: S, read: usize, write: usize) -> Self {
+    pub unsafe fn from_raw_parts(storage: S, read: usize, write: usize) -> Self {
+        assert!(!storage.is_empty());
         Self {
             storage,
             read: End::new(read),
diff --git a/src/rb/macros.rs b/src/rb/macros.rs
index 8b698b6..26251d3 100644
--- a/src/rb/macros.rs
+++ b/src/rb/macros.rs
@@ -2,12 +2,7 @@ macro_rules! rb_impl_init {
     ($type:ident) => {
         impl<T, const N: usize> Default for $type<crate::storage::Array<T, N>> {
             fn default() -> Self {
-                Self::new()
-            }
-        }
-        impl<T, const N: usize> $type<crate::storage::Array<T, N>> {
-            pub const fn new() -> Self {
-                unsafe { Self::from_raw_parts(crate::storage::Array::new(crate::utils::uninit_array()), 0, 0) }
+                unsafe { Self::from_raw_parts(crate::utils::uninit_array().into(), usize::default(), usize::default()) }
             }
         }
 
diff --git a/src/rb/shared.rs b/src/rb/shared.rs
index 36cad99..c73cba6 100644
--- a/src/rb/shared.rs
+++ b/src/rb/shared.rs
@@ -59,9 +59,8 @@ impl<S: Storage> SharedRb<S> {
     ///
     /// The items in storage inside `read..write` range must be initialized, items outside this range must be uninitialized.
     /// `read` and `write` positions must be valid (see implementation details).
-    ///
-    /// `storage` length must be non-zero.
-    pub const unsafe fn from_raw_parts(storage: S, read: usize, write: usize) -> Self {
+    pub unsafe fn from_raw_parts(storage: S, read: usize, write: usize) -> Self {
+        assert!(!storage.is_empty());
         Self {
             storage,
             read_index: CachePadded::new(AtomicUsize::new(read)),
diff --git a/src/storage.rs b/src/storage.rs
index c572eb6..bd504e9 100644
--- a/src/storage.rs
+++ b/src/storage.rs
@@ -93,11 +93,6 @@ pub struct Owning<T: ?Sized> {
 unsafe impl<T: ?Sized> Sync for Owning<T> where T: Send {}
 impl<T> From<T> for Owning<T> {
     fn from(value: T) -> Self {
-        Self::new(value)
-    }
-}
-impl<T> Owning<T> {
-    pub const fn new(value: T) -> Self {
         Self {
             data: UnsafeCell::new(value),
         }
diff --git a/src/tests/new.rs b/src/tests/new.rs
index 4cf6dda..7c17f3f 100644
--- a/src/tests/new.rs
+++ b/src/tests/new.rs
@@ -3,9 +3,6 @@ use crate::{storage::Array, traits::*};
 #[cfg(feature = "alloc")]
 use alloc::vec::Vec;
 
-#[allow(clippy::declare_interior_mutable_const)]
-const _RB: Rb<Array<i32, 4>> = Rb::<Array<i32, 4>>::new();
-
 #[test]
 fn new_static() {
     let rb = Rb::<Array<i32, 2>>::default();
diff --git a/src/utils.rs b/src/utils.rs
index 14fb185..e70e05b 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -6,7 +6,7 @@ use core::{
 };
 
 // TODO: Remove on `maybe_uninit_uninit_array` stabilization.
-pub const fn uninit_array<T, const N: usize>() -> [MaybeUninit<T>; N] {
+pub fn uninit_array<T, const N: usize>() -> [MaybeUninit<T>; N] {
     unsafe { MaybeUninit::<[MaybeUninit<T>; N]>::uninit().assume_init() }
 }
 
@@ -39,20 +39,21 @@ pub fn move_uninit_slice<T>(dst: &mut [MaybeUninit<T>], src: &[MaybeUninit<T>])
 }
 
 pub fn array_to_uninit<T, const N: usize>(value: [T; N]) -> [MaybeUninit<T>; N] {
-    let value = MaybeUninit::new(value);
-    let this = &value as *const _ as *const [MaybeUninit<T>; N];
-    unsafe { this.read() }
+    let value = mem::ManuallyDrop::new(value);
+    let ptr = &value as *const _ as *const [MaybeUninit<T>; N];
+    unsafe { ptr.read() }
 }
 
 #[cfg(feature = "alloc")]
-pub fn vec_to_uninit<T>(mut value: Vec<T>) -> Vec<MaybeUninit<T>> {
-    let (ptr, len, cap) = (value.as_mut_ptr() as *mut MaybeUninit<T>, value.len(), value.capacity());
-    mem::forget(value);
-    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+pub fn vec_to_uninit<T>(value: Vec<T>) -> Vec<MaybeUninit<T>> {
+    let value = mem::ManuallyDrop::new(value);
+    let ptr = &value as *const _ as *const Vec<MaybeUninit<T>>;
+    unsafe { ptr.read() }
 }
 
 #[cfg(feature = "alloc")]
 pub fn boxed_slice_to_uninit<T>(value: Box<[T]>) -> Box<[MaybeUninit<T>]> {
-    let ptr = Box::into_raw(value) as *mut [MaybeUninit<T>];
-    unsafe { Box::from_raw(ptr) }
+    let value = mem::ManuallyDrop::new(value);
+    let ptr = &value as *const _ as *const Box<[MaybeUninit<T>]>;
+    unsafe { ptr.read() }
 }