     @warn_unused_result
     public func subtree(from start: Key, to end: Key) -> BTree<Key, Payload> {
         precondition(start <= end)
-        var result = self
-        result.withCursorAt(start, choosing: .First) { cursor in
-            cursor.removeAllBefore(includingCurrent: false)
-            cursor.move(to: end, choosing: .First)
-            cursor.removeAllAfter(includingCurrent: !cursor.isAtEnd)
-        }
-        return result
+        return suffixFrom(start).prefixUpTo(end)
     }
 
     /// Return a submap consisting of all elements with keys greater than or equal to `start` but less than or equal to `end`.

        if positions.count == 0 {
            return BTree(order: order)
        }
        if positions.count == 1 {
            var result = BTree(order: order)
            result.insert(elementAtPosition(positions.startIndex))
            return result
        }
        var result = self
        result.withCursorAtPosition(positions.startIndex) { cursor in
            cursor.removeAllBefore(includingCurrent: false)
            cursor.move(toPosition: positions.count)
            cursor.removeAllAfter(includingCurrent: !cursor.isAtEnd)
        }
        return result
    }

    /// Return a subtree consisting of all elements with keys greater than or equal to `start` but less than `end`.

    public func subtree(with range: Range<Index>) -> BTree<Key, Payload> {
        range.startIndex.state.expectRoot(root)
        range.endIndex.state.expectRoot(root)
        let start = range.startIndex.state.position
        let end = range.endIndex.state.position
        precondition(0 <= start && start <= end && end <= self.count)
        if start == end {
            return BTree(order: self.order)
        }
        if start == 0 {
            return prefixUpTo(range.endIndex)
        }
        return suffixFrom(range.startIndex).prefix(end - start)
    }

    /// Return a subtree consisting of elements in the specified range of positions.
