diff --git a/stack-graphs/src/arena.rs b/stack-graphs/src/arena.rs
index 6feaa3f7d..383716e46 100644
--- a/stack-graphs/src/arena.rs
+++ b/stack-graphs/src/arena.rs
@@ -30,6 +30,8 @@
 //! [`StackGraph`]: ../graph/struct.StackGraph.html
 
 use std::cell::Cell;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::hash::Hasher;
@@ -38,8 +40,10 @@ use std::mem::MaybeUninit;
 use std::num::NonZeroU32;
 use std::ops::Index;
 use std::ops::IndexMut;
+use std::ops::Range;
 
 use bitvec::vec::BitVec;
+use controlled_option::ControlledOption;
 use controlled_option::Niche;
 
 use crate::utils::cmp_option;
@@ -157,14 +161,66 @@ impl<T> PartialOrd for Handle<T> {
 unsafe impl<T> Send for Handle<T> {}
 unsafe impl<T> Sync for Handle<T> {}
 
+pub struct Handles<T> {
+    range: Range<usize>,
+    _phantom: PhantomData<T>,
+}
+
+impl<T> Iterator for Handles<T> {
+    type Item = Handle<T>;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.range
+            .next()
+            .map(|index| Handle::new(unsafe { NonZeroU32::new_unchecked(index as u32) }))
+    }
+}
+
+impl<T> From<Range<usize>> for Handles<T> {
+    fn from(range: Range<usize>) -> Self {
+        Handles {
+            range,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+pub trait Arena<T> {
+    /// Adds a new instance to this arena, returning a stable handle to it.
+    fn add(&mut self, item: T) -> Handle<T>;
+
+    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
+    fn get(&self, handle: Handle<T>) -> &T;
+
+    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
+    /// it.
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T;
+
+    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
+    /// retain a reference to the arena!)
+    fn iter_handles(&self) -> Handles<T>;
+
+    /// Returns a pointer to this arena's storage.
+    fn as_ptr(&self) -> *const T;
+
+    /// Returns the number of instances stored in this arena.
+    fn len(&self) -> usize;
+
+    /// Returns whether the values associated with the arena are equal, if this can be determined from the
+    /// handles alone. Otherwise, no value is returned.
+    fn try_equals(&self, lhs: Handle<T>, rhs: Handle<T>) -> Option<bool>;
+}
+
 /// Manages the life cycle of instances of type `T`.  You can allocate new instances of `T` from
 /// the arena.  All of the instances managed by this arena will be dropped as a single operation
 /// when the arena itself is dropped.
-pub struct Arena<T> {
+///
+/// Note that we do not deduplicate instances of `T` in any way.  If you add two instances that
+/// have the same content, you will get distinct handles for each one.
+pub struct VecArena<T> {
     items: Vec<MaybeUninit<T>>,
 }
 
-impl<T> Drop for Arena<T> {
+impl<T> Drop for VecArena<T> {
     fn drop(&mut self) {
         unsafe {
             let items = std::mem::transmute::<_, &mut [T]>(&mut self.items[1..]) as *mut [T];
@@ -173,53 +229,111 @@ impl<T> Drop for Arena<T> {
     }
 }
 
-impl<T> Arena<T> {
+impl<T> VecArena<T> {
     /// Creates a new arena.
-    pub fn new() -> Arena<T> {
-        Arena {
+    pub fn new() -> VecArena<T> {
+        VecArena {
             items: vec![MaybeUninit::uninit()],
         }
     }
+}
 
-    /// Adds a new instance to this arena, returning a stable handle to it.
-    ///
-    /// Note that we do not deduplicate instances of `T` in any way.  If you add two instances that
-    /// have the same content, you will get distinct handles for each one.
-    pub fn add(&mut self, item: T) -> Handle<T> {
+impl<T> Arena<T> for VecArena<T> {
+    fn add(&mut self, item: T) -> Handle<T> {
         let index = self.items.len() as u32;
         self.items.push(MaybeUninit::new(item));
         Handle::new(unsafe { NonZeroU32::new_unchecked(index) })
     }
 
-    /// Dereferences a handle to an instance owned by this arena, returning a reference to it.
-    pub fn get(&self, handle: Handle<T>) -> &T {
+    fn get(&self, handle: Handle<T>) -> &T {
         unsafe { std::mem::transmute(&self.items[handle.as_usize()]) }
     }
-    ///
-    /// Dereferences a handle to an instance owned by this arena, returning a mutable reference to
-    /// it.
-    pub fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
+
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
         unsafe { std::mem::transmute(&mut self.items[handle.as_usize()]) }
     }
 
-    /// Returns an iterator of all of the handles in this arena.  (Note that this iterator does not
-    /// retain a reference to the arena!)
-    pub fn iter_handles(&self) -> impl Iterator<Item = Handle<T>> {
-        (1..self.items.len())
-            .into_iter()
-            .map(|index| Handle::new(unsafe { NonZeroU32::new_unchecked(index as u32) }))
+    fn iter_handles(&self) -> Handles<T> {
+        (1..self.items.len()).into()
     }
 
-    /// Returns a pointer to this arena's storage.
-    pub(crate) fn as_ptr(&self) -> *const T {
+    fn as_ptr(&self) -> *const T {
         self.items.as_ptr() as *const T
     }
 
-    /// Returns the number of instances stored in this arena.
     #[inline(always)]
-    pub fn len(&self) -> usize {
+    fn len(&self) -> usize {
         self.items.len()
     }
+
+    #[inline]
+    fn try_equals(&self, _lhs: Handle<T>, _rhs: Handle<T>) -> Option<bool> {
+        None
+    }
+}
+
+/// An interning arena allocation.  Equal handles means equal elements.
+pub struct HashArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    arena: VecArena<T>,
+    index: HashMap<T, Handle<T>>,
+}
+
+impl<T> HashArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    /// Creates a new interning arena.
+    pub fn new() -> Self {
+        Self {
+            arena: VecArena::new(),
+            index: HashMap::new(),
+        }
+    }
+}
+
+impl<T> Arena<T> for HashArena<T>
+where
+    T: Clone + Eq + Hash,
+{
+    fn add(&mut self, item: T) -> Handle<T> {
+        match self.index.entry(item) {
+            Entry::Occupied(entry) => *entry.get(),
+            Entry::Vacant(entry) => {
+                let handle = self.arena.add(entry.key().clone());
+                entry.insert(handle);
+                handle
+            }
+        }
+    }
+
+    fn get(&self, handle: Handle<T>) -> &T {
+        self.arena.get(handle)
+    }
+
+    fn get_mut(&mut self, handle: Handle<T>) -> &mut T {
+        self.arena.get_mut(handle)
+    }
+
+    fn iter_handles(&self) -> Handles<T> {
+        self.arena.iter_handles()
+    }
+
+    fn as_ptr(&self) -> *const T {
+        self.arena.as_ptr()
+    }
+
+    #[inline(always)]
+    fn len(&self) -> usize {
+        self.arena.len()
+    }
+
+    #[inline]
+    fn try_equals(&self, lhs: Handle<T>, rhs: Handle<T>) -> Option<bool> {
+        Some(lhs == rhs)
+    }
 }
 
 //-------------------------------------------------------------------------------------------------
@@ -237,8 +351,9 @@ impl<T> Arena<T> {
 /// ```
 /// # use stack_graphs::arena::Arena;
 /// # use stack_graphs::arena::SupplementalArena;
+/// # use stack_graphs::arena::VecArena;
 /// // We need an Arena to create handles.
-/// let mut arena = Arena::<u32>::new();
+/// let mut arena = VecArena::<u32>::new();
 /// let handle = arena.add(1);
 ///
 /// let mut supplemental = SupplementalArena::<u32, String>::new();
@@ -282,8 +397,8 @@ impl<H, T> SupplementalArena<H, T> {
 
     /// Creates a new, empty supplemental arena, preallocating enough space to store supplemental
     /// data for all of the instances that have already been allocated in a (regular) arena.
-    pub fn with_capacity(arena: &Arena<H>) -> SupplementalArena<H, T> {
-        let mut items = Vec::with_capacity(arena.items.len());
+    pub fn with_capacity(arena: impl Arena<H>) -> SupplementalArena<H, T> {
+        let mut items = Vec::with_capacity(arena.len());
         items[0] = MaybeUninit::uninit();
         SupplementalArena {
             items,
@@ -446,35 +561,33 @@ impl<T> Default for HandleSet<T> {
 /// linked list implementation _should_ be cache-friendly, since the individual cells are allocated
 /// out of an arena.
 #[repr(C)]
-#[derive(Niche)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct List<T> {
     // The value of this handle will be EMPTY_LIST_HANDLE if the list is empty.  For an
     // Option<List<T>>, the value will be zero (via the Option<NonZero> optimization) if the list
     // is None.
-    #[niche]
     cells: Handle<ListCell<T>>,
 }
 
 #[doc(hidden)]
 #[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct ListCell<T> {
     head: T,
     // The value of this handle will be EMPTY_LIST_HANDLE if this is the last element of the list.
     tail: Handle<ListCell<T>>,
 }
 
-const EMPTY_LIST_HANDLE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(u32::MAX) };
+pub trait ListArena<T>: Arena<ListCell<T>> {}
 
-// An arena that's used to manage `List<T>` instances.
-//
-// (Note that the arena doesn't store `List<T>` itself; it stores the `ListCell<T>`s that the lists
-// are made of.)
-pub type ListArena<T> = Arena<ListCell<T>>;
+impl<T, A> ListArena<T> for A where A: Arena<ListCell<T>> {}
+
+const EMPTY_LIST_HANDLE: NonZeroU32 = unsafe { NonZeroU32::new_unchecked(u32::MAX) };
 
 impl<T> List<T> {
-    /// Creates a new `ListArena` that will manage lists of this type.
-    pub fn new_arena() -> ListArena<T> {
-        ListArena::new()
+    /// Creates a new arena that will manage lists of this type.
+    pub fn new_arena() -> impl ListArena<T> {
+        VecArena::new()
     }
 
     /// Returns whether this list is empty.
@@ -500,7 +613,7 @@ impl<T> List<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut ListArena<T>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl ListArena<T>, head: T) {
         self.cells = arena.add(ListCell {
             head,
             tail: self.cells,
@@ -509,7 +622,7 @@ impl<T> List<T> {
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a ListArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl ListArena<T>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -517,15 +630,22 @@ impl<T> List<T> {
         self.cells = cell.tail;
         Some(&cell.head)
     }
+}
 
+impl<'a, T: 'a> List<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter<'a>(mut self, arena: &'a ListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(mut self, arena: &'a impl ListArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
 }
 
 impl<T> List<T> {
-    pub fn equals_with<F>(mut self, arena: &ListArena<T>, mut other: List<T>, mut eq: F) -> bool
+    pub fn equals_with<F>(
+        mut self,
+        arena: &impl ListArena<T>,
+        mut other: List<T>,
+        mut eq: F,
+    ) -> bool
     where
         F: FnMut(&T, &T) -> bool,
     {
@@ -541,7 +661,7 @@ impl<T> List<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &ListArena<T>,
+        arena: &impl ListArena<T>,
         mut other: List<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -565,7 +685,10 @@ impl<T> List<T>
 where
     T: Eq,
 {
-    pub fn equals(self, arena: &ListArena<T>, other: List<T>) -> bool {
+    pub fn equals(self, arena: &impl ListArena<T>, other: List<T>) -> bool {
+        if let Some(equals) = arena.try_equals(self.cells, other.cells) {
+            return equals;
+        }
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -574,7 +697,7 @@ impl<T> List<T>
 where
     T: Ord,
 {
-    pub fn cmp(self, arena: &ListArena<T>, other: List<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &impl ListArena<T>, other: List<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
@@ -591,6 +714,53 @@ impl<T> Clone for List<T> {
 
 impl<T> Copy for List<T> {}
 
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheList<T> {
+    cells: ControlledOption<Handle<ListCell<T>>>,
+}
+
+impl<T> Niche for List<T> {
+    type Output = NicheList<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheList {
+            cells: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.cells.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheList {
+            cells: ControlledOption::from(value.cells),
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        List {
+            cells: value
+                .cells
+                .into_option()
+                .expect("Niche::from_some called on none value of ControlledOption<List<_>>"),
+        }
+    }
+}
+
+impl<T> Clone for NicheList<T> {
+    fn clone(&self) -> Self {
+        Self { cells: self.cells }
+    }
+}
+
+impl<T> Copy for NicheList<T> {}
+
 //-------------------------------------------------------------------------------------------------
 // Reversible arena-allocated list
 
@@ -602,30 +772,41 @@ impl<T> Copy for List<T> {}
 ///
 /// [`List`]: struct.List.html
 #[repr(C)]
-#[derive(Niche)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct ReversibleList<T> {
-    #[niche]
     cells: Handle<ReversibleListCell<T>>,
 }
 
 #[repr(C)]
 #[doc(hidden)]
+#[derive(Clone, Eq)]
 pub struct ReversibleListCell<T> {
     head: T,
     tail: Handle<ReversibleListCell<T>>,
     reversed: Cell<Option<Handle<ReversibleListCell<T>>>>,
 }
 
-// An arena that's used to manage `ReversibleList<T>` instances.
-//
-// (Note that the arena doesn't store `ReversibleList<T>` itself; it stores the
-// `ReversibleListCell<T>`s that the lists are made of.)
-pub type ReversibleListArena<T> = Arena<ReversibleListCell<T>>;
+impl<T: Hash> Hash for ReversibleListCell<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.head.hash(state);
+        self.tail.hash(state);
+    }
+}
+
+impl<T: Eq> PartialEq for ReversibleListCell<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.head == other.head && self.tail == other.tail
+    }
+}
+
+pub trait ReversibleListArena<T>: Arena<ReversibleListCell<T>> {}
+
+impl<T, A> ReversibleListArena<T> for A where A: Arena<ReversibleListCell<T>> {}
 
 impl<T> ReversibleList<T> {
-    /// Creates a new `ReversibleListArena` that will manage lists of this type.
-    pub fn new_arena() -> ReversibleListArena<T> {
-        ReversibleListArena::new()
+    /// Creates a new arena that will manage lists of this type.
+    pub fn new_arena() -> impl ReversibleListArena<T> {
+        VecArena::new()
     }
 
     /// Returns whether this list is empty.
@@ -642,7 +823,7 @@ impl<T> ReversibleList<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this list.
-    pub fn have_reversal(&self, arena: &ReversibleListArena<T>) -> bool {
+    pub fn have_reversal(&self, arena: &impl ReversibleListArena<T>) -> bool {
         if self.is_empty() {
             // The empty list is already reversed.
             return true;
@@ -651,13 +832,13 @@ impl<T> ReversibleList<T> {
     }
 
     /// Pushes a new element onto the front of this list.
-    pub fn push_front(&mut self, arena: &mut ReversibleListArena<T>, head: T) {
+    pub fn push_front(&mut self, arena: &mut impl ReversibleListArena<T>, head: T) {
         self.cells = arena.add(ReversibleListCell::new(head, self.cells, None));
     }
 
     /// Removes and returns the element at the front of this list.  If the list is empty, returns
     /// `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a ReversibleListArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a impl ReversibleListArena<T>) -> Option<&'a T> {
         if self.is_empty() {
             return None;
         }
@@ -665,11 +846,13 @@ impl<T> ReversibleList<T> {
         self.cells = cell.tail;
         Some(&cell.head)
     }
+}
 
+impl<'a, T: 'a> ReversibleList<T> {
     /// Returns an iterator over the elements of this list.
-    pub fn iter<'a>(
+    pub fn iter(
         mut self,
-        arena: &'a ReversibleListArena<T>,
+        arena: &'a impl ReversibleListArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         std::iter::from_fn(move || self.pop_front(arena))
     }
@@ -682,7 +865,7 @@ where
     /// Reverses the list.  Since we're already caching everything in an arena, we make sure to
     /// only calculate the reversal once, returning it as-is if you call this function multiple
     /// times.
-    pub fn reverse(&mut self, arena: &mut ReversibleListArena<T>) {
+    pub fn reverse(&mut self, arena: &mut impl ReversibleListArena<T>) {
         if self.is_empty() {
             return;
         }
@@ -693,7 +876,7 @@ where
     /// Ensures that the reversal of this list is available.  It can be useful to precalculate this
     /// when you have mutable access to the arena, so that you can then reverse and un-reverse the
     /// list later when you only have shared access to it.
-    pub fn ensure_reversal_available(&self, arena: &mut ReversibleListArena<T>) {
+    pub fn ensure_reversal_available(&self, arena: &mut impl ReversibleListArena<T>) {
         // First check to see if the list has already been reversed.
         if self.is_empty() {
             // The empty list is already reversed.
@@ -712,7 +895,7 @@ where
 impl<T> ReversibleList<T> {
     /// Reverses the list, assuming that the reversal has already been computed.  If it hasn't we
     /// return an error.
-    pub fn reverse_reused(&mut self, arena: &ReversibleListArena<T>) -> Result<(), ()> {
+    pub fn reverse_reused(&mut self, arena: &impl ReversibleListArena<T>) -> Result<(), ()> {
         if self.is_empty() {
             // The empty list is already reversed.
             return Ok(());
@@ -750,7 +933,7 @@ where
 {
     fn reverse(
         forwards: Handle<ReversibleListCell<T>>,
-        arena: &mut ReversibleListArena<T>,
+        arena: &mut impl ReversibleListArena<T>,
     ) -> Handle<ReversibleListCell<T>> {
         let mut reversed = ReversibleListCell::empty_handle();
         let mut current = forwards;
@@ -777,7 +960,7 @@ where
 impl<T> ReversibleList<T> {
     pub fn equals_with<F>(
         mut self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl ReversibleListArena<T>,
         mut other: ReversibleList<T>,
         mut eq: F,
     ) -> bool
@@ -796,7 +979,7 @@ impl<T> ReversibleList<T> {
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl ReversibleListArena<T>,
         mut other: ReversibleList<T>,
         mut cmp: F,
     ) -> std::cmp::Ordering
@@ -820,7 +1003,10 @@ impl<T> ReversibleList<T>
 where
     T: Eq,
 {
-    pub fn equals(self, arena: &ReversibleListArena<T>, other: ReversibleList<T>) -> bool {
+    pub fn equals(self, arena: &impl ReversibleListArena<T>, other: ReversibleList<T>) -> bool {
+        if let Some(equals) = arena.try_equals(self.cells, other.cells) {
+            return equals;
+        }
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -831,7 +1017,7 @@ where
 {
     pub fn cmp(
         self,
-        arena: &ReversibleListArena<T>,
+        arena: &impl ReversibleListArena<T>,
         other: ReversibleList<T>,
     ) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
@@ -850,9 +1036,61 @@ impl<T> Clone for ReversibleList<T> {
 
 impl<T> Copy for ReversibleList<T> {}
 
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheReversibleList<T> {
+    cells: ControlledOption<Handle<ReversibleListCell<T>>>,
+}
+
+impl<T> Niche for ReversibleList<T> {
+    type Output = NicheReversibleList<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheReversibleList {
+            cells: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.cells.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheReversibleList {
+            cells: ControlledOption::from(value.cells),
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        ReversibleList {
+            cells: value.cells.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<ReversibleList<_>>",
+            ),
+        }
+    }
+}
+
+impl<T> Clone for NicheReversibleList<T> {
+    fn clone(&self) -> Self {
+        Self { cells: self.cells }
+    }
+}
+
+impl<T> Copy for NicheReversibleList<T> {}
+
 //-------------------------------------------------------------------------------------------------
 // Arena-allocated deque
 
+pub type DequeCell<T> = ReversibleListCell<T>;
+
+pub trait DequeArena<T>: Arena<DequeCell<T>> {}
+
+impl<T, A> DequeArena<T> for A where A: Arena<DequeCell<T>> {}
+
 /// An arena-allocated deque.
 ///
 /// Under the covers, this is implemented as a [`List`][].  Because these lists are singly-linked,
@@ -869,6 +1107,7 @@ impl<T> Copy for ReversibleList<T> {}
 ///
 /// [`List`]: struct.List.html
 #[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
 pub struct Deque<T> {
     list: ReversibleList<T>,
     direction: DequeDirection,
@@ -891,13 +1130,10 @@ impl std::ops::Not for DequeDirection {
     }
 }
 
-// An arena that's used to manage `Deque<T>` instances.
-pub type DequeArena<T> = ReversibleListArena<T>;
-
 impl<T> Deque<T> {
-    /// Creates a new `DequeArena` that will manage deques of this type.
-    pub fn new_arena() -> DequeArena<T> {
-        ReversibleList::new_arena()
+    /// Creates a new arena that will manage deques of this type.
+    pub fn new_arena() -> impl DequeArena<T> {
+        VecArena::new()
     }
 
     /// Returns whether this deque is empty.
@@ -919,7 +1155,7 @@ impl<T> Deque<T> {
     }
 
     /// Returns whether we have already calculated the reversal of this deque.
-    pub fn have_reversal(&self, arena: &DequeArena<T>) -> bool {
+    pub fn have_reversal(&self, arena: &impl DequeArena<T>) -> bool {
         self.list.have_reversal(arena)
     }
 
@@ -930,12 +1166,17 @@ impl<T> Deque<T> {
     fn is_forwards(&self) -> bool {
         matches!(self.direction, DequeDirection::Forwards)
     }
+}
 
+impl<'a, T: 'a> Deque<T> {
     /// Returns an iterator over the contents of this deque, with no guarantee about the ordering of
     /// the elements.  (By not caring about the ordering of the elements, you can call this method
     /// regardless of which direction the deque's elements are currently stored.  And that, in
     /// turn, means that we only need shared access to the arena, and not mutable access to it.)
-    pub fn iter_unordered<'a>(&self, arena: &'a DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter_unordered(
+        &self,
+        arena: &'a impl DequeArena<T>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
         self.list.iter(arena)
     }
 }
@@ -945,7 +1186,7 @@ where
     T: Clone,
 {
     /// Ensures that this deque has computed its backwards-facing list of elements.
-    pub fn ensure_backwards(&mut self, arena: &mut DequeArena<T>) {
+    pub fn ensure_backwards(&mut self, arena: &mut impl DequeArena<T>) {
         if self.is_backwards() {
             return;
         }
@@ -954,7 +1195,7 @@ where
     }
 
     /// Ensures that this deque has computed its forwards-facing list of elements.
-    pub fn ensure_forwards(&mut self, arena: &mut DequeArena<T>) {
+    pub fn ensure_forwards(&mut self, arena: &mut impl DequeArena<T>) {
         if self.is_forwards() {
             return;
         }
@@ -963,38 +1204,60 @@ where
     }
 
     /// Ensures that this deque has computed both directions of elements.
-    pub fn ensure_both_directions(&self, arena: &mut DequeArena<T>) {
+    pub fn ensure_both_directions(&self, arena: &mut impl Arena<DequeCell<T>>) {
         self.list.ensure_reversal_available(arena);
     }
 
     /// Pushes a new element onto the front of this deque.
-    pub fn push_front(&mut self, arena: &mut DequeArena<T>, element: T) {
+    pub fn push_front(&mut self, arena: &mut impl DequeArena<T>, element: T) {
         self.ensure_forwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Pushes a new element onto the back of this deque.
-    pub fn push_back(&mut self, arena: &mut DequeArena<T>, element: T) {
+    pub fn push_back(&mut self, arena: &mut impl DequeArena<T>, element: T) {
         self.ensure_backwards(arena);
         self.list.push_front(arena, element);
     }
 
     /// Removes and returns the element from the front of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_front<'a>(&mut self, arena: &'a mut DequeArena<T>) -> Option<&'a T> {
+    pub fn pop_front<'a>(&mut self, arena: &'a mut impl DequeArena<T>) -> Option<&'a T> {
         self.ensure_forwards(arena);
         self.list.pop_front(arena)
     }
 
     /// Removes and returns the element from the back of this deque.  If the deque is empty,
     /// returns `None`.
-    pub fn pop_back<'a>(&mut self, arena: &'a mut DequeArena<T>) -> Option<&'a T> {
+    pub fn pop_back<'a>(&mut self, arena: &'a mut impl DequeArena<T>) -> Option<&'a T> {
         self.ensure_backwards(arena);
         self.list.pop_front(arena)
     }
 
+    /// Ensures that both deques are stored in the same direction.  It doesn't matter _which_
+    /// direction, as long as they're the same, so do the minimum amount of work to bring this
+    /// about.  (In particular, if we've already calculated the reversal of one of the deques,
+    /// reverse that one.)
+    fn ensure_same_direction(&mut self, arena: &mut impl DequeArena<T>, other: &mut Deque<T>) {
+        if self.direction == other.direction {
+            return;
+        }
+        if self.list.have_reversal(arena) {
+            self.list.reverse(arena);
+            self.direction = !self.direction;
+        } else {
+            other.list.reverse(arena);
+            other.direction = !other.direction;
+        }
+    }
+}
+
+impl<'a, T: 'a> Deque<T>
+where
+    T: Clone,
+{
     /// Returns an iterator over the contents of this deque in a forwards direction.
-    pub fn iter<'a>(&self, arena: &'a mut DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter(&self, arena: &'a mut impl DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse(arena);
@@ -1003,9 +1266,9 @@ where
     }
 
     /// Returns an iterator over the contents of this deque in a backwards direction.
-    pub fn iter_reversed<'a>(
+    pub fn iter_reversed(
         &self,
-        arena: &'a mut DequeArena<T>,
+        arena: &'a mut impl DequeArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
@@ -1013,30 +1276,18 @@ where
         }
         list.iter(arena)
     }
-
-    /// Ensures that both deques are stored in the same direction.  It doesn't matter _which_
-    /// direction, as long as they're the same, so do the minimum amount of work to bring this
-    /// about.  (In particular, if we've already calculated the reversal of one of the deques,
-    /// reverse that one.)
-    fn ensure_same_direction(&mut self, arena: &mut DequeArena<T>, other: &mut Deque<T>) {
-        if self.direction == other.direction {
-            return;
-        }
-        if self.list.have_reversal(arena) {
-            self.list.reverse(arena);
-            self.direction = !self.direction;
-        } else {
-            other.list.reverse(arena);
-            other.direction = !other.direction;
-        }
-    }
 }
 
 impl<T> Deque<T>
 where
     T: Clone,
 {
-    pub fn equals_with<F>(mut self, arena: &mut DequeArena<T>, mut other: Deque<T>, eq: F) -> bool
+    pub fn equals_with<F>(
+        mut self,
+        arena: &mut impl DequeArena<T>,
+        mut other: Deque<T>,
+        eq: F,
+    ) -> bool
     where
         F: FnMut(&T, &T) -> bool,
     {
@@ -1046,7 +1297,7 @@ where
 
     pub fn cmp_with<F>(
         mut self,
-        arena: &mut DequeArena<T>,
+        arena: &mut impl DequeArena<T>,
         mut other: Deque<T>,
         cmp: F,
     ) -> std::cmp::Ordering
@@ -1065,7 +1316,7 @@ impl<T> Deque<T>
 where
     T: Clone + Eq,
 {
-    pub fn equals(self, arena: &mut DequeArena<T>, other: Deque<T>) -> bool {
+    pub fn equals(self, arena: &mut impl DequeArena<T>, other: Deque<T>) -> bool {
         self.equals_with(arena, other, |a, b| *a == *b)
     }
 }
@@ -1074,18 +1325,18 @@ impl<T> Deque<T>
 where
     T: Clone + Ord,
 {
-    pub fn cmp(self, arena: &mut DequeArena<T>, other: Deque<T>) -> std::cmp::Ordering {
+    pub fn cmp(self, arena: &mut impl DequeArena<T>, other: Deque<T>) -> std::cmp::Ordering {
         self.cmp_with(arena, other, |a, b| a.cmp(b))
     }
 }
 
-impl<T> Deque<T> {
+impl<'a, T: 'a> Deque<T> {
     /// Returns an iterator over the contents of this deque in a forwards direction, assuming that
     /// we have already computed its forwards-facing list of elements via [`ensure_forwards`][].
     /// Panics if we haven't already computed it.
     ///
     /// [`ensure_forwards`]: #method.ensure_forwards
-    pub fn iter_reused<'a>(&self, arena: &'a DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
+    pub fn iter_reused(&self, arena: &'a impl DequeArena<T>) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_backwards() {
             list.reverse_reused(arena)
@@ -1099,9 +1350,9 @@ impl<T> Deque<T> {
     /// Panics if we haven't already computed it.
     ///
     /// [`ensure_backwards`]: #method.ensure_backwards
-    pub fn iter_reversed_reused<'a>(
+    pub fn iter_reversed_reused(
         &self,
-        arena: &'a DequeArena<T>,
+        arena: &'a impl DequeArena<T>,
     ) -> impl Iterator<Item = &'a T> + 'a {
         let mut list = self.list;
         if self.is_forwards() {
@@ -1126,3 +1377,57 @@ impl<T> Clone for Deque<T> {
 }
 
 impl<T> Copy for Deque<T> {}
+
+#[repr(C)]
+#[derive(Eq, Hash, PartialEq)]
+pub struct NicheDeque<T> {
+    list: ControlledOption<ReversibleList<T>>,
+    direction: DequeDirection,
+}
+
+impl<T> Niche for Deque<T> {
+    type Output = NicheDeque<T>;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NicheDeque {
+            list: ControlledOption::none(),
+            direction: DequeDirection::Forwards,
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.list.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NicheDeque {
+            list: ControlledOption::from(value.list),
+            direction: value.direction,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Deque {
+            list: value
+                .list
+                .into_option()
+                .expect("Niche::from_some called on none value of ControlledOption<Deque<_>>"),
+            direction: value.direction,
+        }
+    }
+}
+
+impl<T> Clone for NicheDeque<T> {
+    fn clone(&self) -> Self {
+        Self {
+            list: self.list,
+            direction: self.direction,
+        }
+    }
+}
+
+impl<T> Copy for NicheDeque<T> {}
diff --git a/stack-graphs/src/c.rs b/stack-graphs/src/c.rs
index 998d4cf2e..c0dd6177a 100644
--- a/stack-graphs/src/c.rs
+++ b/stack-graphs/src/c.rs
@@ -14,6 +14,7 @@ use std::sync::atomic::AtomicUsize;
 
 use libc::c_char;
 
+use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::graph::File;
 use crate::graph::InternedString;
diff --git a/stack-graphs/src/cycles.rs b/stack-graphs/src/cycles.rs
index eb4577c6a..43e1dbf76 100644
--- a/stack-graphs/src/cycles.rs
+++ b/stack-graphs/src/cycles.rs
@@ -35,7 +35,8 @@ use std::collections::HashMap;
 
 use crate::arena::Handle;
 use crate::arena::List;
-use crate::arena::ListArena;
+use crate::arena::ListCell;
+use crate::arena::VecArena;
 use crate::graph::Edge;
 use crate::graph::Node;
 use crate::graph::StackGraph;
@@ -148,7 +149,7 @@ pub struct AppendingCycleDetector<A> {
     appendages: List<A>,
 }
 
-pub type Appendables<A> = ListArena<A>;
+pub type Appendables<A> = VecArena<ListCell<A>>;
 
 impl<A: Appendable + Clone> AppendingCycleDetector<A> {
     pub fn new() -> Self {
diff --git a/stack-graphs/src/graph.rs b/stack-graphs/src/graph.rs
index 6eb0f8c34..4e9e57e1e 100644
--- a/stack-graphs/src/graph.rs
+++ b/stack-graphs/src/graph.rs
@@ -63,6 +63,7 @@ use smallvec::SmallVec;
 use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::arena::SupplementalArena;
+use crate::arena::VecArena;
 
 //-------------------------------------------------------------------------------------------------
 // String content
@@ -1401,13 +1402,13 @@ impl StackGraph {
 /// Contains all of the nodes and edges that make up a stack graph.
 pub struct StackGraph {
     interned_strings: InternedStringArena,
-    pub(crate) symbols: Arena<Symbol>,
+    pub(crate) symbols: VecArena<Symbol>,
     symbol_handles: FxHashMap<&'static str, Handle<Symbol>>,
-    pub(crate) strings: Arena<InternedString>,
+    pub(crate) strings: VecArena<InternedString>,
     string_handles: FxHashMap<&'static str, Handle<InternedString>>,
-    pub(crate) files: Arena<File>,
+    pub(crate) files: VecArena<File>,
     file_handles: FxHashMap<&'static str, Handle<File>>,
-    pub(crate) nodes: Arena<Node>,
+    pub(crate) nodes: VecArena<Node>,
     pub(crate) source_info: SupplementalArena<Node, SourceInfo>,
     node_id_handles: NodeIDHandles,
     outgoing_edges: SupplementalArena<Node, SmallVec<[OutgoingEdge; 8]>>,
@@ -1573,17 +1574,17 @@ impl StackGraph {
 
 impl Default for StackGraph {
     fn default() -> StackGraph {
-        let mut nodes = Arena::new();
+        let mut nodes = VecArena::new();
         nodes.add(RootNode::new().into());
         nodes.add(JumpToNode::new().into());
 
         StackGraph {
             interned_strings: InternedStringArena::new(),
-            symbols: Arena::new(),
+            symbols: VecArena::new(),
             symbol_handles: FxHashMap::default(),
-            strings: Arena::new(),
+            strings: VecArena::new(),
             string_handles: FxHashMap::default(),
-            files: Arena::new(),
+            files: VecArena::new(),
             file_handles: FxHashMap::default(),
             nodes,
             source_info: SupplementalArena::new(),
diff --git a/stack-graphs/src/partial.rs b/stack-graphs/src/partial.rs
index a012c9bc0..b6ccb0356 100644
--- a/stack-graphs/src/partial.rs
+++ b/stack-graphs/src/partial.rs
@@ -36,6 +36,7 @@
 use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::fmt::Display;
+use std::hash::Hash;
 use std::num::NonZeroU32;
 
 use controlled_option::ControlledOption;
@@ -44,10 +45,10 @@ use enumset::EnumSetType;
 use smallvec::SmallVec;
 
 use crate::arena::Deque;
-use crate::arena::DequeArena;
+use crate::arena::DequeCell;
 use crate::arena::Handle;
+use crate::arena::HashArena;
 use crate::arena::ReversibleList;
-use crate::arena::ReversibleListArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::graph::Edge;
@@ -158,8 +159,8 @@ where
 
 /// Represents an unknown list of scoped symbols.
 #[repr(transparent)]
-#[derive(Clone, Copy, Debug, Eq, Hash, Niche, Ord, PartialEq, PartialOrd)]
-pub struct SymbolStackVariable(#[niche] NonZeroU32);
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SymbolStackVariable(NonZeroU32);
 
 impl SymbolStackVariable {
     pub fn new(variable: u32) -> Option<SymbolStackVariable> {
@@ -218,13 +219,37 @@ impl TryFrom<u32> for SymbolStackVariable {
     }
 }
 
+impl Niche for SymbolStackVariable {
+    type Output = u32;
+
+    #[inline]
+    fn none() -> Self::Output {
+        0
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        *value == 0
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        value.as_u32()
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Self(unsafe { NonZeroU32::new_unchecked(value) })
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Scope stack variables
 
 /// Represents an unknown list of exported scopes.
 #[repr(transparent)]
-#[derive(Clone, Copy, Debug, Eq, Hash, Niche, Ord, PartialEq, PartialOrd)]
-pub struct ScopeStackVariable(#[niche] NonZeroU32);
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ScopeStackVariable(NonZeroU32);
 
 impl ScopeStackVariable {
     pub fn new(variable: u32) -> Option<ScopeStackVariable> {
@@ -281,6 +306,30 @@ impl Into<u32> for ScopeStackVariable {
     }
 }
 
+impl Niche for ScopeStackVariable {
+    type Output = u32;
+
+    #[inline]
+    fn none() -> Self::Output {
+        0
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        *value == 0
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        value.as_u32()
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        Self(unsafe { NonZeroU32::new_unchecked(value) })
+    }
+}
+
 impl TryFrom<u32> for ScopeStackVariable {
     type Error = ();
     fn try_from(value: u32) -> Result<ScopeStackVariable, ()> {
@@ -294,7 +343,7 @@ impl TryFrom<u32> for ScopeStackVariable {
 
 /// A symbol with an unknown, but possibly empty, list of exported scopes attached to it.
 #[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialScopedSymbol {
     pub symbol: Handle<Symbol>,
     // Note that not having an attached scope list is _different_ than having an empty attached
@@ -442,9 +491,8 @@ impl DisplayWithPartialPaths for PartialScopedSymbol {
 /// A pattern that might match against a symbol stack.  Consists of a (possibly empty) list of
 /// partial scoped symbols, along with an optional symbol stack variable.
 #[repr(C)]
-#[derive(Clone, Copy, Niche)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialSymbolStack {
-    #[niche]
     symbols: ReversibleList<PartialScopedSymbol>,
     length: u32,
     variable: ControlledOption<SymbolStackVariable>,
@@ -743,24 +791,13 @@ impl PartialSymbolStack {
         unreachable!();
     }
 
-    pub fn equals(mut self, partials: &mut PartialPaths, mut other: PartialSymbolStack) -> bool {
-        while let Some(self_symbol) = self.pop_front(partials) {
-            if let Some(other_symbol) = other.pop_front(partials) {
-                if !self_symbol.equals(partials, &other_symbol) {
-                    return false;
-                }
-            } else {
-                return false;
-            }
-        }
-        if !other.symbols.is_empty() {
-            return false;
-        }
-        equals_option(
-            self.variable.into_option(),
-            other.variable.into_option(),
-            |a, b| a == b,
-        )
+    pub fn equals(self, _partials: &mut PartialPaths, other: PartialSymbolStack) -> bool {
+        self.symbols == other.symbols
+            && equals_option(
+                self.variable.into_option(),
+                other.variable.into_option(),
+                |a, b| a == b,
+            )
     }
 
     pub fn cmp(
@@ -849,15 +886,60 @@ impl DisplayWithPartialPaths for PartialSymbolStack {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialSymbolStack {
+    symbols: ControlledOption<ReversibleList<PartialScopedSymbol>>,
+    length: u32,
+    variable: ControlledOption<SymbolStackVariable>,
+}
+
+impl Niche for PartialSymbolStack {
+    type Output = NichePartialSymbolStack;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialSymbolStack {
+            symbols: ControlledOption::none(),
+            length: 0,
+            variable: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.symbols.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialSymbolStack {
+            symbols: ControlledOption::from(value.symbols),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialSymbolStack {
+            symbols: value.symbols.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialSymbolStack>",
+            ),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial scope stacks
 
 /// A pattern that might match against a scope stack.  Consists of a (possibly empty) list of
 /// exported scopes, along with an optional scope stack variable.
 #[repr(C)]
-#[derive(Clone, Copy, Niche)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
 pub struct PartialScopeStack {
-    #[niche]
     scopes: ReversibleList<Handle<Node>>,
     length: u32,
     variable: ControlledOption<ScopeStackVariable>,
@@ -1111,11 +1193,8 @@ impl PartialScopeStack {
         self.variable.into_option()
     }
 
-    pub fn equals(self, partials: &mut PartialPaths, other: PartialScopeStack) -> bool {
-        self.scopes
-            .equals_with(&mut partials.partial_scope_stacks, other.scopes, |a, b| {
-                *a == *b
-            })
+    pub fn equals(self, _partials: &mut PartialPaths, other: PartialScopeStack) -> bool {
+        self.scopes == other.scopes
             && equals_option(
                 self.variable.into_option(),
                 other.variable.into_option(),
@@ -1194,6 +1273,52 @@ impl DisplayWithPartialPaths for PartialScopeStack {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialScopeStack {
+    scopes: ControlledOption<ReversibleList<Handle<Node>>>,
+    length: u32,
+    variable: ControlledOption<ScopeStackVariable>,
+}
+
+impl Niche for PartialScopeStack {
+    type Output = NichePartialScopeStack;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialScopeStack {
+            scopes: ControlledOption::none(),
+            length: 0,
+            variable: ControlledOption::none(),
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.scopes.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialScopeStack {
+            scopes: ControlledOption::from(value.scopes),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialScopeStack {
+            scopes: value.scopes.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialScopeStack>",
+            ),
+            length: value.length,
+            variable: value.variable,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial symbol bindings
 
@@ -1597,6 +1722,48 @@ impl DisplayWithPartialPaths for PartialPathEdgeList {
     }
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Eq, Hash, PartialEq)]
+pub struct NichePartialPathEdgeList {
+    edges: ControlledOption<Deque<PartialPathEdge>>,
+    length: u32,
+}
+
+impl Niche for PartialPathEdgeList {
+    type Output = NichePartialPathEdgeList;
+
+    #[inline]
+    fn none() -> Self::Output {
+        NichePartialPathEdgeList {
+            edges: ControlledOption::none(),
+            length: 0,
+        }
+    }
+
+    #[inline]
+    fn is_none(value: &Self::Output) -> bool {
+        value.edges.is_none()
+    }
+
+    #[inline]
+    fn into_some(value: Self) -> Self::Output {
+        NichePartialPathEdgeList {
+            edges: ControlledOption::from(value.edges),
+            length: value.length,
+        }
+    }
+
+    #[inline]
+    fn from_some(value: Self::Output) -> Self {
+        PartialPathEdgeList {
+            edges: value.edges.into_option().expect(
+                "Niche::from_some called on none value of ControlledOption<PartialPathEdgeList>",
+            ),
+            length: value.length,
+        }
+    }
+}
+
 //-------------------------------------------------------------------------------------------------
 // Partial paths
 
@@ -1671,21 +1838,13 @@ impl PartialPath {
         self.edges.shadows(partials, other.edges)
     }
 
-    pub fn equals(&self, partials: &mut PartialPaths, other: &PartialPath) -> bool {
+    pub fn equals(&self, _partials: &mut PartialPaths, other: &PartialPath) -> bool {
         self.start_node == other.start_node
             && self.end_node == other.end_node
-            && self
-                .symbol_stack_precondition
-                .equals(partials, other.symbol_stack_precondition)
-            && self
-                .symbol_stack_postcondition
-                .equals(partials, other.symbol_stack_postcondition)
-            && self
-                .scope_stack_precondition
-                .equals(partials, other.scope_stack_precondition)
-            && self
-                .scope_stack_postcondition
-                .equals(partials, other.scope_stack_postcondition)
+            && self.symbol_stack_precondition == other.symbol_stack_precondition
+            && self.symbol_stack_postcondition == other.symbol_stack_postcondition
+            && self.scope_stack_precondition == other.scope_stack_precondition
+            && self.scope_stack_postcondition == other.scope_stack_postcondition
     }
 
     pub fn cmp(
@@ -2672,17 +2831,17 @@ struct Join {
 /// Manages the state of a collection of partial paths built up as part of the partial-path-finding
 /// algorithm or path-stitching algorithm.
 pub struct PartialPaths {
-    pub(crate) partial_symbol_stacks: ReversibleListArena<PartialScopedSymbol>,
-    pub(crate) partial_scope_stacks: ReversibleListArena<Handle<Node>>,
-    pub(crate) partial_path_edges: DequeArena<PartialPathEdge>,
+    pub(crate) partial_symbol_stacks: HashArena<DequeCell<PartialScopedSymbol>>,
+    pub(crate) partial_scope_stacks: HashArena<DequeCell<Handle<Node>>>,
+    pub(crate) partial_path_edges: HashArena<DequeCell<PartialPathEdge>>,
 }
 
 impl PartialPaths {
     pub fn new() -> PartialPaths {
         PartialPaths {
-            partial_symbol_stacks: ReversibleList::new_arena(),
-            partial_scope_stacks: ReversibleList::new_arena(),
-            partial_path_edges: Deque::new_arena(),
+            partial_symbol_stacks: HashArena::new(),
+            partial_scope_stacks: HashArena::new(),
+            partial_path_edges: HashArena::new(),
         }
     }
 }
diff --git a/stack-graphs/src/stitching.rs b/stack-graphs/src/stitching.rs
index 5de928324..7987f7abc 100644
--- a/stack-graphs/src/stitching.rs
+++ b/stack-graphs/src/stitching.rs
@@ -35,7 +35,6 @@
 //! [`Database`]: struct.Database.html
 //! [`PathStitcher`]: struct.PathStitcher.html
 
-use std::collections::HashMap;
 use std::collections::VecDeque;
 #[cfg(feature = "copious-debugging")]
 use std::fmt::Display;
@@ -44,10 +43,11 @@ use std::ops::Index;
 use crate::arena::Arena;
 use crate::arena::Handle;
 use crate::arena::HandleSet;
+use crate::arena::HashArena;
 use crate::arena::List;
-use crate::arena::ListArena;
 use crate::arena::ListCell;
 use crate::arena::SupplementalArena;
+use crate::arena::VecArena;
 use crate::cycles::Appendables;
 use crate::cycles::AppendingCycleDetector;
 use crate::cycles::SimilarPathDetector;
@@ -74,10 +74,9 @@ use crate::CancellationFlag;
 /// partial paths that are actually needed, placing them into a `Database` instance as they're
 /// needed.
 pub struct Database {
-    pub(crate) partial_paths: Arena<PartialPath>,
+    pub(crate) partial_paths: VecArena<PartialPath>,
     pub(crate) local_nodes: HandleSet<Node>,
-    symbol_stack_keys: ListArena<Handle<Symbol>>,
-    symbol_stack_key_cache: HashMap<SymbolStackCacheKey, SymbolStackKeyHandle>,
+    symbol_stack_keys: HashArena<ListCell<Handle<Symbol>>>,
     paths_by_start_node: SupplementalArena<Node, Vec<Handle<PartialPath>>>,
     root_paths_by_precondition: SupplementalArena<SymbolStackKeyCell, Vec<Handle<PartialPath>>>,
 }
@@ -86,10 +85,9 @@ impl Database {
     /// Creates a new, empty database.
     pub fn new() -> Database {
         Database {
-            partial_paths: Arena::new(),
+            partial_paths: VecArena::new(),
             local_nodes: HandleSet::new(),
-            symbol_stack_keys: List::new_arena(),
-            symbol_stack_key_cache: HashMap::new(),
+            symbol_stack_keys: HashArena::new(),
             paths_by_start_node: SupplementalArena::new(),
             root_paths_by_precondition: SupplementalArena::new(),
         }
@@ -362,18 +360,7 @@ impl SymbolStackKey {
 
     /// Pushes a new symbol onto the back of this symbol stack key.
     fn push_back(&mut self, db: &mut Database, symbol: Handle<Symbol>) {
-        let cache_key = SymbolStackCacheKey {
-            head: symbol,
-            tail: self.back_handle(),
-        };
-        if let Some(handle) = db.symbol_stack_key_cache.get(&cache_key) {
-            self.symbols = List::from_handle(*handle);
-            return;
-        }
-        // push_front because we store the key's symbols in reverse order.
         self.symbols.push_front(&mut db.symbol_stack_keys, symbol);
-        let handle = self.back_handle();
-        db.symbol_stack_key_cache.insert(cache_key, handle);
     }
 
     /// Pops a symbol from the back of this symbol stack key.
diff --git a/stack-graphs/tests/it/arena.rs b/stack-graphs/tests/it/arena.rs
index 5af25d66e..1e611f73d 100644
--- a/stack-graphs/tests/it/arena.rs
+++ b/stack-graphs/tests/it/arena.rs
@@ -8,15 +8,17 @@
 use stack_graphs::arena::Arena;
 use stack_graphs::arena::Deque;
 use stack_graphs::arena::DequeArena;
+use stack_graphs::arena::HashArena;
 use stack_graphs::arena::List;
 use stack_graphs::arena::ListArena;
 use stack_graphs::arena::ReversibleList;
 use stack_graphs::arena::ReversibleListArena;
 use stack_graphs::arena::SupplementalArena;
+use stack_graphs::arena::VecArena;
 
 #[test]
 fn can_allocate_in_arena() {
-    let mut arena = Arena::new();
+    let mut arena = VecArena::new();
     let hello1 = arena.add("hello".to_string());
     let hello2 = arena.add("hello".to_string());
     let there = arena.add("there".to_string());
@@ -28,9 +30,23 @@ fn can_allocate_in_arena() {
     assert_ne!(arena.get(hello2), arena.get(there));
 }
 
+#[test]
+fn can_allocate_in_interning_arena() {
+    let mut arena = HashArena::new();
+    let hello1 = arena.add("hello".to_string());
+    let hello2 = arena.add("hello".to_string());
+    let there = arena.add("there".to_string());
+    assert_eq!(hello1, hello2);
+    assert_ne!(hello1, there);
+    assert_ne!(hello2, there);
+    assert_eq!(arena.get(hello1), arena.get(hello2));
+    assert_ne!(arena.get(hello1), arena.get(there));
+    assert_ne!(arena.get(hello2), arena.get(there));
+}
+
 #[test]
 fn can_allocate_in_supplemental_arena() {
-    let mut arena = Arena::<u32>::new();
+    let mut arena = VecArena::<u32>::new();
     let h1 = arena.add(1);
     let h2 = arena.add(2);
     let h3 = arena.add(3);
@@ -45,187 +61,202 @@ fn can_allocate_in_supplemental_arena() {
 
 #[test]
 fn can_create_lists() {
-    fn collect(list: &List<u32>, arena: &ListArena<u32>) -> Vec<u32> {
+    fn collect(list: &List<u32>, arena: &impl ListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
-
-    let mut arena = List::new_arena();
-    let mut list = List::empty();
-    assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
-    list.push_front(&mut arena, 1);
-    assert_eq!(collect(&list, &arena), vec![1]);
-    list.push_front(&mut arena, 2);
-    list.push_front(&mut arena, 3);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+    fn run(mut arena: impl ListArena<u32>) {
+        let mut list = List::empty();
+        assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
+        list.push_front(&mut arena, 1);
+        assert_eq!(collect(&list, &arena), vec![1]);
+        list.push_front(&mut arena, 2);
+        list.push_front(&mut arena, 3);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_lists() {
-    use std::cmp::Ordering;
-    let mut arena = List::new_arena();
-    let mut from_slice = |slice: &[u32]| {
-        let mut list = List::empty();
-        for element in slice.iter().rev() {
-            list.push_front(&mut arena, *element);
-        }
-        list
-    };
-    let list0 = from_slice(&[]);
-    let list1 = from_slice(&[1]);
-    let list2 = from_slice(&[2]);
-    let list12 = from_slice(&[1, 2]);
-    assert!(list0.equals(&arena, list0));
-    assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
-    assert!(!list0.equals(&arena, list1));
-    assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
-    assert!(list1.equals(&arena, list1));
-    assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
-    assert!(!list1.equals(&arena, list2));
-    assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
-    assert!(list2.equals(&arena, list2));
-    assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
-    assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+    fn run(mut arena: impl ListArena<u32>) {
+        use std::cmp::Ordering;
+        let mut from_slice = |slice: &[u32]| {
+            let mut list = List::empty();
+            for element in slice.iter().rev() {
+                list.push_front(&mut arena, *element);
+            }
+            list
+        };
+        let list0 = from_slice(&[]);
+        let list1 = from_slice(&[1]);
+        let list2 = from_slice(&[2]);
+        let list12 = from_slice(&[1, 2]);
+        assert!(list0.equals(&arena, list0));
+        assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
+        assert!(!list0.equals(&arena, list1));
+        assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
+        assert!(list1.equals(&arena, list1));
+        assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
+        assert!(!list1.equals(&arena, list2));
+        assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
+        assert!(list2.equals(&arena, list2));
+        assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
+        assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_create_reversible_lists() {
-    fn collect(list: &ReversibleList<u32>, arena: &ReversibleListArena<u32>) -> Vec<u32> {
+    fn collect(list: &ReversibleList<u32>, arena: &impl ReversibleListArena<u32>) -> Vec<u32> {
         list.iter(arena).copied().collect()
     }
-
-    let mut arena = ReversibleList::new_arena();
-    let mut list = ReversibleList::empty();
-    assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
-    list.push_front(&mut arena, 1);
-    assert_eq!(collect(&list, &arena), vec![1]);
-    list.push_front(&mut arena, 2);
-    list.push_front(&mut arena, 3);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
-    list.reverse(&mut arena);
-    assert_eq!(collect(&list, &arena), vec![1, 2, 3]);
-    list.push_front(&mut arena, 4);
-    list.push_front(&mut arena, 5);
-    assert_eq!(collect(&list, &arena), vec![5, 4, 1, 2, 3]);
-    list.reverse(&mut arena);
-    assert_eq!(collect(&list, &arena), vec![3, 2, 1, 4, 5]);
-    // Verify that we stash away the re-reversal so that we don't have to recompute it.
-    assert!(list.have_reversal(&arena));
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut list = ReversibleList::empty();
+        assert_eq!(collect(&list, &arena), vec![] as Vec<u32>);
+        list.push_front(&mut arena, 1);
+        assert_eq!(collect(&list, &arena), vec![1]);
+        list.push_front(&mut arena, 2);
+        list.push_front(&mut arena, 3);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1]);
+        list.reverse(&mut arena);
+        assert_eq!(collect(&list, &arena), vec![1, 2, 3]);
+        list.push_front(&mut arena, 4);
+        list.push_front(&mut arena, 5);
+        assert_eq!(collect(&list, &arena), vec![5, 4, 1, 2, 3]);
+        list.reverse(&mut arena);
+        assert_eq!(collect(&list, &arena), vec![3, 2, 1, 4, 5]);
+        // Verify that we stash away the re-reversal so that we don't have to recompute it.
+        assert!(list.have_reversal(&arena));
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_reversible_lists() {
     use std::cmp::Ordering;
-    let mut arena = ReversibleList::new_arena();
-    let mut from_slice = |slice: &[u32]| {
-        let mut list = ReversibleList::empty();
-        for element in slice.iter().rev() {
-            list.push_front(&mut arena, *element);
-        }
-        list
-    };
-    let list0 = from_slice(&[]);
-    let list1 = from_slice(&[1]);
-    let list2 = from_slice(&[2]);
-    let list12 = from_slice(&[1, 2]);
-    assert!(list0.equals(&arena, list0));
-    assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
-    assert!(!list0.equals(&arena, list1));
-    assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
-    assert!(list1.equals(&arena, list1));
-    assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
-    assert!(!list1.equals(&arena, list2));
-    assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
-    assert!(list2.equals(&arena, list2));
-    assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
-    assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
-    let mut list21 = list12;
-    list21.reverse(&mut arena);
-    assert_eq!(list2.cmp(&arena, list21), Ordering::Less);
-    assert_eq!(list1.cmp(&arena, list21), Ordering::Less);
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut from_slice = |slice: &[u32]| {
+            let mut list = ReversibleList::empty();
+            for element in slice.iter().rev() {
+                list.push_front(&mut arena, *element);
+            }
+            list
+        };
+        let list0 = from_slice(&[]);
+        let list1 = from_slice(&[1]);
+        let list2 = from_slice(&[2]);
+        let list12 = from_slice(&[1, 2]);
+        assert!(list0.equals(&arena, list0));
+        assert_eq!(list0.cmp(&arena, list0), Ordering::Equal);
+        assert!(!list0.equals(&arena, list1));
+        assert_eq!(list0.cmp(&arena, list1), Ordering::Less);
+        assert!(list1.equals(&arena, list1));
+        assert_eq!(list1.cmp(&arena, list1), Ordering::Equal);
+        assert!(!list1.equals(&arena, list2));
+        assert_eq!(list1.cmp(&arena, list2), Ordering::Less);
+        assert!(list2.equals(&arena, list2));
+        assert_eq!(list2.cmp(&arena, list12), Ordering::Greater);
+        assert_eq!(list1.cmp(&arena, list12), Ordering::Less);
+        let mut list21 = list12;
+        list21.reverse(&mut arena);
+        assert_eq!(list2.cmp(&arena, list21), Ordering::Less);
+        assert_eq!(list1.cmp(&arena, list21), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_create_deques() {
-    fn collect(deque: &Deque<u32>, arena: &mut DequeArena<u32>) -> Vec<u32> {
+    fn collect(deque: &Deque<u32>, arena: &mut impl DequeArena<u32>) -> Vec<u32> {
         deque.iter(arena).copied().collect()
     }
-    fn collect_reused(deque: &Deque<u32>, arena: &DequeArena<u32>) -> Vec<u32> {
+    fn collect_reused(deque: &Deque<u32>, arena: &impl DequeArena<u32>) -> Vec<u32> {
         deque.iter_reused(arena).copied().collect()
     }
-    fn collect_rev(deque: &Deque<u32>, arena: &mut DequeArena<u32>) -> Vec<u32> {
+    fn collect_rev(deque: &Deque<u32>, arena: &mut impl DequeArena<u32>) -> Vec<u32> {
         deque.iter_reversed(arena).copied().collect()
     }
-
-    let mut arena = Deque::new_arena();
-    let mut deque = Deque::empty();
-    assert_eq!(collect(&deque, &mut arena), vec![] as Vec<u32>);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![] as Vec<u32>);
-    deque.push_front(&mut arena, 1);
-    assert_eq!(collect(&deque, &mut arena), vec![1]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![1]);
-    deque.push_front(&mut arena, 2);
-    deque.push_front(&mut arena, 3);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![1, 2, 3]);
-    deque.push_back(&mut arena, 4);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![4, 1, 2, 3]);
-    deque.push_back(&mut arena, 5);
-    deque.push_back(&mut arena, 6);
-    assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4, 5, 6]);
-    assert_eq!(collect_rev(&deque, &mut arena), vec![6, 5, 4, 1, 2, 3]);
-    deque.push_front(&mut arena, 7);
-    deque.push_front(&mut arena, 8);
-    assert_eq!(collect(&deque, &mut arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
-    assert_eq!(collect_reused(&deque, &arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
-    assert_eq!(
-        collect_rev(&deque, &mut arena),
-        vec![6, 5, 4, 1, 2, 3, 7, 8]
-    );
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let mut deque = Deque::empty();
+        assert_eq!(collect(&deque, &mut arena), vec![] as Vec<u32>);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![] as Vec<u32>);
+        deque.push_front(&mut arena, 1);
+        assert_eq!(collect(&deque, &mut arena), vec![1]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![1]);
+        deque.push_front(&mut arena, 2);
+        deque.push_front(&mut arena, 3);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![1, 2, 3]);
+        deque.push_back(&mut arena, 4);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![4, 1, 2, 3]);
+        deque.push_back(&mut arena, 5);
+        deque.push_back(&mut arena, 6);
+        assert_eq!(collect(&deque, &mut arena), vec![3, 2, 1, 4, 5, 6]);
+        assert_eq!(collect_rev(&deque, &mut arena), vec![6, 5, 4, 1, 2, 3]);
+        deque.push_front(&mut arena, 7);
+        deque.push_front(&mut arena, 8);
+        assert_eq!(collect(&deque, &mut arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
+        assert_eq!(collect_reused(&deque, &arena), vec![8, 7, 3, 2, 1, 4, 5, 6]);
+        assert_eq!(
+            collect_rev(&deque, &mut arena),
+            vec![6, 5, 4, 1, 2, 3, 7, 8]
+        );
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }
 
 #[test]
 fn can_compare_deques() {
     use std::cmp::Ordering;
-    let mut arena = Deque::new_arena();
     // Build up deques in both directions so that our comparisons have to test the "reverse if
     // needed" logic.
-    let from_slice_forwards = |slice: &[u32], arena: &mut DequeArena<u32>| {
+    fn from_slice_forwards(slice: &[u32], arena: &mut impl DequeArena<u32>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter() {
             deque.push_back(arena, *element);
         }
         deque
-    };
-    let from_slice_backwards = |slice: &[u32], arena: &mut DequeArena<u32>| {
+    }
+    fn from_slice_backwards(slice: &[u32], arena: &mut impl DequeArena<u32>) -> Deque<u32> {
         let mut deque = Deque::empty();
         for element in slice.iter().rev() {
             deque.push_front(arena, *element);
         }
         deque
-    };
-    let deque0 = from_slice_forwards(&[], &mut arena);
-    let mut deque1 = from_slice_backwards(&[1], &mut arena);
-    let deque2 = from_slice_forwards(&[2], &mut arena);
-    let mut deque10 = from_slice_backwards(&[1, 0], &mut arena);
-    let deque12 = from_slice_backwards(&[1, 2], &mut arena);
-    assert!(deque0.equals(&mut arena, deque0));
-    assert_eq!(deque0.cmp(&mut arena, deque0), Ordering::Equal);
-    assert!(!deque0.equals(&mut arena, deque1));
-    assert_eq!(deque0.cmp(&mut arena, deque1), Ordering::Less);
-    assert!(deque1.equals(&mut arena, deque1));
-    assert_eq!(deque1.cmp(&mut arena, deque1), Ordering::Equal);
-    assert!(!deque1.equals(&mut arena, deque2));
-    assert_eq!(deque1.cmp(&mut arena, deque2), Ordering::Less);
-    assert!(deque2.equals(&mut arena, deque2));
-    assert_eq!(deque2.cmp(&mut arena, deque12), Ordering::Greater);
-    assert_eq!(deque1.cmp(&mut arena, deque12), Ordering::Less);
+    }
+    fn run(mut arena: impl ReversibleListArena<u32>) {
+        let deque0 = from_slice_forwards(&[], &mut arena);
+        let mut deque1 = from_slice_backwards(&[1], &mut arena);
+        let deque2 = from_slice_forwards(&[2], &mut arena);
+        let mut deque10 = from_slice_backwards(&[1, 0], &mut arena);
+        let deque12 = from_slice_backwards(&[1, 2], &mut arena);
+        assert!(deque0.equals(&mut arena, deque0));
+        assert_eq!(deque0.cmp(&mut arena, deque0), Ordering::Equal);
+        assert!(!deque0.equals(&mut arena, deque1));
+        assert_eq!(deque0.cmp(&mut arena, deque1), Ordering::Less);
+        assert!(deque1.equals(&mut arena, deque1));
+        assert_eq!(deque1.cmp(&mut arena, deque1), Ordering::Equal);
+        assert!(!deque1.equals(&mut arena, deque2));
+        assert_eq!(deque1.cmp(&mut arena, deque2), Ordering::Less);
+        assert!(deque2.equals(&mut arena, deque2));
+        assert_eq!(deque2.cmp(&mut arena, deque12), Ordering::Greater);
+        assert_eq!(deque1.cmp(&mut arena, deque12), Ordering::Less);
 
-    // We should get the same result regardless of which direction the deques are pointing.
-    deque1.ensure_forwards(&mut arena);
-    deque10.ensure_forwards(&mut arena);
-    assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
-    deque1.ensure_backwards(&mut arena);
-    deque10.ensure_backwards(&mut arena);
-    assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
+        // We should get the same result regardless of which direction the deques are pointing.
+        deque1.ensure_forwards(&mut arena);
+        deque10.ensure_forwards(&mut arena);
+        assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
+        deque1.ensure_backwards(&mut arena);
+        deque10.ensure_backwards(&mut arena);
+        assert_eq!(deque1.cmp(&mut arena, deque10), Ordering::Less);
+    }
+    run(VecArena::new());
+    run(HashArena::new());
 }