         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 dropFirst(positions.startIndex).prefix(positions.count)
     }
 
     /// 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)
        if range.startIndex == range.endIndex {
            return BTree(order: self.order)
        }
        let end = self.positionOfIndex(range.endIndex)
        var result = self
        result.withCursorAt(range.startIndex) { cursor in
            let start = cursor.position
            cursor.removeAllBefore(includingCurrent: false)
            cursor.move(toPosition: end - start)
            cursor.removeAllAfter(includingCurrent: !cursor.isAtEnd)
        }
        return result
    }

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

    @warn_unused_result
    public func subtree(from start: Key, to end: Key) -> BTree<Key, Payload> {
        precondition(start <= end)
        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`.
