diff --git a/src/flow/traversible.rs b/src/flow/traversible.rs
index dd16dec..f23818d 100644
--- a/src/flow/traversible.rs
+++ b/src/flow/traversible.rs
@@ -11,7 +11,7 @@ use crate::func::*;
 pub type Split<'a, T, A, D> = (
     Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
     Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
-    Rc<A>,
+    A,
 );
 
 pub trait TraversibleBinaryNode<'a, T: Monad<'a>, A: 'a, D: 'a + PartialEq>: 'a {
diff --git a/src/flow/traversible/algorithms/contains.rs b/src/flow/traversible/algorithms/contains.rs
index 55d5068..c5b04c6 100644
--- a/src/flow/traversible/algorithms/contains.rs
+++ b/src/flow/traversible/algorithms/contains.rs
@@ -1,30 +1,30 @@
 use crate::flow::traversible::*;
 
-pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
+pub fn n_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     n_set: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
-    key: Rc<A>,
+    key: A,
 ) -> T::F<()> {
     let (t_setl, t_setr, k_set) = n_set.split();
-    match comparator.pick_smaller(key.as_ref(), k_set.as_ref()) {
+    match comparator.pick_smaller(&key, &k_set) {
         Comparison::L => t_contains(comparator, t_setl, key),
         Comparison::E => T::pure(()),
         Comparison::R => t_contains(comparator, t_setr, key),
     }
 }
 
-pub fn r_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
+pub fn r_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     r_set: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
-    key: Rc<A>,
+    key: A,
 ) -> T::F<()> {
     T::bind(r_set.resolve(), |n_set| n_contains(comparator, n_set, key))
 }
 
