             return result
         }
         
-        private func pushUp<T: Node>(siblingOrDescendantAtLeftSideOf childIndex: Int, evaluatedBy evaluation: (T -> Bool), bailIf shouldBail: (T -> Bool) = { _ in return false }) -> T? {
+        /// Evaluates the left sibling for a certain condition.  If the condition is met, the
+        /// sibling is returned.  Otherwise this method looks amongst the sibling's right-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>(siblingOrDescendantAtLeftSideOf childIndex: Int, evaluatedBy evaluation: (T -> Bool), bailIf bail: (T -> Bool) = { _ in return false }) -> T? {
             
             guard let theSibling: T = sibling(leftOf: childIndex)
-                where !shouldBail(theSibling) else {
+                where !bail(theSibling) else {
                 return nil
             }
             

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

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