diff --git a/src/unify/backing_vec.rs b/src/unify/backing_vec.rs
index 7c1eb2c..bac9556 100644
--- a/src/unify/backing_vec.rs
+++ b/src/unify/backing_vec.rs
@@ -6,7 +6,7 @@ use std::ops::{self, Range};
 
 use undo_log::{Rollback, Snapshots, UndoLogs, VecLog};
 
-use super::{UnifyKey, UnifyValue, VarValue};
+use super::{ExtraTraversalData, NoExtraTraversalData, UnifyKey, UnifyValue, VarValue};
 
 #[allow(dead_code)] // rustc BUG
 #[allow(type_alias_bounds)]
@@ -15,9 +15,12 @@ type Key<S: UnificationStoreBase> = <S as UnificationStoreBase>::Key;
 /// Largely internal trait implemented by the unification table
 /// backing store types. The most common such type is `InPlace`,
 /// which indicates a standard, mutable unification table.
-pub trait UnificationStoreBase: ops::Index<usize, Output = VarValue<Key<Self>>> {
+pub trait UnificationStoreBase:
+    ops::Index<usize, Output = VarValue<Key<Self>, Self::ExtraTraversalData>>
+{
     type Key: UnifyKey<Value = Self::Value>;
     type Value: UnifyValue;
+    type ExtraTraversalData: ExtraTraversalData<Self::Key>;
 
     fn len(&self) -> usize;
 
@@ -27,15 +30,18 @@ pub trait UnificationStoreBase: ops::Index<usize, Output = VarValue<Key<Self>>>
 }
 
 pub trait UnificationStoreMut: UnificationStoreBase {
-    fn reset_unifications(&mut self, value: impl FnMut(u32) -> VarValue<Self::Key>);
+    fn reset_unifications(
+        &mut self,
+        value: impl FnMut(u32) -> VarValue<Self::Key, Self::ExtraTraversalData>,
+    );
 
-    fn push(&mut self, value: VarValue<Self::Key>);
+    fn push(&mut self, value: VarValue<Self::Key, Self::ExtraTraversalData>);
 
     fn reserve(&mut self, num_new_values: usize);
 
     fn update<F>(&mut self, index: usize, op: F)
     where
-        F: FnOnce(&mut VarValue<Self::Key>);
+        F: FnOnce(&mut VarValue<Self::Key, Self::ExtraTraversalData>);
 }
 
 pub trait UnificationStore: UnificationStoreMut {
@@ -55,14 +61,21 @@ pub trait UnificationStore: UnificationStoreMut {
 #[derive(Clone, Debug)]
 pub struct InPlace<
     K: UnifyKey,
-    V: sv::VecLike<Delegate<K>> = Vec<VarValue<K>>,
-    L = VecLog<sv::UndoLog<Delegate<K>>>,
+    TD: ExtraTraversalData<K> = NoExtraTraversalData,
+    V: sv::VecLike<Delegate<K, TD>> = Vec<VarValue<K, TD>>,
+    L = VecLog<sv::UndoLog<Delegate<K, TD>>>,
 > {
-    pub(crate) values: sv::SnapshotVec<Delegate<K>, V, L>,
+    pub(crate) values: sv::SnapshotVec<Delegate<K, TD>, V, L>,
 }
 
 // HACK(eddyb) manual impl avoids `Default` bound on `K`.
-impl<K: UnifyKey, V: sv::VecLike<Delegate<K>> + Default, L: Default> Default for InPlace<K, V, L> {
+impl<
+        K: UnifyKey,
+        TD: ExtraTraversalData<K>,
+        V: sv::VecLike<Delegate<K, TD>> + Default,
+        L: Default,
+    > Default for InPlace<K, TD, V, L>
+{
     fn default() -> Self {
         InPlace {
             values: sv::SnapshotVec::new(),
@@ -70,32 +83,38 @@ impl<K: UnifyKey, V: sv::VecLike<Delegate<K>> + Default, L: Default> Default for
     }
 }
 
-impl<K, V, L> UnificationStoreBase for InPlace<K, V, L>
+impl<K, TD, V, L> UnificationStoreBase for InPlace<K, TD, V, L>
 where
     K: UnifyKey,
-    V: sv::VecLike<Delegate<K>>,
+    V: sv::VecLike<Delegate<K, TD>>,
+    TD: ExtraTraversalData<K>,
 {
     type Key = K;
     type Value = K::Value;
+    type ExtraTraversalData = TD;
 
     fn len(&self) -> usize {
         self.values.len()
     }
 }
 
-impl<K, V, L> UnificationStoreMut for InPlace<K, V, L>
+impl<K, TD, V, L> UnificationStoreMut for InPlace<K, TD, V, L>
 where
     K: UnifyKey,
-    V: sv::VecLike<Delegate<K>>,
-    L: UndoLogs<sv::UndoLog<Delegate<K>>>,
+    TD: ExtraTraversalData<K>,
+    V: sv::VecLike<Delegate<K, TD>>,
+    L: UndoLogs<sv::UndoLog<Delegate<K, TD>>>,
 {
     #[inline]
-    fn reset_unifications(&mut self, mut value: impl FnMut(u32) -> VarValue<Self::Key>) {
+    fn reset_unifications(
+        &mut self,
+        mut value: impl FnMut(u32) -> VarValue<Self::Key, Self::ExtraTraversalData>,
+    ) {
         self.values.set_all(|i| value(i as u32));
     }
 
     #[inline]
-    fn push(&mut self, value: VarValue<Self::Key>) {
+    fn push(&mut self, value: VarValue<Self::Key, Self::ExtraTraversalData>) {
         self.values.push(value);
     }
 
@@ -107,17 +126,18 @@ where
     #[inline]
     fn update<F>(&mut self, index: usize, op: F)
     where
-        F: FnOnce(&mut VarValue<Self::Key>),
+        F: FnOnce(&mut VarValue<Self::Key, Self::ExtraTraversalData>),
     {
         self.values.update(index, op)
     }
 }
 
-impl<K, V, L> UnificationStore for InPlace<K, V, L>
+impl<K, TD, V, L> UnificationStore for InPlace<K, TD, V, L>
 where
     K: UnifyKey,
-    V: sv::VecLike<Delegate<K>>,
-    L: Snapshots<sv::UndoLog<Delegate<K>>>,
+    TD: ExtraTraversalData<K>,
+    V: sv::VecLike<Delegate<K, TD>>,
+    L: Snapshots<sv::UndoLog<Delegate<K, TD>>>,
 {
     type Snapshot = sv::Snapshot<L::Snapshot>;
 
@@ -142,43 +162,46 @@ where
     }
 }
 
-impl<K, V, L> ops::Index<usize> for InPlace<K, V, L>
+impl<K, TD, V, L> ops::Index<usize> for InPlace<K, TD, V, L>
 where
-    V: sv::VecLike<Delegate<K>>,
+    V: sv::VecLike<Delegate<K, TD>>,
     K: UnifyKey,
+    TD: ExtraTraversalData<K>,
 {
-    type Output = VarValue<K>;
-    fn index(&self, index: usize) -> &VarValue<K> {
+    type Output = VarValue<K, TD>;
+    fn index(&self, index: usize) -> &VarValue<K, TD> {
         &self.values[index]
     }
 }
 
 #[doc(hidden)]
 #[derive(Copy, Clone, Debug)]
-pub struct Delegate<K>(PhantomData<K>);
+pub struct Delegate<K, TD>(PhantomData<(K, TD)>);
 
-impl<K: UnifyKey> sv::SnapshotVecDelegate for Delegate<K> {
-    type Value = VarValue<K>;
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> sv::SnapshotVecDelegate for Delegate<K, TD> {
+    type Value = VarValue<K, TD>;
     type Undo = ();
 
-    fn reverse(_: &mut Vec<VarValue<K>>, _: ()) {}
+    fn reverse(_: &mut Vec<VarValue<K, TD>>, _: ()) {}
 }
 
-impl<K: UnifyKey> Rollback<sv::UndoLog<Delegate<K>>> for super::UnificationTableStorage<K> {
-    fn reverse(&mut self, undo: sv::UndoLog<Delegate<K>>) {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> Rollback<sv::UndoLog<Delegate<K, TD>>>
+    for super::UnificationTableStorage<K, TD>
+{
+    fn reverse(&mut self, undo: sv::UndoLog<Delegate<K, TD>>) {
         self.values.values.reverse(undo);
     }
 }
 
 #[cfg(feature = "persistent")]
 #[derive(Clone, Debug)]
-pub struct Persistent<K: UnifyKey> {
-    values: DVec<VarValue<K>>,
+pub struct Persistent<K: UnifyKey, TD: ExtraTraversalData<K>> {
+    values: DVec<VarValue<K, TD>>,
 }
 
 // HACK(eddyb) manual impl avoids `Default` bound on `K`.
 #[cfg(feature = "persistent")]
-impl<K: UnifyKey> Default for Persistent<K> {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> Default for Persistent<K, TD> {
     fn default() -> Self {
         Persistent {
             values: DVec::new(),
@@ -187,9 +210,10 @@ impl<K: UnifyKey> Default for Persistent<K> {
 }
 
 #[cfg(feature = "persistent")]
-impl<K: UnifyKey> UnificationStoreBase for Persistent<K> {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> UnificationStoreBase for Persistent<K, TD> {
     type Key = K;
     type Value = K::Value;
+    type ExtraTraversalData = TD;
 
     fn len(&self) -> usize {
         self.values.len()
@@ -197,9 +221,12 @@ impl<K: UnifyKey> UnificationStoreBase for Persistent<K> {
 }
 
 #[cfg(feature = "persistent")]
-impl<K: UnifyKey> UnificationStoreMut for Persistent<K> {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> UnificationStoreMut for Persistent<K, TD> {
     #[inline]
-    fn reset_unifications(&mut self, mut value: impl FnMut(u32) -> VarValue<Self::Key>) {
+    fn reset_unifications(
+        &mut self,
+        mut value: impl FnMut(u32) -> VarValue<Self::Key, Self::ExtraTraversalData>,
+    ) {
         // Without extending dogged, there isn't obviously a more
         // efficient way to do this. But it's pretty dumb. Maybe
         // dogged needs a `map`.
@@ -209,7 +236,7 @@ impl<K: UnifyKey> UnificationStoreMut for Persistent<K> {
     }
 
     #[inline]
-    fn push(&mut self, value: VarValue<Self::Key>) {
+    fn push(&mut self, value: VarValue<Self::Key, Self::ExtraTraversalData>) {
         self.values.push(value);
     }
 
@@ -221,7 +248,7 @@ impl<K: UnifyKey> UnificationStoreMut for Persistent<K> {
     #[inline]
     fn update<F>(&mut self, index: usize, op: F)
     where
-        F: FnOnce(&mut VarValue<Self::Key>),
+        F: FnOnce(&mut VarValue<Self::Key, Self::ExtraTraversalData>),
     {
         let p = &mut self.values[index];
         op(p);
@@ -229,7 +256,7 @@ impl<K: UnifyKey> UnificationStoreMut for Persistent<K> {
 }
 
 #[cfg(feature = "persistent")]
-impl<K: UnifyKey> UnificationStore for Persistent<K> {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> UnificationStore for Persistent<K, TD> {
     type Snapshot = Self;
 
     #[inline]
@@ -252,12 +279,13 @@ impl<K: UnifyKey> UnificationStore for Persistent<K> {
 }
 
 #[cfg(feature = "persistent")]
-impl<K> ops::Index<usize> for Persistent<K>
+impl<K, TD> ops::Index<usize> for Persistent<K, TD>
 where
     K: UnifyKey,
+    TD: ExtraTraversalData<K>,
 {
-    type Output = VarValue<K>;
-    fn index(&self, index: usize) -> &VarValue<K> {
+    type Output = VarValue<K, TD>;
+    fn index(&self, index: usize) -> &VarValue<K, TD> {
         &self.values[index]
     }
 }
diff --git a/src/unify/mod.rs b/src/unify/mod.rs
index a26d699..34d43e8 100644
--- a/src/unify/mod.rs
+++ b/src/unify/mod.rs
@@ -160,10 +160,90 @@ pub struct NoError {
 /// time of the algorithm under control. For more information, see
 /// <http://en.wikipedia.org/wiki/Disjoint-set_data_structure>.
 #[derive(PartialEq, Clone, Debug)]
-pub struct VarValue<K: UnifyKey> {
+pub struct VarValue<K: UnifyKey, TD: ExtraTraversalData<K>> {
     parent: K,       // if equal to self, this is a root
     value: K::Value, // value assigned (only relevant to root)
     rank: u32,       // max depth (only relevant to root)
+    traversing_data: TD::Data,
+}
+
+// Debug and Clone on these are just here because derives will generate
+// bounds on these types andhaving these enable us to still not have to
+// write these impls manually.
+
+/// Use this as [`ExtraTraversalData`] if you don't need to traverse connected
+/// components directly on the [`UnificationTable`]
+#[derive(Debug, Clone)]
+pub struct NoExtraTraversalData;
+/// Use this as [`ExtraTraversalData`] if you need to traverse connected
+/// components directly on the [`UnificationTable`]
+///
+/// This makes the [`UnificationTable::unioned_keys`] function available
+#[derive(Debug, Clone)]
+pub struct ConnectedComponentTraversal;
+/// Choose an implementor of this trait to determine whether the
+/// [`UnificationTable`] will store the data necessary to do connected
+/// component traversal.
+///
+/// This trait is largely internal and is not meant to be implemented outside
+/// of this crate.
+///
+/// It provides necessary functions to change the behavior of
+/// the [`UnificationTable`] where it should differ between the two
+/// implementations.
+pub trait ExtraTraversalData<K: UnifyKey>: Sized + Clone + Debug {
+    type Data: Clone + Debug;
+    fn init_from_key(k: K) -> Self::Data;
+    fn redirect(old_root_value: &mut VarValue<K, Self>, sibling: K);
+    fn make_root(new_root_value: &mut VarValue<K, Self>, child: K);
+    fn child(var_value: &VarValue<K, Self>, self_key: K) -> Option<K>;
+}
+impl<K: UnifyKey> ExtraTraversalData<K> for NoExtraTraversalData {
+    type Data = ();
+    #[inline(always)]
+    fn init_from_key(_k: K) -> Self::Data {}
+    #[inline(always)]
+    fn redirect(_old_root_value: &mut VarValue<K, Self>, _sibling: K) {}
+    #[inline(always)]
+    fn make_root(_new_root_value: &mut VarValue<K, Self>, _child: K) {}
+    #[inline(always)]
+    fn child(_var_value: &VarValue<K, Self>, _self_key: K) -> Option<K> {
+        None
+    }
+}
+impl<K: UnifyKey> ExtraTraversalData<K> for ConnectedComponentTraversal {
+    type Data = CongruenceClosureTraversalData<K>;
+    #[inline(always)]
+    fn init_from_key(k: K) -> Self::Data {
+        CongruenceClosureTraversalData {
+            child: k,
+            sibling: k,
+        }
+    }
+    #[inline(always)]
+    fn redirect(old_root_value: &mut VarValue<K, Self>, sibling: K) {
+        // Since this used to be a root, we should have
+        // var_value.parent = var_value.sibling = the key of this value
+        debug_assert_eq!(
+            old_root_value.parent,
+            old_root_value.traversing_data.sibling
+        );
+        old_root_value.traversing_data.sibling = sibling;
+    }
+    #[inline(always)]
+    fn make_root(new_root_value: &mut VarValue<K, Self>, child: K) {
+        new_root_value.traversing_data.child = child;
+    }
+    #[inline(always)]
+    fn child(var_value: &VarValue<K, Self>, self_key: K) -> Option<K> {
+        var_value.child(self_key)
+    }
+}
+#[doc(hidden)]
+#[derive(PartialEq, Clone, Debug)]
+pub struct CongruenceClosureTraversalData<K> {
+    child: K,
+    sibling: K,
 }
 
 /// Table of unification keys and their values. You must define a key type K
@@ -185,21 +265,22 @@ pub struct UnificationTable<S: UnificationStoreBase> {
     values: S,
 }
 
-pub type UnificationStorage<K> = Vec<VarValue<K>>;
-pub type UnificationTableStorage<K> = UnificationTable<InPlace<K, UnificationStorage<K>, ()>>;
+pub type UnificationStorage<K, TD = NoExtraTraversalData> = Vec<VarValue<K, TD>>;
+pub type UnificationTableStorage<K, TD = NoExtraTraversalData> =
+    UnificationTable<InPlace<K, TD, UnificationStorage<K, TD>, ()>>;
 
 /// A unification table that uses an "in-place" vector.
-#[allow(type_alias_bounds)]
 pub type InPlaceUnificationTable<
-    K: UnifyKey,
-    V: sv::VecLike<Delegate<K>> = Vec<VarValue<K>>,
-    L = VecLog<UndoLog<Delegate<K>>>,
-> = UnificationTable<InPlace<K, V, L>>;
+    K,
+    TD = NoExtraTraversalData,
+    V = UnificationStorage<K, TD>,
+    L = VecLog<UndoLog<Delegate<K, TD>>>,
+> = UnificationTable<InPlace<K, TD, V, L>>;
 
 /// A unification table that uses a "persistent" vector.
 #[cfg(feature = "persistent")]
-#[allow(type_alias_bounds)]
-pub type PersistentUnificationTable<K: UnifyKey> = UnificationTable<Persistent<K>>;
+pub type PersistentUnificationTable<K, TD = NoExtraTraversalData> =
+    UnificationTable<Persistent<K, TD>>;
 
 /// At any time, users may snapshot a unification table.  The changes
 /// made during the snapshot may either be *committed* or *rolled back*.
@@ -209,24 +290,25 @@ pub struct Snapshot<S: UnificationStore> {
     snapshot: S::Snapshot,
 }
 
-impl<K: UnifyKey> VarValue<K> {
-    fn new_var(key: K, value: K::Value) -> VarValue<K> {
-        VarValue::new(key, value, 0)
-    }
-
-    fn new(parent: K, value: K::Value, rank: u32) -> VarValue<K> {
+impl<K: UnifyKey, TD: ExtraTraversalData<K>> VarValue<K, TD> {
+    fn new(key: K, value: K::Value) -> Self {
         VarValue {
-            parent: parent, // this is a root
+            parent: key, // this is a root
             value: value,
-            rank: rank,
+            rank: 0,
+            traversing_data: TD::init_from_key(key),
         }
     }
 
-    fn redirect(&mut self, to: K) {
+    #[inline(always)]
+    fn redirect(&mut self, to: K, sibling: K) {
+        TD::redirect(self, sibling);
         self.parent = to;
     }
 
-    fn root(&mut self, rank: u32, value: K::Value) {
+    #[inline(always)]
+    fn make_root(&mut self, rank: u32, child: K, value: K::Value) {
+        TD::make_root(self, child);
         self.rank = rank;
         self.value = value;
     }
@@ -243,18 +325,29 @@ impl<K: UnifyKey> VarValue<K> {
         }
     }
 }
-impl<K> UnificationTableStorage<K>
+impl<K: UnifyKey> VarValue<K, ConnectedComponentTraversal> {
+    fn child(&self, self_key: K) -> Option<K> {
+        self.if_not_self(self.traversing_data.child, self_key)
+    }
+
+    fn sibling(&self, self_key: K) -> Option<K> {
+        self.if_not_self(self.traversing_data.sibling, self_key)
+    }
+}
+
+impl<K, TD> UnificationTableStorage<K, TD>
 where
     K: UnifyKey,
+    TD: ExtraTraversalData<K>,
 {
     /// Creates a `UnificationTable` using an external `undo_log`, allowing mutating methods to be
     /// called if `L` does not implement `UndoLogs`
     pub fn with_log<'a, L>(
         &'a mut self,
         undo_log: L,
-    ) -> UnificationTable<InPlace<K, &'a mut UnificationStorage<K>, L>>
+    ) -> UnificationTable<InPlace<K, TD, &'a mut UnificationStorage<K, TD>, L>>
     where
-        L: UndoLogs<sv::UndoLog<Delegate<K>>>,
+        L: UndoLogs<sv::UndoLog<Delegate<K, TD>>>,
     {
         UnificationTable {
             values: InPlace {
@@ -319,7 +412,7 @@ impl<S: UnificationStoreMut> UnificationTable<S> {
     pub fn new_key(&mut self, value: S::Value) -> S::Key {
         let len = self.values.len();
         let key: S::Key = UnifyKey::from_index(len as u32);
-        self.values.push(VarValue::new_var(key, value));
+        self.values.push(VarValue::new(key, value));
         debug!("{}: created new key: {:?}", S::tag(), key);
         key
     }
@@ -337,13 +430,13 @@ impl<S: UnificationStoreMut> UnificationTable<S> {
         self.values.reset_unifications(|i| {
             let key = UnifyKey::from_index(i as u32);
             let value = value(key);
-            VarValue::new_var(key, value)
+            VarValue::new(key, value)
         });
     }
 
     /// Obtains the current value for a particular key.
     /// Not for end-users; they can use `probe_value`.
-    fn value(&self, key: S::Key) -> &VarValue<S::Key> {
+    fn value(&self, key: S::Key) -> &VarValue<S::Key, S::ExtraTraversalData> {
         &self.values[key.index() as usize]
     }
 
@@ -383,7 +476,7 @@ impl<S: UnificationStoreMut> UnificationTable<S> {
 
     fn update_value<OP>(&mut self, key: S::Key, op: OP)
     where
-        OP: FnOnce(&mut VarValue<S::Key>),
+        OP: FnOnce(&mut VarValue<S::Key, S::ExtraTraversalData>),
     {
         self.values.update(key.index() as usize, op);
         debug!("Updated variable {:?} to {:?}", key, self.value(key));
@@ -452,15 +545,128 @@ impl<S: UnificationStoreMut> UnificationTable<S> {
         new_root_key: S::Key,
         new_value: S::Value,
     ) {
+        let sibling = <S::ExtraTraversalData as ExtraTraversalData<S::Key>>::child(
+            self.value(new_root_key),
+            new_root_key,
+        )
+        .unwrap_or(old_root_key);
         self.update_value(old_root_key, |old_root_value| {
-            old_root_value.redirect(new_root_key);
+            old_root_value.redirect(new_root_key, sibling);
         });
         self.update_value(new_root_key, |new_root_value| {
-            new_root_value.root(new_rank, new_value);
+            new_root_value.make_root(new_rank, old_root_key, new_value);
         });
     }
 }
 
+impl<S: UnificationStoreMut<ExtraTraversalData = ConnectedComponentTraversal>> UnificationTable<S> {
+    /// Returns an iterator over all keys unioned with `key`.
+    pub fn unioned_keys<K1>(&mut self, key: K1) -> UnionedKeys<S>
+    where
+        K1: Into<S::Key>,
+    {
+        let key = key.into();
+        let root_key = self.uninlined_get_root_key(key);
+        UnionedKeys {
+            table: self,
+            stack: vec![root_key],
+        }
+    }
+
+    /// Clears all unifications that were connected to `key`.
+    /// They will all become individual elements again.
+    ///
+    /// This leaves other connected components intact.
+    ///
+    /// The values of each variable are given by the closure.
+    pub fn reset_unifications_partial(
+        &mut self,
+        key: impl Into<S::Key>,
+        mut value: impl FnMut(S::Key) -> S::Value,
+    ) {
+        let key = key.into();
+        let unioned_keys: Vec<_> = self.unioned_keys(key).collect();
+        for key in unioned_keys {
+            self.update_value(key, |var_value| {
+                *var_value = VarValue::new(key, value(key));
+            });
+        }
+    }
+}
+
+/// Iterator over keys that have been unioned together.
+/// You can only obtain this from an [`UnificationTable`] that uses
+/// [`ConnectedComponentTraversal`]
+///
+/// Returned by the `unioned_keys` method.
+pub struct UnionedKeys<'a, S>
+where
+    S: UnificationStoreMut<ExtraTraversalData = ConnectedComponentTraversal> + 'a,
+    S::Key: 'a,
+    S::Value: 'a,
+{
+    table: &'a mut UnificationTable<S>,
+    stack: Vec<S::Key>,
+}
+
+impl<'a, S> UnionedKeys<'a, S>
+where
+    S: UnificationStoreMut<ExtraTraversalData = ConnectedComponentTraversal> + 'a,
+    S::Key: 'a,
+    S::Value: 'a,
+{
+    fn var_value(&self, key: S::Key) -> &VarValue<S::Key, S::ExtraTraversalData> {
+        self.table.value(key)
+    }
+}
+
+impl<'a, S: 'a> Iterator for UnionedKeys<'a, S>
+where
+    S: UnificationStoreMut<ExtraTraversalData = ConnectedComponentTraversal> + 'a,
+    S::Key: 'a,
+    S::Value: 'a,
+{
+    type Item = S::Key;
+
+    fn next(&mut self) -> Option<S::Key> {
+        let key = match self.stack.last() {
+            Some(k) => *k,
+            None => {
+                return None;
+            }
+        };
+
+        let vv = self.var_value(key);
+
+        match vv.child(key) {
+            Some(child_key) => {
+                self.stack.push(child_key);
+            }
+            None => {
+                // No child, push a sibling for the current node. If
+                // current node has no siblings, start popping
+                // ancestors until we find an aunt or uncle or
+                // something to push. Note that we have the invariant
+                // that for every node N that we reach by popping
+                // items off of the stack, we have already visited all
+                // children of N.
+                while let Some(ancestor_key) = self.stack.pop() {
+                    let ancestor_vv = self.var_value(ancestor_key);
+                    match ancestor_vv.sibling(ancestor_key) {
+                        Some(sibling) => {
+                            self.stack.push(sibling);
+                            break;
+                        }
+                        None => {}
+                    }
+                }
+            }
+        }
+
+        Some(key)
+    }
+}
+
 /// ////////////////////////////////////////////////////////////////////////
 /// Public API
 
diff --git a/src/unify/tests.rs b/src/unify/tests.rs
index 5665aba..72087c4 100644
--- a/src/unify/tests.rs
+++ b/src/unify/tests.rs
@@ -17,9 +17,13 @@ extern crate test;
 #[cfg(feature = "bench")]
 use self::test::Bencher;
 use std::cmp;
+use std::collections::HashSet;
 #[cfg(feature = "persistent")]
 use unify::Persistent;
-use unify::{EqUnifyValue, InPlace, InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
+use unify::{
+    ConnectedComponentTraversal, EqUnifyValue, InPlace, InPlaceUnificationTable, NoError,
+    NoExtraTraversalData, UnifyKey, UnifyValue,
+};
 use unify::{UnificationStore, UnificationTable};
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -46,10 +50,13 @@ macro_rules! all_modes {
             $body
         }
 
-        test_body::<InPlace<$t>>();
+        test_body::<InPlace<$t, NoExtraTraversalData>>();
+        test_body::<InPlace<$t, ConnectedComponentTraversal>>();
 
         #[cfg(feature = "persistent")]
-        test_body::<Persistent<$t>>();
+        test_body::<Persistent<$t, NoExtraTraversalData>>();
+        #[cfg(feature = "persistent")]
+        test_body::<Persistent<$t, ConnectedComponentTraversal>>();
     };
 }
 
@@ -241,6 +248,31 @@ fn even_odd() {
     }
 }
 
+#[test]
+fn even_odd_iter() {
+    let mut ut: InPlaceUnificationTable<UnitKey, ConnectedComponentTraversal> =
+        UnificationTable::new();
+    let mut keys = Vec::new();
+    const MAX: usize = 1 << 10;
+
+    for i in 0..MAX {
+        let key = ut.new_key(());
+        keys.push(key);
+
+        if i >= 2 {
+            ut.union(key, keys[i - 2]);
+        }
+    }
+
+    let even_keys: HashSet<UnitKey> = ut.unioned_keys(keys[22]).collect();
+
+    assert_eq!(even_keys.len(), MAX / 2);
+
+    for key in even_keys {
+        assert!((key.0 & 1) == 0);
+    }
+}
+
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 struct IntKey(u32);
 
diff --git a/tests/external_undo_log.rs b/tests/external_undo_log.rs
index 2537826..9a217c3 100644
--- a/tests/external_undo_log.rs
+++ b/tests/external_undo_log.rs
@@ -5,7 +5,7 @@ extern crate ena;
 use ena::{
     snapshot_vec as sv,
     undo_log::{Rollback, Snapshots, UndoLogs},
-    unify::{self as ut, EqUnifyValue, UnifyKey},
+    unify::{self as ut, EqUnifyValue, NoExtraTraversalData, UnifyKey},
 };
 
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
@@ -27,12 +27,12 @@ impl UnifyKey for IntKey {
 impl EqUnifyValue for IntKey {}
 
 enum UndoLog {
-    EqRelation(sv::UndoLog<ut::Delegate<IntKey>>),
+    EqRelation(sv::UndoLog<ut::Delegate<IntKey, NoExtraTraversalData>>),
     Values(sv::UndoLog<i32>),
 }
 
-impl From<sv::UndoLog<ut::Delegate<IntKey>>> for UndoLog {
-    fn from(l: sv::UndoLog<ut::Delegate<IntKey>>) -> Self {
+impl From<sv::UndoLog<ut::Delegate<IntKey, NoExtraTraversalData>>> for UndoLog {
+    fn from(l: sv::UndoLog<ut::Delegate<IntKey, NoExtraTraversalData>>) -> Self {
         UndoLog::EqRelation(l)
     }
 }
@@ -55,7 +55,6 @@ impl Rollback<UndoLog> for TypeVariableStorage {
 #[derive(Default)]
 struct TypeVariableStorage {
     values: sv::SnapshotVecStorage<i32>,
-
     eq_relations: ut::UnificationTableStorage<IntKey>,
 }