diff --git a/Cargo.toml b/Cargo.toml
index 304a10f..4f86e55 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "im-lists"
-version = "0.10.0"
+version = "0.11.0"
 authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
 edition = "2021"
 readme = "README.md"
@@ -14,6 +14,7 @@ categories = ["data-structures"]
 
 [dependencies]
 smallvec = { version = "1.10.0" }
+generic_singleton = "0.5.1"
 
 [dev-dependencies]
 criterion = "0.3.5"
diff --git a/src/list.rs b/src/list.rs
index e43bb4a..d541632 100644
--- a/src/list.rs
+++ b/src/list.rs
@@ -15,7 +15,7 @@ use std::{cmp::Ordering, iter::FromIterator, marker::PhantomData};
 use crate::{
     handler::{DefaultDropHandler, DropHandler},
     shared::{ArcPointer, PointerFamily, RcPointer},
-    unrolled::{ConsumingWrapper, IterWrapper, UnrolledList},
+    unrolled::{ConsumingWrapper, IterWrapper, UnrolledCell, UnrolledList},
 };
 
 /// A persistent list.
@@ -55,7 +55,7 @@ use crate::{
 /// This means for operations that for a normal linked list may take linear time *Θ(n)*, we get a constant factor
 /// decrease of either a factor of *m* or *m / 2*. Similarly, we will see O(log(n)) performance characteristics if the growth rate is set to be larger than 1.
 pub struct GenericList<
-    T: Clone,
+    T: Clone + 'static,
     P: PointerFamily = RcPointer,
     const N: usize = 256,
     const G: usize = 1,
@@ -68,6 +68,16 @@ pub type List<T> = GenericList<T, RcPointer, 256>;
 pub type SharedVList<T> = GenericList<T, ArcPointer, 2, 2>;
 pub type VList<T> = GenericList<T, RcPointer, 2, 2>;
 
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+pub struct RawCell<
+    T: Clone + 'static,
+    P: PointerFamily,
+    const N: usize,
+    const G: usize,
+    D: DropHandler<GenericList<T, P, N, G, D>>,
+>(*const UnrolledCell<T, P, N, G>, PhantomData<D>);
+
 impl<T: Clone, P: PointerFamily, const N: usize, const G: usize, D: DropHandler<Self>> Clone
     for GenericList<T, P, N, G, D>
 {
@@ -140,8 +150,21 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize, D: DropHandler<
     }
 
     #[doc(hidden)]
-    pub fn draining_iterator(mut self) -> impl Iterator<Item = T> {
+    pub fn draining_iterator(
+        mut self,
+        // default: UnrolledList<T, P, N, G>,
+    ) -> impl Iterator<Item = T> {
         std::mem::take(&mut self.0).draining_iterator()
+        // std::mem::replace(&mut self.0, default).draining_iterator()
+        // todo!()
+        // let x = MaybeUninit::new(self);
+        // let x = x.as_ptr();
+
+        // unsafe { std::ptr::read(&(*x).0).draining_iterator() }
+
+        // self.0.draining_iterator()
+        // ManuallyDrop::take(slot)
+        // todo!()
     }
 
     #[doc(hidden)]
@@ -156,6 +179,32 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize, D: DropHandler<
             .collect()
     }
 
+    #[doc(hidden)]
+    pub fn as_ptr(&self) -> RawCell<T, P, N, G, D> {
+        RawCell(self.0.as_ptr(), PhantomData)
+    }
+
+    /// Call a function on a raw pointer
+    /// # Safety
+    /// This must be called with a valid pointer as returned from as_ptr
+    #[doc(hidden)]
+    pub unsafe fn call_from_raw<O, F: FnOnce(&Self) -> O>(
+        cell: RawCell<T, P, N, G, D>,
+        func: F,
+    ) -> O {
+        let value = unsafe { Self::from_raw(cell) };
+        let res = func(&value);
+        std::mem::forget(value);
+        res
+    }
+
+    /// # Safety
+    /// This must be called with a valid pointer as returned from as_ptr
+    #[doc(hidden)]
+    unsafe fn from_raw(cell: RawCell<T, P, N, G, D>) -> Self {
+        Self(UnrolledList(P::from_raw(cell.0)), PhantomData)
+    }
+
     /// Get the length of the list
     ///
     /// # Examples
@@ -593,7 +642,7 @@ impl<
 /// An iterator over lists with values of type `T`.
 pub struct Iter<
     'a,
-    T: Clone,
+    T: Clone + 'static,
     P: PointerFamily,
     const N: usize,
     const G: usize,
@@ -602,7 +651,7 @@ pub struct Iter<
 
 impl<
         'a,
-        T: Clone,
+        T: Clone + 'static,
         P: PointerFamily,
         const N: usize,
         const G: usize,
@@ -651,7 +700,7 @@ impl<
 
 /// A consuming iterator over lists with values of type `T`.
 pub struct ConsumingIter<
-    T: Clone,
+    T: Clone + 'static,
     P: PointerFamily,
     const N: usize,
     const G: usize,
@@ -851,8 +900,15 @@ mod tests {
     use crate::{list, vlist};
 
     #[test]
-    fn strong_count() {
+    fn strong_count_empty() {
         let list: List<usize> = List::new();
+        assert!(list.strong_count() >= 1);
+    }
+
+    #[test]
+    fn strong_count() {
+        let mut list: List<usize> = List::new();
+        list.cons_mut(1);
         assert_eq!(list.strong_count(), 1);
     }
 
@@ -1219,8 +1275,15 @@ mod arc_tests {
     use crate::{shared_list, shared_vlist, vlist};
 
     #[test]
-    fn strong_count() {
+    fn strong_count_empty() {
         let list: SharedList<usize> = SharedList::new();
+        assert!(list.strong_count() >= 1);
+    }
+
+    #[test]
+    fn strong_count() {
+        let mut list: SharedList<usize> = SharedList::new();
+        list.cons_mut(1);
         assert_eq!(list.strong_count(), 1);
     }
 
@@ -1587,4 +1650,17 @@ mod arc_tests {
 
         // assert!(list.is_empty())
     }
+
+    #[test]
+    fn raw_test() {
+        let list = (0..1000usize).into_iter().collect::<SharedVList<_>>();
+
+        // Get the inner pointer, and then otherwise
+        // call the drop implementation as neatly as possible.
+        let pointer = list.as_ptr();
+
+        // Create value from pointer
+        let value = unsafe { SharedVList::from_raw(pointer) };
+        std::mem::forget(value);
+    }
 }
diff --git a/src/shared.rs b/src/shared.rs
index 2879ce4..3a00cfe 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -1,7 +1,7 @@
 use std::{ops::Deref, rc::Rc, sync::Arc};
 
-pub trait PointerFamily {
-    type Pointer<T>: Deref<Target = T>;
+pub trait PointerFamily: 'static {
+    type Pointer<T: 'static>: Deref<Target = T>;
 
     fn new<T>(value: T) -> Self::Pointer<T>;
     fn strong_count<T>(this: &Self::Pointer<T>) -> usize;
@@ -11,80 +11,100 @@ pub trait PointerFamily {
     fn make_mut<T: Clone>(ptr: &mut Self::Pointer<T>) -> &mut T;
     fn clone<T>(ptr: &Self::Pointer<T>) -> Self::Pointer<T>;
     fn as_ptr<T>(this: &Self::Pointer<T>) -> *const T;
+    fn into_raw<T>(this: Self::Pointer<T>) -> *const T;
+    /// # Safety
+    /// This must be called from a pointer as returned from into_raw
+    unsafe fn from_raw<T>(this: *const T) -> Self::Pointer<T>;
 }
 
 pub struct RcPointer;
 
 impl PointerFamily for RcPointer {
-    type Pointer<T> = Rc<T>;
+    type Pointer<T: 'static> = Rc<T>;
 
-    fn new<T>(value: T) -> Self::Pointer<T> {
+    fn new<T: 'static>(value: T) -> Self::Pointer<T> {
         Rc::new(value)
     }
 
-    fn strong_count<T>(this: &Self::Pointer<T>) -> usize {
+    fn strong_count<T: 'static>(this: &Self::Pointer<T>) -> usize {
         Rc::strong_count(this)
     }
 
-    fn try_unwrap<T>(this: Self::Pointer<T>) -> Option<T> {
+    fn try_unwrap<T: 'static>(this: Self::Pointer<T>) -> Option<T> {
         Rc::try_unwrap(this).ok()
     }
 
-    fn get_mut<T>(this: &mut Self::Pointer<T>) -> Option<&mut T> {
+    fn get_mut<T: 'static>(this: &mut Self::Pointer<T>) -> Option<&mut T> {
         Rc::get_mut(this)
     }
 
-    fn ptr_eq<T>(this: &Self::Pointer<T>, other: &Self::Pointer<T>) -> bool {
+    fn ptr_eq<T: 'static>(this: &Self::Pointer<T>, other: &Self::Pointer<T>) -> bool {
         Rc::ptr_eq(this, other)
     }
 
-    fn make_mut<T: Clone>(ptr: &mut Self::Pointer<T>) -> &mut T {
+    fn make_mut<T: Clone + 'static>(ptr: &mut Self::Pointer<T>) -> &mut T {
         Rc::make_mut(ptr)
     }
 
-    fn clone<T>(ptr: &Self::Pointer<T>) -> Self::Pointer<T> {
+    fn clone<T: 'static>(ptr: &Self::Pointer<T>) -> Self::Pointer<T> {
         Rc::clone(ptr)
     }
 
-    fn as_ptr<T>(this: &Self::Pointer<T>) -> *const T {
+    fn as_ptr<T: 'static>(this: &Self::Pointer<T>) -> *const T {
         Rc::as_ptr(this)
     }
+
+    fn into_raw<T: 'static>(this: Self::Pointer<T>) -> *const T {
+        Rc::into_raw(this)
+    }
+
+    unsafe fn from_raw<T: 'static>(this: *const T) -> Self::Pointer<T> {
+        Rc::from_raw(this)
+    }
 }
 
 pub struct ArcPointer;
 
 impl PointerFamily for ArcPointer {
-    type Pointer<T> = Arc<T>;
+    type Pointer<T: 'static> = Arc<T>;
 
-    fn new<T>(value: T) -> Self::Pointer<T> {
+    fn new<T: 'static>(value: T) -> Self::Pointer<T> {
         Arc::new(value)
     }
 
-    fn strong_count<T>(this: &Self::Pointer<T>) -> usize {
+    fn strong_count<T: 'static>(this: &Self::Pointer<T>) -> usize {
         Arc::strong_count(this)
     }
 
-    fn try_unwrap<T>(this: Self::Pointer<T>) -> Option<T> {
+    fn try_unwrap<T: 'static>(this: Self::Pointer<T>) -> Option<T> {
         Arc::try_unwrap(this).ok()
     }
 
-    fn get_mut<T>(this: &mut Self::Pointer<T>) -> Option<&mut T> {
+    fn get_mut<T: 'static>(this: &mut Self::Pointer<T>) -> Option<&mut T> {
         Arc::get_mut(this)
     }
 
-    fn ptr_eq<T>(this: &Self::Pointer<T>, other: &Self::Pointer<T>) -> bool {
+    fn ptr_eq<T: 'static>(this: &Self::Pointer<T>, other: &Self::Pointer<T>) -> bool {
         Arc::ptr_eq(this, other)
     }
 
-    fn make_mut<T: Clone>(ptr: &mut Self::Pointer<T>) -> &mut T {
+    fn make_mut<T: Clone + 'static>(ptr: &mut Self::Pointer<T>) -> &mut T {
         Arc::make_mut(ptr)
     }
 
-    fn clone<T>(ptr: &Self::Pointer<T>) -> Self::Pointer<T> {
+    fn clone<T: 'static>(ptr: &Self::Pointer<T>) -> Self::Pointer<T> {
         Arc::clone(ptr)
     }
 
-    fn as_ptr<T>(this: &Self::Pointer<T>) -> *const T {
+    fn as_ptr<T: 'static>(this: &Self::Pointer<T>) -> *const T {
         Arc::as_ptr(this)
     }
+
+    fn into_raw<T: 'static>(this: Self::Pointer<T>) -> *const T {
+        Arc::into_raw(this)
+    }
+
+    unsafe fn from_raw<T: 'static>(this: *const T) -> Self::Pointer<T> {
+        Arc::from_raw(this)
+    }
 }
diff --git a/src/unrolled.rs b/src/unrolled.rs
index 27cbf8b..67194d8 100644
--- a/src/unrolled.rs
+++ b/src/unrolled.rs
@@ -16,7 +16,7 @@ type ConsumingIter<T, P, const N: usize, const G: usize> = FlatMap<
     fn(UnrolledList<T, P, N, G>) -> MaybeCloned<T, P, N, G>, // Rev<std::iter::Take<std::vec::IntoIter<T>>>,
 >;
 
-enum MaybeCloned<T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+enum MaybeCloned<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> {
     Owned(Rev<std::iter::Take<std::vec::IntoIter<T>>>),
     Cloned(OwnedNodeIterator<T, P, N, G>),
 }
@@ -86,8 +86,24 @@ type DrainingConsumingIter<T, P, const N: usize, const G: usize> = FlatMap<
     fn(UnrolledList<T, P, N, G>) -> Rev<std::iter::Take<std::vec::IntoIter<T>>>,
 >;
 
+fn empty_list<T: Clone, P: PointerFamily, const N: usize, const G: usize>(
+) -> P::Pointer<UnrolledCell<T, P, N, G>>
+where
+    P::Pointer<UnrolledCell<T, P, N, G>>: 'static,
+{
+    let mut output = None;
+    generic_singleton::get_or_init_thread_local!(
+        || P::new(UnrolledCell::new()),
+        |cell: &P::Pointer<UnrolledCell<T, P, N, G>>| {
+            output = Some(P::clone(cell));
+        }
+    );
+
+    output.unwrap()
+}
+
 #[derive(Eq)]
-pub(crate) struct UnrolledList<T: Clone, P: PointerFamily, const N: usize, const G: usize = 1>(
+pub struct UnrolledList<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize>(
     pub(crate) P::Pointer<UnrolledCell<T, P, N, G>>,
 );
 
@@ -126,7 +142,13 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Default
 
 impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> UnrolledList<T, P, N, G> {
     pub fn new() -> Self {
-        UnrolledList(P::new(UnrolledCell::new()))
+        // UnrolledList(P::new(UnrolledCell::new()))
+
+        UnrolledList(empty_list::<T, P, N, G>())
+    }
+
+    pub fn as_ptr(&self) -> *const UnrolledCell<T, P, N, G> {
+        P::as_ptr(&self.0)
     }
 
     pub fn new_with_capacity() -> Self {
@@ -423,20 +445,36 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> UnrolledList<T,
     // Returns None if the next is empty - otherwise updates self to be the rest
     pub fn cdr_mut(&mut self) -> Option<&mut Self> {
         if self.0.index > 1 {
+            // This will allocate a new cell
             P::make_mut(&mut self.0).index -= 1;
             Some(self)
         } else {
-            let inner = P::make_mut(&mut self.0);
-            let output = inner.next.take();
-            match output {
-                Some(x) => {
-                    *self = x;
-                    Some(self)
-                }
-                None => {
-                    *self = Self::new();
-                    None
+            let inner = P::get_mut(&mut self.0);
+
+            match inner {
+                Some(inner) => {
+                    let output = inner.next.take();
+                    match output {
+                        Some(x) => {
+                            *self = x;
+                            Some(self)
+                        }
+                        None => {
+                            *self = Self::new();
+                            None
+                        }
+                    }
                 }
+                None => match &self.0.next {
+                    Some(x) => {
+                        *self = x.clone();
+                        Some(self)
+                    }
+                    None => {
+                        *self = Self::new();
+                        None
+                    }
+                },
             }
         }
     }
@@ -573,7 +611,9 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> UnrolledList<T,
 }
 
 // Don't blow the stack
-impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Drop for UnrolledCell<T, P, N, G> {
+impl<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> Drop
+    for UnrolledCell<T, P, N, G>
+{
     fn drop(&mut self) {
         let mut cur = self.next.take().map(|x| x.0);
         loop {
@@ -588,7 +628,7 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Drop for Unroll
     }
 }
 
-pub(crate) struct UnrolledCell<T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+pub struct UnrolledCell<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> {
     index: usize,
     elements: P::Pointer<Vec<T>>,
     pub(crate) next: Option<UnrolledList<T, P, N, G>>,
@@ -702,7 +742,12 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Extend<T>
     }
 }
 
-pub(crate) struct DrainingNodeIter<T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+pub(crate) struct DrainingNodeIter<
+    T: Clone + 'static,
+    P: PointerFamily,
+    const N: usize,
+    const G: usize,
+> {
     cur: Option<UnrolledList<T, P, N, G>>,
     _inner: PhantomData<T>,
 }
@@ -712,6 +757,8 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
 {
     type Item = UnrolledList<T, P, N, G>;
     fn next(&mut self) -> Option<Self::Item> {
+        // This is doing allocation. Don't want that.
+
         if let Some(mut _self) = std::mem::take(&mut self.cur) {
             if let Some(next) = _self.0.next.as_ref() {
                 // If we can, drop these values!
@@ -729,10 +776,43 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
         } else {
             None
         }
+
+        // let mut _self = &mut self.cur;
+        // let mut ret = None;
+
+        // if let Some(next) = _self.as_mut().and_then(|x| x.0.next.as_ref()) {
+        //     // If the next is empty, then we don't want to point to it?
+        //     if next.is_empty() {
+        //         let mut value = None;
+        //         std::mem::swap(&mut self.cur, &mut value);
+        //         return value;
+        //     }
+
+        //     // If we can, drop these values!
+        //     if next.strong_count() == 1 && P::strong_count(&next.0.elements) == 1 {
+        //         // self.cur = _self.0.next.clone();
+        //         // self.cur = P::get_mut(&mut _self.0).and_then(|x| x.next.take());
+        //         // todo!()
+
+        //         let mut value = _self
+        //             .as_mut()
+        //             .and_then(|x| P::get_mut(&mut x.0).and_then(|x| x.next.take()));
+
+        //         std::mem::swap(&mut self.cur, &mut value);
+
+        //         ret = value
+        //     } else {
+        //         self.cur = None
+        //     }
+        // } else {
+        //     self.cur = None
+        // }
+
+        // ret
     }
 }
 
-pub(crate) struct NodeIter<T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+pub(crate) struct NodeIter<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> {
     cur: Option<UnrolledList<T, P, N, G>>,
     _inner: PhantomData<T>,
 }
@@ -749,12 +829,18 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator for No
     }
 }
 
-pub(crate) struct NodeIterRef<'a, T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+pub(crate) struct NodeIterRef<
+    'a,
+    T: Clone + 'static,
+    P: PointerFamily,
+    const N: usize,
+    const G: usize,
+> {
     cur: Option<&'a UnrolledList<T, P, N, G>>,
     _inner: PhantomData<T>,
 }
 
-impl<'a, T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
+impl<'a, T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> Iterator
     for NodeIterRef<'a, T, P, N, G>
 {
     type Item = &'a UnrolledList<T, P, N, G>;
@@ -769,8 +855,8 @@ impl<'a, T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
     }
 }
 
-pub(crate) struct DrainingConsumingWrapper<
-    T: Clone,
+pub struct DrainingConsumingWrapper<
+    T: Clone + 'static,
     P: PointerFamily,
     const N: usize,
     const G: usize,
@@ -801,8 +887,7 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
     }
 }
 
-// TODO have this expose tryfold
-pub(crate) struct ConsumingWrapper<T: Clone, P: PointerFamily, const N: usize, const G: usize>(
+pub struct ConsumingWrapper<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize>(
     ConsumingIter<T, P, N, G>,
 );
 
@@ -831,7 +916,7 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> Iterator
     }
 }
 
-struct OwnedNodeIterator<T: Clone, P: PointerFamily, const N: usize, const G: usize> {
+struct OwnedNodeIterator<T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize> {
     list: UnrolledCell<T, P, N, G>,
 }
 
@@ -890,7 +975,7 @@ impl<T: Clone, P: PointerFamily, const N: usize, const G: usize> IntoIterator
 }
 
 // TODO have this also expose TryFold
-pub(crate) struct IterWrapper<'a, T: Clone, P: PointerFamily, const N: usize, const G: usize>(
+pub struct IterWrapper<'a, T: Clone + 'static, P: PointerFamily, const N: usize, const G: usize>(
     RefIter<'a, T, P, N, G>,
 );
 
@@ -1134,7 +1219,7 @@ mod tests {
 
     use crate::shared::RcPointer;
 
-    type RcList<T> = UnrolledList<T, RcPointer, 256>;
+    type RcList<T> = UnrolledList<T, RcPointer, 256, 1>;
 
     use super::*;
 
@@ -1182,7 +1267,7 @@ mod iterator_tests {
 
     const CAPACITY: usize = 256;
 
-    type RcList<T> = UnrolledList<T, RcPointer, 256>;
+    type RcList<T> = UnrolledList<T, RcPointer, 256, 1>;
 
     #[test]
     fn check_size() {
@@ -1686,7 +1771,7 @@ mod reference_counting_correctness {
 
     use super::*;
     use crate::shared::RcPointer;
-    type RcList<T> = UnrolledList<T, RcPointer, 256>;
+    type RcList<T> = UnrolledList<T, RcPointer, 256, 1>;
 
     #[derive(Clone)]
     enum Value {
diff --git a/src/unrolled/proptests.rs b/src/unrolled/proptests.rs
index 82f12e6..7d3a9ee 100644
--- a/src/unrolled/proptests.rs
+++ b/src/unrolled/proptests.rs
@@ -83,7 +83,8 @@ fn action_strategy() -> impl Strategy<Value = Action> {
         any::<usize>().prop_map(Action::PushBack),
         Just(Action::PopFront),
         // Getting values should work...
-        (0..100usize).prop_map(Action::Get)
+        (0..100usize).prop_map(Action::Get),
+        Just(Action::Clone),
     ]
 }
 
@@ -580,7 +581,7 @@ fn append_zero_then_popfront() {
     }
 }
 
-run_property_tests!(unrolled_linked_list, crate::unrolled::UnrolledList<T, RcPointer, 256>);
+run_property_tests!(unrolled_linked_list, crate::unrolled::UnrolledList<T, RcPointer, 256, 1>);
 
 run_property_tests!(vlist, crate::unrolled::UnrolledList<T, RcPointer, 4, 2>);