diff --git a/src/flow/binary.rs b/src/flow/binary.rs
index 5990678..f971dea 100644
--- a/src/flow/binary.rs
+++ b/src/flow/binary.rs
@@ -177,12 +177,13 @@ pub trait BinaryTreesAvl<'a>: BinaryTrees<'a> {
     ) -> BTWrap<'a, Self, Self::Node>;
 
     fn join_key_balanced_tree(
-        self,
+        &self,
         tl: Self::Tree,
         key: KeyRc<'a, Self>,
         tr: Self::Tree,
     ) -> BTWrap<'a, Self, Self::Tree> {
-        self.clone().tree_bind(self.join_key_balanced(tl, key, tr))
+        self.clone()
+            .tree_bind(self.clone().join_key_balanced(tl, key, tr))
     }
 
     fn join_key_balanced(
@@ -201,13 +202,13 @@ pub trait BinaryTreesAvl<'a>: BinaryTrees<'a> {
                     Self::bind(self.assume_node(&trl), move |nrl| {
                         let (trll, trlr, krl) = self.split(&nrl);
                         Self::T::bind2(
-                            self.clone().join_key_balanced_tree(tl, key, trll),
-                            self.clone().join_key_balanced_tree(trlr, kr, trr),
+                            self.join_key_balanced_tree(tl, key, trll),
+                            self.join_key_balanced_tree(trlr, kr, trr),
                             |ti, to| self.join_key_balanced(ti, krl, to),
                         )
                     })
                 } else {
-                    Self::bind(self.clone().join_key_balanced_tree(tl, key, trl), |t| {
+                    Self::bind(self.join_key_balanced_tree(tl, key, trl), |t| {
                         self.join_key_balanced(t, kr, trr)
                     })
                 }
@@ -219,13 +220,13 @@ pub trait BinaryTreesAvl<'a>: BinaryTrees<'a> {
                     Self::bind(self.assume_node(&tlr), move |nlr| {
                         let (tlrl, tlrr, klr) = self.split(&nlr);
                         Self::T::bind2(
-                            self.clone().join_key_balanced_tree(tll, kl, tlrl),
-                            self.clone().join_key_balanced_tree(tlrr, key, tr),
+                            self.join_key_balanced_tree(tll, kl, tlrl),
+                            self.join_key_balanced_tree(tlrr, key, tr),
                             |to, ti| self.join_key_balanced(to, klr, ti),
                         )
                     })
                 } else {
-                    Self::bind(self.clone().join_key_balanced_tree(tlr, key, tr), |t| {
+                    Self::bind(self.join_key_balanced_tree(tlr, key, tr), |t| {
                         self.join_key_balanced(tll, kl, t)
                     })
                 }