             return node
         }
         
-        /// Pushes up the right-side sibling, or its descendants when the evaluation closure
-        /// returns `true`.  Bails
-        ///
-        private func pushUp<T: Node>(siblingOrDescendantAtRightSideOf childIndex: Int, evaluatedBy evaluation: (T -> Bool), bailIf shouldBail: (T -> Bool) = { _ in return false }) -> T? {
+        /// Evaluates the right sibling for a certain condition.  If the condition is met, the
+        /// sibling is returned.  Otherwise this method looks amongst the sibling's left-side
+        /// descendants for any node returning `true` at the evaluation closure.
+        ///
+        /// The search bails if the bail closure returns `true` for either the sibling or its
+        /// descendants before a matching node is found.
+        ///
+        /// When a match is found, it's pushed up to the level of the receiver.
+        ///
+        /// - Parameters:
+        ///     - childIndex: the index of the child to find the sibling of.
+        ///     - evaluation: the closure that will evaluate the nodes for a matching result.
+        ///     - bail: the closure to evaluate if the search must bail.
+        ///
+        /// - Returns: The requested node, if one is found, or `nil`.
+        ///
+        private func pushUp<T: Node>(siblingOrDescendantAtRightSideOf childIndex: Int, evaluatedBy evaluation: (T -> Bool), bailIf bail: (T -> Bool) = { _ in return false }) -> T? {
             
             guard let theSibling: T = sibling(rightOf: childIndex)
-                where !shouldBail(theSibling) else {
+                where !bail(theSibling) else {
                     return nil
             }
             

        /// - Parameters:
        ///     - evaluate: the closure to evaluate the candidate.  `true` means we have a good
        ///             candidate.
        ///
        /// - Returns: the matching element, if any was found, or `nil`.
        ///
        @warn_unused_result
        private func find<T: Node>(rightSideDescendantEvaluatedBy evaluate: (T -> Bool), bailIf shouldBail: (T -> Bool) = { _ in return false }) -> T? {
            
            guard children.count > 0 else {
                return nil

            
            let child = children[0]
            
            if let match = child as? T where !bail(match) && evaluate(match) {
                return match
            } else if let element = child as? ElementNode {
                return element.find(leftSideDescendantEvaluatedBy: evaluate, bailIf: bail)
            } else {
                return nil
            }