-pub fn t_contains<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
+pub fn t_contains<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     t_set: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
-    key: Rc<A>,
+    key: A,
 ) -> T::F<()> {
     match t_set.refer() {
         Some(r_set) => r_contains(comparator, r_set, key),
diff --git a/src/flow/traversible/algorithms/subset.rs b/src/flow/traversible/algorithms/subset.rs
index 176734b..6d10333 100644
--- a/src/flow/traversible/algorithms/subset.rs
+++ b/src/flow/traversible/algorithms/subset.rs
@@ -7,14 +7,14 @@ struct SubsetContext<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> {
     comparator: &'a dyn Comparator<A>,
     n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
     n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
-    k_l: Option<Rc<A>>,
-    k_r: Option<Rc<A>>,
+    k_l: Option<A>,
+    k_r: Option<A>,
     t_superl: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
     t_superr: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
-    k_super: Rc<A>,
+    k_super: A,
 }
 
-impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a, T, A, D> {
+impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq> SubsetContext<'a, T, A, D> {
     fn on_l(self, (t_subl, t_subr, k_sub): Split<'a, T, A, D>) -> T::F<()> {
         T::la2(
             algorithms::contains::t_contains(self.comparator, self.t_superl.clone(), k_sub.clone()),
@@ -85,10 +85,7 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
 
     fn test(self) -> T::F<()> {
         let split = self.n_subset.split();
-        match self
-            .comparator
-            .pick_smaller(split.2.as_ref(), self.k_super.as_ref())
-        {
+        match self.comparator.pick_smaller(&split.2, &self.k_super) {
             Comparison::L => self.on_l(split),
             Comparison::E => self.on_e(split),
             Comparison::R => self.on_r(split),
@@ -96,21 +93,21 @@ impl<'a, T: 'a + MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq> SubsetContext<'a,
     }
 }
 
-pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
+pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     n_subset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
     n_superset: Rc<dyn TraversibleBinaryNode<'a, T, A, D>>,
-    k_l: Option<Rc<A>>,
-    k_r: Option<Rc<A>>,
+    k_l: Option<A>,
+    k_r: Option<A>,
 ) -> T::F<()> {
     let (t_superl, t_superr, k_super) = n_superset.split();
     if let Some(ref a_l) = k_l {
-        if let Comparison::R = comparator.pick_smaller(a_l.as_ref(), k_super.as_ref()) {
+        if let Comparison::R = comparator.pick_smaller(a_l, &k_super) {
             return t_subset_of_t(comparator, n_subset.to_tree(), t_superr, k_l, k_r);
         }
     }
     if let Some(ref a_r) = k_r {
-        if let Comparison::L = comparator.pick_smaller(a_r.as_ref(), k_super.as_ref()) {
+        if let Comparison::L = comparator.pick_smaller(a_r, &k_super) {
             return t_subset_of_t(comparator, n_subset.to_tree(), t_superl, k_l, k_r);
         }
     }
@@ -127,12 +124,12 @@ pub fn n_subset_of_n<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
     .test()
 }
 
-pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
+pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     r_subset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
     r_superset: Rc<dyn TraversibleBinaryReference<'a, T, A, D>>,
-    k_l: Option<Rc<A>>,
-    k_r: Option<Rc<A>>,
+    k_l: Option<A>,
+    k_r: Option<A>,
 ) -> T::F<()> {
     T::bind2(
         r_subset.resolve(),
@@ -141,12 +138,12 @@ pub fn r_subset_of_r<'a, T: MonadFail<'a, ()>, A: 'a, D: 'a + PartialEq>(
     )
 }
 
-pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A, D: 'a + PartialEq>(
+pub fn t_subset_of_t<'a, T: MonadFail<'a, ()>, A: 'a + Clone, D: 'a + PartialEq>(
     comparator: &'a dyn Comparator<A>,
     t_subset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
     t_superset: Rc<dyn TraversibleBinaryTree<'a, T, A, D>>,
-    k_l: Option<Rc<A>>,
-    k_r: Option<Rc<A>>,
+    k_l: Option<A>,
+    k_r: Option<A>,
 ) -> T::F<()> {
     match (t_subset.refer(), t_superset.refer()) {
         (None, _) => T::pure(()),
diff --git a/src/flow/traversible/unbalanced.rs b/src/flow/traversible/unbalanced.rs
index a68e37c..ddac66f 100644
--- a/src/flow/traversible/unbalanced.rs
+++ b/src/flow/traversible/unbalanced.rs
@@ -24,7 +24,7 @@ impl PartialEq for UnbalancedData {
 pub struct UnbalancedNode<'a, T: Monad<'a>, A: 'a> {
     cl: Rc<UnbalancedTree<'a, T, A>>,
     cr: Rc<UnbalancedTree<'a, T, A>>,
-    key: Rc<A>,
+    key: A,
 }
 
 pub type UnbalancedResolution<'a, T, A> = Wrap<'a, Rc<UnbalancedNode<'a, T, A>>, T>;
@@ -76,7 +76,7 @@ impl<'a, A: 'a + Display> Display
     }
 }
 
-impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryNode<'a, T, A, UnbalancedData>
+impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryNode<'a, T, A, UnbalancedData>
     for UnbalancedNode<'a, T, A>
 {
     fn split(&self) -> Split<'a, T, A, UnbalancedData> {
@@ -90,7 +90,7 @@ impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryNode<'a, T, A, UnbalancedData>
     }
 }
 
-impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryReference<'a, T, A, UnbalancedData>
+impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryReference<'a, T, A, UnbalancedData>
     for UnbalancedReference<'a, T, A>
 {
     fn resolve(&self) -> Wrap<'a, Rc<dyn TraversibleBinaryNode<'a, T, A, UnbalancedData>>, T> {
@@ -104,7 +104,7 @@ impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryReference<'a, T, A, UnbalancedDat
     }
 }
 
-impl<'a, T: Monad<'a>, A: 'a> TraversibleBinaryTree<'a, T, A, UnbalancedData>
+impl<'a, T: Monad<'a>, A: 'a + Clone> TraversibleBinaryTree<'a, T, A, UnbalancedData>
     for UnbalancedTree<'a, T, A>
 {
     fn refer(&self) -> Option<Rc<dyn TraversibleBinaryReference<'a, T, A, UnbalancedData>>> {
@@ -138,11 +138,7 @@ impl<'a, T: Monad<'a>, A: 'a> UnbalancedConstructor<'a, T, A> {
         key: A,
         cr: Rc<UnbalancedTree<'a, T, A>>,
     ) -> Rc<UnbalancedTree<'a, T, A>> {
-        let node = Rc::new(UnbalancedNode {
-            cl,
-            cr,
-            key: key.into(),
-        });
+        let node = Rc::new(UnbalancedNode { cl, cr, key });
         let ctr = self.clone();
         UnbalancedTree::Node(Rc::new(UnbalancedReference((ctr.wrap)(node)))).into()
     }