Use Sequence.Element rather than Sequence.Iterator.Element

Author: lorentey

Sources/BTreeBuilder.swift

@@ -17,7 +17,7 @@ extension BTree {
     /// - Complexity: O(count * log(`count`))
     /// - SeeAlso: `init(sortedElements:order:fillFactor:)` for a (faster) variant that can be used if the sequence is already sorted.
     public init<S: Sequence>(_ elements: S, dropDuplicates: Bool = false, order: Int? = nil)
-        where S.Iterator.Element == Element {
+        where S.Element == Element {
         let order = order ?? Node.defaultOrder
         self.init(Node(order: order))
         withCursorAtEnd { cursor in
@@ -47,7 +47,7 @@ extension BTree {
     ///      If not specified, a value of 1.0 is used, i.e., nodes will be loaded with as many elements as possible.
     /// - Complexity: O(count)
     /// - SeeAlso: `init(elements:order:fillFactor:)` for a (slower) unsorted variant.
-    public init<S: Sequence>(sortedElements elements: S, dropDuplicates: Bool = false, order: Int? = nil, fillFactor: Double = 1) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sortedElements elements: S, dropDuplicates: Bool = false, order: Int? = nil, fillFactor: Double = 1) where S.Element == Element {
         var iterator = elements.makeIterator()
         self.init(order: order ?? Node.defaultOrder, fillFactor: fillFactor, dropDuplicates: dropDuplicates, next: { iterator.next() })
     }

Sources/BTreeCursor.swift

@@ -500,7 +500,7 @@ public final class BTreeCursor<Key: Comparable, Value> {
     ///
     /// - Requires: `self.isValid` and `elements` is sorted by key.
     /// - Complexity: O(log(`count`) + *c*), where *c* is the number of elements in the sequence.
-    public func insert<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    public func insert<S: Sequence>(_ elements: S) where S.Element == Element {
         insertWithoutCloning(BTree(sortedElements: elements).root)
     }
 

Sources/BTreeMerger.swift

@@ -209,7 +209,7 @@ extension BTree {
     ///
     /// - Requires: `sortedKeys` is sorted in ascending order.
     /// - Complexity: O(*n* + `self.count`), where *n* is the number of keys in `sortedKeys`.
-    public func subtracting<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchingStrategy) -> BTree where S.Iterator.Element == Key {
+    public func subtracting<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchingStrategy) -> BTree where S.Element == Key {
         if self.isEmpty { return self }
 
         var b = BTreeBuilder<Key, Value>(order: self.order)
@@ -251,7 +251,7 @@ extension BTree {
     ///
     /// - Requires: `sortedKeys` is sorted in ascending order.
     /// - Complexity: O(*n* + `self.count`), where *n* is the number of keys in `sortedKeys`.
-    public func intersection<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchingStrategy) -> BTree where S.Iterator.Element == Key {
+    public func intersection<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchingStrategy) -> BTree where S.Element == Key {
         if self.isEmpty { return self }
 
         var b = BTreeBuilder<Key, Value>(order: self.order)

Sources/BTreeNode.swift

@@ -27,6 +27,7 @@ internal let bTreeNodeSize = 16383
 /// A node in an in-memory B-tree data structure, efficiently mapping `Comparable` keys to arbitrary values.
 /// Iterating over the elements in a B-tree returns them in ascending order of their keys.
 internal final class BTreeNode<Key: Comparable, Value> {
+    typealias Iterator = BTreeIterator<Key, Value>
     typealias Element = Iterator.Element
     typealias Node = BTreeNode<Key, Value>
 
@@ -131,8 +132,6 @@ extension BTreeNode {
 //MARK: Sequence
 
 extension BTreeNode: Sequence {
-    typealias Iterator = BTreeIterator<Key, Value>
-
     var isEmpty: Bool { return count == 0 }
 
     func makeIterator() -> Iterator {

Sources/List.swift

@@ -47,7 +47,7 @@ extension List {
     /// Initialize a new list from the given elements.
     ///
     /// - Complexity: O(*n*) where *n* is the number of elements in the sequence.
-    public init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(_ elements: S) where S.Element == Element {
         self.init(Tree(sortedElements: elements.lazy.map { (EmptyKey(), $0) }))
     }
 }
@@ -235,8 +235,8 @@ extension List {
     /// Return an `Array` containing the concatenated results of mapping `transform` over `self`.
     ///
     /// - Complexity: O(`result.count`)
-    public func flatMap<S: Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Iterator.Element] {
-        var result: [S.Iterator.Element] = []
+    public func flatMap<S: Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Element] {
+        var result: [S.Element] = []
         try self.forEach { element in
             result.append(contentsOf: try transform(element))
         }
@@ -398,7 +398,7 @@ extension List {
     /// Append the contents of `elements` to the end of this list.
     ///
     /// - Complexity: O(log(`count`) + *n*) where *n* is the number of elements in the sequence.
-    public mutating func append<S: Sequence>(contentsOf elements: S) where S.Iterator.Element == Element {
+    public mutating func append<S: Sequence>(contentsOf elements: S) where S.Element == Element {
         if let list = elements as? List<Element> {
             append(contentsOf: list)
             return
@@ -420,7 +420,7 @@ extension List {
     /// Insert the contents of `elements` into this list starting at `index`.
     ///
     /// - Complexity: O(log(`self.count`) + *n*) where *n* is the number of elements inserted.
-    public mutating func insert<S: Sequence>(contentsOf elements: S, at index: Int) where S.Iterator.Element == Element {
+    public mutating func insert<S: Sequence>(contentsOf elements: S, at index: Int) where S.Element == Element {
         if let list = elements as? List<Element> {
             insert(contentsOf: list, at: index)
             return
@@ -534,7 +534,7 @@ extension List: RangeReplaceableCollection {
     /// Replace elements in `range` with `elements`.
     ///
     /// - Complexity: O(log(`count`) + `max(range.count, elements.count)`)
-    public mutating func replaceSubrange<C: Collection>(_ range: Range<Int>, with elements: C) where C.Iterator.Element == Element {
+    public mutating func replaceSubrange<C: Collection>(_ range: Range<Int>, with elements: C) where C.Element == Element {
         precondition(range.lowerBound >= 0 && range.upperBound <= count)
         if let list = elements as? List<Element> {
             replaceSubrange(range, with: list)

Sources/Map.swift

@@ -53,7 +53,7 @@ extension Map {
     /// If the sequence contains elements with duplicate keys, only the last element is kept in the map.
     ///
     /// - Complexity: O(*n* * log(*n*)) where *n* is the number of items in `elements`.
-    public init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(_ elements: S) where S.Element == Element {
         self.tree = Tree(elements, dropDuplicates: true)
     }
 
@@ -62,7 +62,7 @@ extension Map {
     /// If the sequence contains elements with duplicate keys, only the last element is kept in the map.
     ///
     /// - Complexity: O(*n*) where *n* is the number of items in `elements`.
-    public init<S: Sequence>(sortedElements elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sortedElements elements: S) where S.Element == Element {
         self.tree = Tree(sortedElements: elements, dropDuplicates: true)
     }
 }
@@ -258,8 +258,8 @@ extension Map {
     /// Return an `Array` containing the concatenated results of mapping `transform` over `self`.
     ///
     /// - Complexity: O(`count`)
-    public func flatMap<S: Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Iterator.Element] {
-        var result: [S.Iterator.Element] = []
+    public func flatMap<S: Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Element] {
+        var result: [S.Element] = []
         try self.forEach { element in
             result.append(contentsOf: try transform(element))
         }
@@ -546,7 +546,7 @@ extension Map {
     /// Return a map that contains all elements in `self` whose keys are in `keys`.
     ///
     /// - Complexity: O(*n* * log(`count`)) where *n* is the number of keys in `keys`.
-    public func including<S: Sequence>(_ keys: S) -> Map where S.Iterator.Element == Key {
+    public func including<S: Sequence>(_ keys: S) -> Map where S.Element == Key {
         return including(SortedSet(keys))
     }
 
@@ -560,7 +560,7 @@ extension Map {
     /// Return a map that contains all elements in `self` whose keys are not in `keys`.
     ///
     /// - Complexity: O(*n* * log(`count`)) where *n* is the number of keys in `keys`.
-    public func excluding<S: Sequence>(_ keys: S) -> Map where S.Iterator.Element == Key {
+    public func excluding<S: Sequence>(_ keys: S) -> Map where S.Element == Key {
         return excluding(SortedSet(keys))
     }
 }

Sources/SortedBag.swift

@@ -53,15 +53,15 @@ extension SortedBag {
     /// If the sequence contains duplicate items, all of them are kept, in the same order.
     ///
     /// - Complexity: O(*n* * log(*n*)), where *n* is the number of items in the sequence.
-    public init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(_ elements: S) where S.Element == Element {
         self.init(Tree(sortedElements: elements.sorted().lazy.map { ($0, ()) }, dropDuplicates: false))
     }
 
     /// Create a bag from a sorted finite sequence of items.
     /// If the sequence contains duplicate items, all of them are kept.
     ///
     /// - Complexity: O(*n*), where *n* is the number of items in the sequence.
-    public init<S: Sequence>(sortedElements elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sortedElements elements: S) where S.Element == Element {
         self.init(Tree(sortedElements: elements.lazy.map { ($0, ()) }, dropDuplicates: false))
     }
 
@@ -256,7 +256,7 @@ extension SortedBag {
     }
 
     /// Return an `Array` containing the concatenated results of mapping `transform` over `self`.
-    public func flatMap<S : Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Iterator.Element] {
+    public func flatMap<S : Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Element] {
         return try tree.flatMap { try transform($0.0) }
     }
 

Sources/SortedSet.swift

@@ -42,15 +42,15 @@ extension SortedSet {
     /// If the sequence contains duplicate items, only the last instance will be kept in the set.
     ///
     /// - Complexity: O(*n* * log(*n*)), where *n* is the number of items in the sequence.
-    public init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(_ elements: S) where S.Element == Element {
         self.init(Tree(sortedElements: elements.sorted().lazy.map { ($0, ()) }, dropDuplicates: true))
     }
 
     /// Create a set from a sorted finite sequence of items.
     /// If the sequence contains duplicate items, only the last instance will be kept in the set.
     ///
     /// - Complexity: O(*n*), where *n* is the number of items in the sequence.
-    public init<S: Sequence>(sortedElements elements: S) where S.Iterator.Element == Element {
+    public init<S: Sequence>(sortedElements elements: S) where S.Element == Element {
         self.init(Tree(sortedElements: elements.lazy.map { ($0, ()) }, dropDuplicates: true))
     }
 
@@ -245,7 +245,7 @@ extension SortedSet {
     }
 
     /// Return an `Array` containing the concatenated results of mapping `transform` over `self`.
-    public func flatMap<S : Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Iterator.Element] {
+    public func flatMap<S : Sequence>(_ transform: (Element) throws -> S) rethrows -> [S.Element] {
         return try tree.flatMap { try transform($0.0) }
     }
 

Tests/BTreeTests/BTreeBuilderTests.swift

@@ -15,7 +15,7 @@ class BTreeBuilderTests: XCTestCase {
     typealias Tree = BTree<Int, String>
     typealias Element = (Int, String)
 
-    func elements<S: Sequence>(_ range: S) -> [Element] where S.Iterator.Element == Int {
+    func elements<S: Sequence>(_ range: S) -> [Element] where S.Element == Int {
         return range.map { ($0, String($0)) }
     }
 

Tests/BTreeTests/BTreeComparisonTests.swift

@@ -14,7 +14,7 @@ private typealias Node = BTreeNode<Int, Void>
 private typealias Tree = BTree<Int, Void>
 private typealias Element = (Int, Void)
 
-private func makeTree<S: Sequence>(_ s: S, order: Int = 5, keysPerNode: Int? = nil) -> Tree where S.Iterator.Element == Int {
+private func makeTree<S: Sequence>(_ s: S, order: Int = 5, keysPerNode: Int? = nil) -> Tree where S.Element == Int {
     var b = Builder(order: order, keysPerNode: keysPerNode ?? order - 1)
     for i in s {
         b.append((i, ()))

Tests/BTreeTests/BTreeMergeTests.swift

@@ -23,7 +23,7 @@ class BTreeMergeTests: XCTestCase {
         return Tree(order: 5)
     }
 
-    func makeTree<S: Sequence>(_ s: S, order: Int = 5, keysPerNode: Int? = nil) -> Tree where S.Iterator.Element == Int {
+    func makeTree<S: Sequence>(_ s: S, order: Int = 5, keysPerNode: Int? = nil) -> Tree where S.Element == Int {
         var b = Builder(order: order, keysPerNode: keysPerNode ?? order - 1)
         for i in s.sorted() {
             b.append((i, ()))

Tests/BTreeTests/BTreeNodeTests.swift

@@ -440,7 +440,7 @@ class BTreeNodeTests: XCTestCase {
             let tree = BTree<Int, String>(order: 5)
             return tree.root
         }
-        func createNode<S: Sequence>(_ keys: S) -> Node where S.Iterator.Element == Int {
+        func createNode<S: Sequence>(_ keys: S) -> Node where S.Element == Int {
             let elements = keys.map { ($0, String($0)) }
             let tree = BTree(sortedElements: elements, order: 5)
             return tree.root

Tests/BTreeTests/BTreeTestSupport.swift

@@ -272,7 +272,7 @@ struct DictionaryBag<Element: Hashable>: Collection {
 
     init() {}
 
-    init<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    init<S: Sequence>(_ elements: S) where S.Element == Element {
         self.init()
         self.formUnion(elements)
     }
@@ -319,13 +319,13 @@ struct DictionaryBag<Element: Hashable>: Collection {
         }
     }
 
-    mutating func subtract<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    mutating func subtract<S: Sequence>(_ elements: S) where S.Element == Element {
         for element in elements {
             self.remove(element)
         }
     }
 
-    mutating func subtractAll<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    mutating func subtractAll<S: Sequence>(_ elements: S) where S.Element == Element {
         for element in elements {
             if let c = bag[element] {
                 bag[element] = nil
@@ -334,25 +334,25 @@ struct DictionaryBag<Element: Hashable>: Collection {
         }
     }
 
-    func subtracting<S: Sequence>(_ elements: S) -> DictionaryBag where S.Iterator.Element == Element {
+    func subtracting<S: Sequence>(_ elements: S) -> DictionaryBag where S.Element == Element {
         var bag = self
         bag.subtract(elements)
         return bag
     }
 
-    func subtractingAll<S: Sequence>(_ elements: S) -> DictionaryBag where S.Iterator.Element == Element {
+    func subtractingAll<S: Sequence>(_ elements: S) -> DictionaryBag where S.Element == Element {
         var bag = self
         bag.subtractAll(elements)
         return bag
     }
 
-    mutating func formUnion<S: Sequence>(_ elements: S) where S.Iterator.Element == Element {
+    mutating func formUnion<S: Sequence>(_ elements: S) where S.Element == Element {
         for element in elements {
             self.insert(element)
         }
     }
 
-    func union<S: Sequence>(_ elements: S) -> DictionaryBag where S.Iterator.Element == Element {
+    func union<S: Sequence>(_ elements: S) -> DictionaryBag where S.Element == Element {
         var bag = self
         bag.formUnion(elements)
         return bag

Tests/BTreeTests/ListTests.swift

@@ -282,7 +282,7 @@ class ListTests: XCTestCase {
         assertEqualElements(l1, 0..<10)
 
         let l3: List<Int> = [10, 11, 12, 13, 14]
-        func appendAsSequence<E, S: Sequence>(_ list: inout List<E>, _ elements: S) where S.Iterator.Element == E {
+        func appendAsSequence<E, S: Sequence>(_ list: inout List<E>, _ elements: S) where S.Element == E {
             list.append(contentsOf: elements)
         }
         appendAsSequence(&l1, l3)
@@ -311,7 +311,7 @@ class ListTests: XCTestCase {
         assertEqualElements(list, 0..<5)
 
         var copy = list
-        func insertAsSequence<E, S: Sequence>(_ list: inout List<E>, _ elements: S, at index: Int) where S.Iterator.Element == E {
+        func insertAsSequence<E, S: Sequence>(_ list: inout List<E>, _ elements: S, at index: Int) where S.Element == E {
             list.insert(contentsOf: elements, at: index)
         }
         insertAsSequence(&copy, l, at: copy.count)
@@ -439,7 +439,7 @@ class ListTests: XCTestCase {
         list.replaceSubrange(1..<3, with: [50, 51, 52, 53, 54, 55])
         assertEqualElements(list, [0, 50, 51, 52, 53, 54, 55, 20, 30, 8, 9])
 
-        func replaceAsSequence<E, C: Collection>(_ list: inout List<E>, range: CountableRange<Int>, with elements: C) where C.Iterator.Element == E {
+        func replaceAsSequence<E, C: Collection>(_ list: inout List<E>, range: CountableRange<Int>, with elements: C) where C.Element == E {
             list.replaceSubrange(range, with: elements)
         }
         replaceAsSequence(&list, range: 1 ..< 9, with: List(1 ..< 8))

Tests/BTreeTests/XCTest extensions.swift

@@ -11,23 +11,23 @@ import Foundation
 import XCTest
 @testable import BTree
 
-func assertEqualElements<Element: Equatable, S1: Sequence, S2: Sequence>(_ a: S1, _ b: S2, file: StaticString = #file, line: UInt = #line) where S1.Iterator.Element == Element, S2.Iterator.Element == Element {
+func assertEqualElements<Element: Equatable, S1: Sequence, S2: Sequence>(_ a: S1, _ b: S2, file: StaticString = #file, line: UInt = #line) where S1.Element == Element, S2.Element == Element {
     let aa = Array(a)
     let ba = Array(b)
     if !aa.elementsEqual(ba) {
         XCTFail("XCTAssertEqual failed: \"\(aa)\" is not equal to \"\(ba)\"", file: file, line: line)
     }
 }
 
-func assertEqualElements<T1: Equatable, T2: Equatable, S1: Sequence, S2: Sequence>(_ a: S1, _ b: S2, file: StaticString = #file, line: UInt = #line) where S1.Iterator.Element == (T1, T2), S2.Iterator.Element == (T1, T2) {
+func assertEqualElements<T1: Equatable, T2: Equatable, S1: Sequence, S2: Sequence>(_ a: S1, _ b: S2, file: StaticString = #file, line: UInt = #line) where S1.Element == (T1, T2), S2.Element == (T1, T2) {
     let aa = Array(a)
     let ba = Array(b)
     if !aa.elementsEqual(ba, by: { a, b in a.0 == b.0 && a.1 == b.1 }) {
         XCTFail("XCTAssertEqual failed: \"\(aa)\" is not equal to \"\(ba)\"", file: file, line: line)
     }
 }
 
-func assertEqualElements<Element: Equatable, S1: Sequence, S2: Sequence, S1W: Sequence, S2W: Sequence>(_ a: S1, _ b: S2, element: Element.Type = Element.self, file: StaticString = #file, line: UInt = #line) where S1.Iterator.Element == S1W, S2.Iterator.Element == S2W, S1W.Iterator.Element == Element, S2W.Iterator.Element == Element {
+func assertEqualElements<Element: Equatable, S1: Sequence, S2: Sequence, S1W: Sequence, S2W: Sequence>(_ a: S1, _ b: S2, element: Element.Type = Element.self, file: StaticString = #file, line: UInt = #line) where S1.Element == S1W, S2.Element == S2W, S1W.Element == Element, S2W.Element == Element {
     let aa = a.map { Array($0) }
     let ba = b.map { Array($0) }
     if !aa.elementsEqual(ba, by: { $0.elementsEqual($1) }) {
@@ -41,14 +41,14 @@ extension BTree {
         assertEqualElements(self.map { $0.0 }, other.map { $0.0 }, file: file, line: line)
     }
 
-    internal func assertKeysEqual<S: Sequence>(_ s: S, file: StaticString = #file, line: UInt = #line) where S.Iterator.Element == Key {
+    internal func assertKeysEqual<S: Sequence>(_ s: S, file: StaticString = #file, line: UInt = #line) where S.Element == Key {
         assertEqualElements(self.map { $0.0 }, s, file: file, line: line)
     }
 }
 
 internal extension Sequence {
-    func repeatEach(_ count: Int) -> Array<Iterator.Element> {
-        var result: [Iterator.Element] = []
+    func repeatEach(_ count: Int) -> Array<Element> {
+        var result: [Element] = []
         result.reserveCapacity(count * underestimatedCount)
         for element in self {
             for _ in 0 ..< count {