1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
/*
This source file is part of the Swift.org open source project
Copyright (c) 2022 Apple Inc. and the Swift project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
See https://swift.org/CONTRIBUTORS.txt for Swift project authors
*/
import Foundation
/// A sequence that groups its elements to optimize accesses.
///
/// You use a grouped sequence when you need efficient access to its elements via a grouping mechanism of your
/// choosing and you aren't concerned with the order of the elements in the sequence.
///
/// ```swift
/// var groupedSequence = GroupedSequence<Int, String> { $0.count }
/// groupedSequence.append("a")
/// groupedSequence.append(contentsOf: ["aa", "aaa"])
///
/// print(groupedSequence[1])
/// // Prints ["a"]
///
/// print(groupedSequence[2])
/// // Prints ["aa"]
/// ```
///
/// You can iterate through a grouped sequence's unordered elements.
///
/// ```swift
/// for item in groupedSequence {
/// print(item)
/// }
///
/// // Prints "aa"
/// // Prints "a"
/// // Prints "aaa"
/// ```
struct GroupedSequence<Key: Hashable, Element>: Sequence, CustomStringConvertible {
fileprivate var storage = [Key: Element]()
/// A closure that transforms an element into its key.
private var deriveKey: (Element) -> Key
var description: String {
storage.values.description
}
/// Creates an empty grouped sequence.
init(deriveKey: @escaping (Element) -> Key) {
self.deriveKey = deriveKey
}
/// Adds an element to the group sequence.
///
/// If an element with the same derived key was appended before, it will be replaced with the new element.
mutating func append(_ element: Element) {
storage[deriveKey(element)] = element
}
/// Adds the contents of a sequence to the group sequence.
///
/// Existing elements with the same derived key will be replaced with the new element.
mutating func append(contentsOf newElements: some Sequence<Element>) {
for element in newElements {
append(element)
}
}
/// Accesses the member using the given key.
subscript(key: Key) -> Element? {
get {
storage[key]
}
}
/// Returns an iterator over the members of the sequence.
func makeIterator() -> some IteratorProtocol<Element> {
storage.values.makeIterator()
}
}
extension Array {
/// Creates an array given a grouped sequence.
init<Key>(_ groupedSequence: GroupedSequence<Key, Element>) {
self = Array(groupedSequence.storage.values)
}
}
|
