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

                return theSibling
            }
            
            return pushUp(leftSideDescendantEvaluatedBy: evaluation, bailIf: shouldBail)
        }
        
        ///  Pushes up to the level of the receiver and right-side descendant that evaluates
        /// to `true`.
        ///
        /// - Parameters:
        ///     - evaluationClosure: the closure that will be used to evaluate all descendants.
        ///
        /// - Returns: if any matching descendant is found, this method will return the requested
        ///         node after being pushed all the way up, or `nil` if no matching descendant is
        ///         found.
        ///
        func pushUp<T: Node>(rightSideDescendantEvaluatedBy evaluationClosure: (T -> Bool), bailIf shouldBail: (T -> Bool) = { _ in return false }) -> T? {
            
            guard let node = find(rightSideDescendantEvaluatedBy: evaluationClosure, bailIf: shouldBail) else {
                return nil
            }
            

            return result
        }
        
        /// 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 !bail(theSibling) else {
                return nil
            }
            
