mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2327673b0e | ||
|
|
4b779b8b3b | ||
|
|
0e2941ef50 | ||
|
|
e25cf27e57 | ||
|
|
3484ac31f6 | ||
|
|
f9f3a5ccc4 | ||
|
|
4038b5da40 | ||
|
|
65ef6cb966 | ||
|
|
0f27d99c89 | ||
|
|
66a56e36e7 | ||
|
|
9901a50b03 | ||
|
|
061501a712 | ||
|
|
dbc48be5dd | ||
|
|
04d91803a2 |
No files matched your search
@@ -17,5 +17,5 @@ Replace this paragraph with a description of your changes and rationale. Provide
|
||||
### Checklist
|
||||
- [ ] I've added at least one test that validates that my change is working, if appropriate
|
||||
- [ ] I've followed the code style of the rest of the project
|
||||
- [ ] I've read the [Contribution Guidelines](../CONTRIBUTING.md)
|
||||
- [ ] I've read the [Contribution Guidelines](../blob/main/CONTRIBUTING.md)
|
||||
- [ ] I've updated the documentation if necessary
|
||||
@@ -34,5 +34,5 @@ What is the impact of this change on existing users? Does it deprecate or remove
|
||||
### Checklist
|
||||
- [ ] I've added at least one test that validates that my change is working, if appropriate
|
||||
- [ ] I've followed the code style of the rest of the project
|
||||
- [ ] I've read the [Contribution Guidelines](../../CONTRIBUTING.md)
|
||||
- [ ] I've read the [Contribution Guidelines](../../blob/main/CONTRIBUTING.md)
|
||||
- [ ] I've updated the documentation if necessary
|
||||
+70
-2
@@ -12,10 +12,67 @@ package updates, you can specify your package dependency using
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
*No changes yet.*
|
||||
*No new changes.*
|
||||
|
||||
---
|
||||
|
||||
## [0.2.1] - 2021-06-01
|
||||
|
||||
### Additions
|
||||
|
||||
Expanded versatility for two existing operations:
|
||||
|
||||
- A series of `joined(by:)` overloads concatenate a sequence of sequences using
|
||||
an element or a collection, either passed in or generated from consecutive
|
||||
elements via a closure. ([#138])
|
||||
- Additional `trimming(while:)` methods for trimming only the start or end of a
|
||||
collection, as well as mutating versions of all three variants. ([#104])
|
||||
|
||||
The 0.2.1 release includes contributions from [fedeci] and [timvermeulen].
|
||||
Thank you!
|
||||
|
||||
## [0.2.0] - 2021-05-17
|
||||
|
||||
### Additions
|
||||
|
||||
Two new additions to the list of algorithms:
|
||||
|
||||
- `adjacentPairs()` lazily iterates over tuples of adjacent elements of a
|
||||
sequence. ([#119])
|
||||
- `minAndMax()` finds both the smallest and largest elements of a sequence in
|
||||
a single pass. ([#90])
|
||||
|
||||
### Changes
|
||||
|
||||
- When calling `chunked(on:)`, the resulting collection has an element type of
|
||||
`(Subject, SubSequence)` instead of just `SubSequence`, making the subject
|
||||
value available when iterating.
|
||||
|
||||
```swift
|
||||
let numbers = [5, 6, -3, -9, -11, 2, 7, 6]
|
||||
for (signum, values) in numbers.chunked(on: { $0.signum() }) {
|
||||
print(signum, values)
|
||||
}
|
||||
// 1 [5, 6]
|
||||
// -1 [-3, -9, -11]
|
||||
// 1 [2, 7, 6]
|
||||
```
|
||||
|
||||
### Fixes
|
||||
|
||||
- Improvements to the documentation and PR templates.
|
||||
|
||||
The 0.2.0 release includes contributions from [CTMacUser], [LemonSpike],
|
||||
[mpangburn], and [natecook1000]. Thank you!
|
||||
|
||||
---
|
||||
|
||||
## [0.1.1] - 2021-04-14
|
||||
|
||||
### Fixes
|
||||
|
||||
- `Product2` associated type inference error in release build ([#130])
|
||||
|
||||
## [0.1.0] - 2021-04-13
|
||||
|
||||
### Additions
|
||||
@@ -149,7 +206,10 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
|
||||
<!-- Link references for releases -->
|
||||
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/0.1.0...HEAD
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/0.2.1...HEAD
|
||||
[0.2.1]: https://github.com/apple/swift-algorithms/compare/0.2.0...0.2.1
|
||||
[0.2.0]: https://github.com/apple/swift-algorithms/compare/0.1.1...0.2.0
|
||||
[0.1.1]: https://github.com/apple/swift-algorithms/compare/0.1.0...0.1.1
|
||||
[0.1.0]: https://github.com/apple/swift-algorithms/compare/0.0.4...0.1.0
|
||||
[0.0.4]: https://github.com/apple/swift-algorithms/compare/0.0.3...0.0.4
|
||||
[0.0.3]: https://github.com/apple/swift-algorithms/compare/0.0.2...0.0.3
|
||||
@@ -173,20 +233,27 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[#77]: https://github.com/apple/swift-algorithms/pull/77
|
||||
[#78]: https://github.com/apple/swift-algorithms/pull/78
|
||||
[#85]: https://github.com/apple/swift-algorithms/pull/85
|
||||
[#90]: https://github.com/apple/swift-algorithms/pull/90
|
||||
[#91]: https://github.com/apple/swift-algorithms/pull/91
|
||||
[#104]: https://github.com/apple/swift-algorithms/pull/104
|
||||
[#106]: https://github.com/apple/swift-algorithms/pull/106
|
||||
[#112]: https://github.com/apple/swift-algorithms/pull/112
|
||||
[#119]: https://github.com/apple/swift-algorithms/pull/119
|
||||
[#124]: https://github.com/apple/swift-algorithms/pull/124
|
||||
[#125]: https://github.com/apple/swift-algorithms/pull/125
|
||||
[#130]: https://github.com/apple/swift-algorithms/pull/130
|
||||
[#138]: https://github.com/apple/swift-algorithms/pull/138
|
||||
|
||||
<!-- Link references for contributors -->
|
||||
|
||||
[AustinConlon]: https://github.com/apple/swift-algorithms/commits?author=AustinConlon
|
||||
[benrimmington]: https://github.com/apple/swift-algorithms/commits?author=benrimmington
|
||||
[bjhomer]: https://github.com/apple/swift-algorithms/commits?author=bjhomer
|
||||
[CTMacUser]: https://github.com/apple/swift-algorithms/commits?author=CTMacUser
|
||||
[danielctull]: https://github.com/apple/swift-algorithms/commits?author=danielctull
|
||||
[dhruvshah8]: https://github.com/apple/swift-algorithms/commits?author=dhruvshah8
|
||||
[egorzhdan]: https://github.com/apple/swift-algorithms/commits?author=egorzhdan
|
||||
[fedeci]: https://github.com/apple/swift-algorithms/commits?author=fedeci
|
||||
[hashemi]: https://github.com/apple/swift-algorithms/commits?author=hashemi
|
||||
[IanKeen]: https://github.com/apple/swift-algorithms/commits?author=IanKeen
|
||||
[iSame7]: https://github.com/apple/swift-algorithms/commits?author=iSame7
|
||||
@@ -197,6 +264,7 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[markuswntr]: https://github.com/apple/swift-algorithms/commits?author=markuswntr
|
||||
[mdznr]: https://github.com/apple/swift-algorithms/commits?author=mdznr
|
||||
[michiboo]: https://github.com/apple/swift-algorithms/commits?author=michiboo
|
||||
[mpangburn]: https://github.com/apple/swift-algorithms/commits?author=mpangburn
|
||||
[natecook1000]: https://github.com/apple/swift-algorithms/commits?author=natecook1000
|
||||
[nordicio]: https://github.com/apple/swift-algorithms/commits?author=nordicio
|
||||
[ollieatkinson]: https://github.com/apple/swift-algorithms/commits?author=ollieatkinson
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
# AdjacentPairs
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/AdjacentPairs.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/AdjacentPairsTests.swift)]
|
||||
|
||||
Lazily iterates over tuples of adjacent elements.
|
||||
|
||||
This operation is available for any sequence by calling the `adjacentPairs()` method.
|
||||
|
||||
```swift
|
||||
let numbers = (1...5)
|
||||
let pairs = numbers.adjacentPairs()
|
||||
// Array(pairs) == [(1, 2), (2, 3), (3, 4), (4, 5)]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `adjacentPairs()` method is declared as a `Sequence` extension returning `AdjacentPairsSequence` and as a `Collection` extension returning `AdjacentPairsCollection`.
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func adjacentPairs() -> AdjacentPairsSequence<Self>
|
||||
}
|
||||
```
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func adjacentPairs() -> AdjacentPairsCollection<Self>
|
||||
}
|
||||
```
|
||||
|
||||
The `AdjacentPairsSequence` type is a sequence, and the `AdjacentPairsCollection` type is a collection with conditional conformance to `BidirectionalCollection` and `RandomAccessCollection` when the underlying collection conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling `adjacentPairs` is an O(1) operation.
|
||||
|
||||
### Naming
|
||||
|
||||
This method is named for clarity while remaining agnostic to any particular domain of programming. In natural language processing, this operation is akin to computing a list of bigrams; however, this algorithm is not specific to this use case.
|
||||
|
||||
[naming]: https://forums.swift.org/t/naming-of-chained-with/40999/
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
This function is often written as a `zip` of a sequence together with itself, minus its first element.
|
||||
|
||||
**Haskell:** This operation is spelled ``s `zip` tail s``.
|
||||
|
||||
**Python:** Python users may write `zip(s, s[1:])` for a list with at least one element. For natural language processing, the `nltk` package offers a `bigrams` function akin to this method.
|
||||
|
||||
Note that in Swift, the spelling `zip(s, s.dropFirst())` is undefined behavior for a single-pass sequence `s`.
|
||||
+17
-15
@@ -22,18 +22,20 @@ let chunks = numbers.chunked(by: { $0 <= $1 })
|
||||
|
||||
The `chunk(on:)` method, by contrast, takes a projection of each element and
|
||||
separates chunks where the projection of two consecutive elements is not equal.
|
||||
The result includes both the projected value and the subsequence
|
||||
that groups elements with that projected value:
|
||||
|
||||
```swift
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
let chunks = names.chunked(on: \.first!)
|
||||
// [["David"], ["Kyle", "Karoy"], ["Nate"]]
|
||||
// [("D", ["David"]), ("K", ["Kyle", "Karoy"]), ("N", ["Nate"])]
|
||||
```
|
||||
|
||||
The `chunks(ofCount:)` takes a `count` parameter (required to be > 0) and separates
|
||||
the collection into `n` chunks of this given count. If the `count` parameter is
|
||||
evenly divided by the count of the base `Collection` all the chunks will have
|
||||
the count equals to the parameter. Otherwise, the last chunk will contain the
|
||||
remaining elements.
|
||||
The `chunks(ofCount:)` method takes a `count` parameter (greater than zero)
|
||||
and separates the collection into chunks of this given count.
|
||||
If the `count` parameter is evenly divided by the count of the base `Collection`,
|
||||
all the chunks will have a count equal to the parameter.
|
||||
Otherwise, the last chunk will contain the remaining elements.
|
||||
|
||||
```swift
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
@@ -44,17 +46,17 @@ let remaining = names.chunks(ofCount: 3)
|
||||
// equivalent to [["David", "Kyle", "Karoy"], ["Nate"]]
|
||||
```
|
||||
|
||||
The `chunks(ofCount:)` is the method of the [existing SE proposal][proposal].
|
||||
Unlike the `split` family of methods, the entire collection is included in the
|
||||
chunked result — joining the resulting chunks recreates the original collection.
|
||||
The `chunks(ofCount:)` is the subject of an [existing SE proposal][proposal].
|
||||
|
||||
When "chunking" a collection, the entire collection is included in the result,
|
||||
unlike the `split` family of methods, where separators are dropped.
|
||||
Joining the result of a chunking method call recreates the original collection.
|
||||
|
||||
```swift
|
||||
c.elementsEqual(c.chunked(...).joined())
|
||||
// true
|
||||
```
|
||||
|
||||
Check the [proposal][proposal] detailed design section for more info.
|
||||
|
||||
[proposal]: https://github.com/apple/swift-evolution/pull/935
|
||||
|
||||
## Detailed Design
|
||||
@@ -70,21 +72,21 @@ extension Collection {
|
||||
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: (Element) -> Subject
|
||||
) -> [SubSequence]
|
||||
) -> [(Subject, SubSequence)]
|
||||
}
|
||||
|
||||
extension LazyCollectionProtocol {
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> Chunked<Elements>
|
||||
) -> ChunkedBy<Elements, Element>
|
||||
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> Chunked<Elements>
|
||||
) -> ChunkedOn<Elements, Subject>
|
||||
}
|
||||
```
|
||||
|
||||
The `Chunked` type is bidirectional when the wrapped collection is
|
||||
The `ChunkedBy` and `ChunkedOn` types are bidirectional when the wrapped collection is
|
||||
bidirectional.
|
||||
|
||||
### Complexity
|
||||
|
||||
@@ -0,0 +1,102 @@
|
||||
# Joined
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Joined.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/JoinedTests.swift)]
|
||||
|
||||
Concatenate a sequence of sequences, inserting a separator between each element.
|
||||
|
||||
The separator can be either a single element or a sequence of elements, and it
|
||||
can optionally depend on the sequences right before and after it by returning it
|
||||
from a closure:
|
||||
|
||||
```swift
|
||||
for number in [[1], [2, 3], [4, 5, 6]].joined(by: 100) {
|
||||
print(number)
|
||||
}
|
||||
// 1, 100, 2, 3, 100, 4, 5, 6
|
||||
|
||||
for number in [[10], [20, 30], [40, 50, 60]].joined(by: { [$0.count, $1.count] }) {
|
||||
print(number)
|
||||
}
|
||||
// 10, 1, 2, 20, 30, 2, 3, 40, 50, 60
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The versions that take a closure are executed eagerly and are defined on
|
||||
`Sequence`:
|
||||
|
||||
```swift
|
||||
extension Sequence where Element: Sequence {
|
||||
public func joined(
|
||||
by separator: (Element, Element) throws -> Element.Element
|
||||
) rethrows -> [Element.Element]
|
||||
|
||||
public func joined<Separator>(
|
||||
by separator: (Element, Element) throws -> Separator
|
||||
) rethrows -> [Element.Element]
|
||||
where Separator: Sequence, Separator.Element == Element.Element
|
||||
}
|
||||
```
|
||||
|
||||
The versions that do not take a closure are defined on both `Sequence` and
|
||||
`Collection` because the resulting collections need to precompute their start
|
||||
index to ensure O(1) access:
|
||||
|
||||
```swift
|
||||
extension Sequence where Element: Sequence {
|
||||
public func joined(by separator: Element.Element)
|
||||
-> JoinedBySequence<Self, CollectionOfOne<Element.Element>>
|
||||
|
||||
public func joined<Separator>(
|
||||
by separator: Separator
|
||||
) -> JoinedBySequence<Self, Separator>
|
||||
where Separator: Collection, Separator.Element == Element.Element
|
||||
}
|
||||
|
||||
extension Collection where Element: Sequence {
|
||||
public func joined(by separator: Element.Element)
|
||||
-> JoinedByCollection<Self, CollectionOfOne<Element.Element>>
|
||||
|
||||
public func joined<Separator>(
|
||||
by separator: Separator
|
||||
) -> JoinedByCollection<Self, Separator>
|
||||
where Separator: Collection, Separator.Element == Element.Element
|
||||
}
|
||||
```
|
||||
|
||||
Note that the sequence separator of the closure-less version defined on
|
||||
`Sequence` is required to be a `Collection`, because a plain `Sequence` cannot in
|
||||
general be iterated over multiple times.
|
||||
|
||||
The closure-based versions also have lazy variants that are defined on both
|
||||
`LazySequenceProtocol` and `LazyCollectionProtocol` for the same reason as
|
||||
explained above:
|
||||
|
||||
```swift
|
||||
extension LazySequenceProtocol where Element: Sequence {
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureSequence<Self, CollectionOfOne<Element.Element>>
|
||||
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureSequence<Self, Separator>
|
||||
}
|
||||
|
||||
extension LazyCollectionProtocol where Element: Collection {
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureCollection<Self, CollectionOfOne<Element.Element>>
|
||||
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureCollection<Self, Separator>
|
||||
}
|
||||
```
|
||||
|
||||
`JoinedBySequence`, `JoinedByClosureSequence`, `JoinedByCollection`, and
|
||||
`JoinedByClosureCollection` conform to `LazySequenceProtocol` when the base
|
||||
sequence conforms. `JoinedByCollection` and `JoinedByClosureCollection` also
|
||||
conform to `LazyCollectionProtocol` and `BidirectionalCollection` when the base
|
||||
collection conforms.
|
||||
+30
-3
@@ -1,4 +1,4 @@
|
||||
# Min/Max with Count
|
||||
# Minima and/or Maxima
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/MinMax.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/MinMaxTests.swift)]
|
||||
@@ -13,6 +13,17 @@ let smallestThree = numbers.min(count: 3, sortedBy: <)
|
||||
// [1, 2, 3]
|
||||
```
|
||||
|
||||
Return the smallest and largest elements of this sequence, determined by a predicate or in the order defined by `Comparable` conformance.
|
||||
|
||||
If you need both the minimum and maximum values of a collection, using these methods can give you a performance boost over running the `min` method followed by the `max` method. Plus they work with single-pass sequences.
|
||||
|
||||
```swift
|
||||
let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
if let (smallest, largest) = numbers.minAndMax(by: <) {
|
||||
// Work with 1 and 9....
|
||||
}
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
This adds the `Collection` methods shown below:
|
||||
@@ -31,6 +42,16 @@ extension Collection {
|
||||
}
|
||||
```
|
||||
|
||||
And the `Sequence` method:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func minAndMax(
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> (min: Element, max: Element)?
|
||||
}
|
||||
```
|
||||
|
||||
Additionally, versions of these methods for `Comparable` types are also provided:
|
||||
|
||||
```swift
|
||||
@@ -39,20 +60,26 @@ extension Collection where Element: Comparable {
|
||||
|
||||
public func max(count: Int) -> [Element]
|
||||
}
|
||||
|
||||
extension Sequence where Element: Comparable {
|
||||
public func minAndMax() -> (min: Element, max: Element)?
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The algorithm used is based on [Soroush Khanlou's research on this matter](https://khanlou.com/2018/12/analyzing-complexity/). The total complexity is `O(k log k + nk)`, which will result in a runtime close to `O(n)` if *k* is a small amount. If *k* is a large amount (more than 10% of the collection), we fall back to sorting the entire array. Realistically, this means the worst case is actually `O(n log n)`.
|
||||
The algorithm used for minimal- or maximal-ordered subsets is based on [Soroush Khanlou's research on this matter](https://khanlou.com/2018/12/analyzing-complexity/). The total complexity is `O(k log k + nk)`, which will result in a runtime close to `O(n)` if *k* is a small amount. If *k* is a large amount (more than 10% of the collection), we fall back to sorting the entire array. Realistically, this means the worst case is actually `O(n log n)`.
|
||||
|
||||
Here are some benchmarks we made that demonstrates how this implementation (SmallestM) behaves when *k* increases (before implementing the fallback):
|
||||
|
||||

|
||||

|
||||
|
||||
The algorithm used for simultaneous minimum and maximum is slightly optimized. At each iteration, two elements are read, their relative order is determined, then each is compared against exactly one of the current extrema for potential replacement. When a comparison predicate has to analyze every component of both operands, the optimized algorithm isn't much faster than the straightforward approach. But when a predicate only needs to compare a small part of each instance, the optimization shines through.
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**C++:** The `<algorithm>` library defines a `partial_sort` function where the entire array is returned using a partial heap sort.
|
||||
**C++:** The `<algorithm>` library defines a `partial_sort` function where the entire array is returned using a partial heap sort. It also defines a `minmax_element` function that scans a range for its minimal and maximal elements.
|
||||
|
||||
**Python:** Defines a `heapq` priority queue that can be used to manually achieve the same result.
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 74 KiB After Width: | Height: | Size: 64 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 77 KiB After Width: | Height: | Size: 69 KiB |
+20
-1
@@ -48,6 +48,25 @@ func myAlgorithm2<Input>(input: Input) where Input: BidirectionalCollection {
|
||||
Swift provides the `BidirectionalCollection` protocol for marking types which support reverse traversal,
|
||||
and generic types and algorithms which want to make use of that should add it to their constraints.
|
||||
|
||||
### >= 0.3.0
|
||||
|
||||
In `v0.3.0` new methods are added to allow discarding all the elements matching the predicate at the beginning (prefix) or at the ending (suffix) of the collection.
|
||||
- `trimmingSuffix(while:)` can only be run on collections conforming to the `BidirectionalCollection` protocol.
|
||||
- `trimmingPrefix(while:)` can be run also on collections conforming to the `Collection` protocol.
|
||||
|
||||
```swift
|
||||
let myString = " hello, world "
|
||||
print(myString.trimmingPrefix(while: \.isWhitespace)) // "hello, world "
|
||||
|
||||
print(myString.trimmingSuffix(while: \.isWhitespace)) // " hello, world"
|
||||
```
|
||||
Also mutating variants for all the methods already existing and the new ones are added.
|
||||
```swift
|
||||
var myString = " hello, world "
|
||||
myString.trim(while: \.isWhitespace)
|
||||
print(myString) // "hello, world"
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling this method is O(_n_).
|
||||
@@ -111,4 +130,4 @@ let result = input.dropFromBothEnds(while: { ... })
|
||||
|
||||
// No such ambiguity here.
|
||||
let result = input.trimming(while: { ... })
|
||||
```
|
||||
```
|
||||
@@ -20,8 +20,9 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
#### Combining collections
|
||||
|
||||
- [`chain(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chain.md): Concatenates two collections with the same element type.
|
||||
- [`product(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Product.md): Iterates over all the pairs of two collections; equivalent to nested `for`-`in` loops.
|
||||
- [`cycled()`, `cycled(times:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Cycle.md): Repeats the elements of a collection forever or a set number of times.
|
||||
- [`joined(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Joined.md): Concatenate sequences of sequences, using an element or sequence as a separator, or using a closure to generate each separator.
|
||||
- [`product(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Product.md): Iterates over all the pairs of two collections; equivalent to nested `for`-`in` loops.
|
||||
|
||||
#### Subsetting operations
|
||||
|
||||
@@ -30,8 +31,9 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
- [`randomStableSample(count:)`, `randomStableSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection, preserving their original relative order.
|
||||
- [`striding(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Stride.md): Returns every nth element of a collection.
|
||||
- [`suffix(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Suffix.md): Returns the suffix of a collection where all element pass a given predicate.
|
||||
- [`trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start and end.
|
||||
- [`trimmingPrefix(while:)`, `trimmingSuffix(while)`, `trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start, end, or both. The mutating `trim...` methods trim a collection in place.
|
||||
- [`uniqued()`, `uniqued(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md): The unique elements of a collection, preserving their order.
|
||||
- [`minAndMax()`, `minAndMax(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest and largest elements of a sequence.
|
||||
|
||||
#### Partial sorting
|
||||
|
||||
@@ -39,10 +41,12 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
|
||||
#### Other useful operations
|
||||
|
||||
- [`adjacentPairs()`](https://github.com/apple/swift-algorithms/blob/main/Guides/AdjacentPairs.md): Lazily iterates over tuples of adjacent elements.
|
||||
- [`chunked(by:)`, `chunked(on:)`, `chunks(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chunked.md): Eager and lazy operations that break a collection into chunks based on either a binary predicate or when the result of a projection changes or chunks of a given count.
|
||||
- [`firstNonNil(_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/FirstNonNil.md): Returns the first non-`nil` result from transforming a sequence's elements.
|
||||
- [`indexed()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Indexed.md): Iterate over tuples of a collection's indices and elements.
|
||||
- [`interspersed(with:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Intersperse.md): Place a value between every two elements of a sequence.
|
||||
- [`partitioningIndex(where:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): Returns the starting index of the partition of a collection that matches a predicate.
|
||||
- [`reductions(_:)`, `reductions(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Reductions.md): Returns all the intermediate states of reducing the elements of a sequence or collection.
|
||||
- [`split(maxSplits:omittingEmptySubsequences:whereSeparator)`, `split(separator:maxSplits:omittingEmptySubsequences)`](https://github.com/apple/swift-algorithms/blob/main/Guides/LazySplit.md): Lazy versions of the Standard Library's eager operations that split sequences and collections into subsequences separated by the specified separator element.
|
||||
- [`windows(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Windows.md): Breaks a collection into overlapping subsequences where elements are slices from the original collection.
|
||||
|
||||
@@ -0,0 +1,315 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Creates a sequence of adjacent pairs of elements from this sequence.
|
||||
///
|
||||
/// In the `AdjacentPairsSequence` returned by this method, the elements of
|
||||
/// the *i*th pair are the *i*th and *(i+1)*th elements of the underlying
|
||||
/// sequence.
|
||||
/// The following example uses the `adjacentPairs()` method to iterate over
|
||||
/// adjacent pairs of integers:
|
||||
///
|
||||
/// for pair in (1...).prefix(5).adjacentPairs() {
|
||||
/// print(pair)
|
||||
/// }
|
||||
/// // Prints "(1, 2)"
|
||||
/// // Prints "(2, 3)"
|
||||
/// // Prints "(3, 4)"
|
||||
/// // Prints "(4, 5)"
|
||||
@inlinable
|
||||
public func adjacentPairs() -> AdjacentPairsSequence<Self> {
|
||||
AdjacentPairsSequence(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// A collection of adjacent pairs of elements built from an underlying
|
||||
/// collection.
|
||||
///
|
||||
/// In an `AdjacentPairsCollection`, the elements of the *i*th pair are the
|
||||
/// *i*th and *(i+1)*th elements of the underlying sequence. The following
|
||||
/// example uses the `adjacentPairs()` method to iterate over adjacent pairs
|
||||
/// of integers:
|
||||
///
|
||||
/// for pair in (1...5).adjacentPairs() {
|
||||
/// print(pair)
|
||||
/// }
|
||||
/// // Prints "(1, 2)"
|
||||
/// // Prints "(2, 3)"
|
||||
/// // Prints "(3, 4)"
|
||||
/// // Prints "(4, 5)"
|
||||
@inlinable
|
||||
public func adjacentPairs() -> AdjacentPairsCollection<Self> {
|
||||
AdjacentPairsCollection(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
/// A sequence of adjacent pairs of elements built from an underlying sequence.
|
||||
///
|
||||
/// Use the `adjacentPairs()` method on a sequence to create an
|
||||
/// `AdjacentPairsSequence` instance.
|
||||
public struct AdjacentPairsSequence<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// Creates an instance that makes pairs of adjacent elements from `base`.
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence {
|
||||
/// The iterator for an `AdjacentPairsSequence` or `AdjacentPairsCollection`.
|
||||
public struct Iterator {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal var previousElement: Base.Element?
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base.Iterator) {
|
||||
self.base = base
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence.Iterator: IteratorProtocol {
|
||||
public typealias Element = (Base.Element, Base.Element)
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
if previousElement == nil {
|
||||
previousElement = base.next()
|
||||
}
|
||||
|
||||
guard let previous = previousElement, let next = base.next() else {
|
||||
return nil
|
||||
}
|
||||
|
||||
previousElement = next
|
||||
return (previous, next)
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence: Sequence {
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator())
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var underestimatedCount: Int {
|
||||
Swift.max(0, base.underestimatedCount - 1)
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
/// A collection of adjacent pairs of elements built from an underlying
|
||||
/// collection.
|
||||
///
|
||||
/// Use the `adjacentPairs()` method on a collection to create an
|
||||
/// `AdjacentPairsCollection` instance.
|
||||
public struct AdjacentPairsCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
public let startIndex: Index
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
|
||||
// Lazily build the end index, since we can't use the instance
|
||||
// property pre-initialization
|
||||
var endIndex: Index {
|
||||
Index(first: base.endIndex, second: base.endIndex)
|
||||
}
|
||||
|
||||
// Precompute `startIndex` to ensure O(1) behavior.
|
||||
guard !base.isEmpty else {
|
||||
self.startIndex = endIndex
|
||||
return
|
||||
}
|
||||
|
||||
// If there's only one element (i.e. the second index of base == endIndex)
|
||||
// then this collection should be empty.
|
||||
let secondIndex = base.index(after: base.startIndex)
|
||||
self.startIndex = secondIndex == base.endIndex
|
||||
? endIndex
|
||||
: Index(first: base.startIndex, second: secondIndex)
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection {
|
||||
public typealias Iterator = AdjacentPairsSequence<Base>.Iterator
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection {
|
||||
/// A position in an `AdjacentPairsCollection`.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var first: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
internal var second: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(first: Base.Index, second: Base.Index) {
|
||||
self.first = first
|
||||
self.second = second
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func ==(lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.first == rhs.first
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.first < rhs.first
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: Collection {
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(first: base.endIndex, second: base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> (Base.Element, Base.Element) {
|
||||
(base[position.first], base[position.second])
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance beyond endIndex")
|
||||
let next = base.index(after: i.second)
|
||||
return next == base.endIndex
|
||||
? endIndex
|
||||
: Index(first: i.second, second: next)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
guard let result = distance > 0
|
||||
? offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
: offsetBackward(i, by: -distance, limitedBy: startIndex)
|
||||
else { fatalError("Index out of bounds") }
|
||||
return result
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index, offsetBy distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
if distance > 0 {
|
||||
let limit = limit > i ? limit : endIndex
|
||||
return offsetForward(i, by: distance, limitedBy: limit)
|
||||
} else {
|
||||
let limit = limit < i ? limit : startIndex
|
||||
return offsetBackward(i, by: -distance, limitedBy: limit)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit > i)
|
||||
|
||||
guard let newFirst = base.index(i.second, offsetBy: distance - 1, limitedBy: limit.first),
|
||||
newFirst != base.endIndex
|
||||
else { return nil }
|
||||
let newSecond = base.index(after: newFirst)
|
||||
|
||||
precondition(newSecond <= base.endIndex, "Can't advance beyond endIndex")
|
||||
return newSecond == base.endIndex
|
||||
? endIndex
|
||||
: Index(first: newFirst, second: newSecond)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit < i)
|
||||
|
||||
let offset = i == endIndex ? 0 : 1
|
||||
guard let newSecond = base.index(
|
||||
i.first,
|
||||
offsetBy: -(distance - offset),
|
||||
limitedBy: limit.second)
|
||||
else { return nil }
|
||||
let newFirst = base.index(newSecond, offsetBy: -1)
|
||||
precondition(newFirst >= base.startIndex, "Can't move before startIndex")
|
||||
return Index(first: newFirst, second: newSecond)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
// While there's a 2-step gap between the `first` base index values in
|
||||
// `endIndex` and the penultimate index of this collection, the `second`
|
||||
// base index values are consistently one step apart throughout the
|
||||
// entire collection.
|
||||
base.distance(from: start.second, to: end.second)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
Swift.max(0, base.count - 1)
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't offset before startIndex")
|
||||
let second = i == endIndex
|
||||
? base.index(before: base.endIndex)
|
||||
: i.first
|
||||
let first = base.index(before: second)
|
||||
return Index(first: first, second: second)
|
||||
}
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension AdjacentPairsCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension AdjacentPairsCollection.Index: Hashable where Base.Index: Hashable {
|
||||
@inlinable
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(first)
|
||||
}
|
||||
}
|
||||
@@ -10,8 +10,10 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection wrapper that breaks a collection into chunks based on a
|
||||
/// predicate or projection.
|
||||
public struct Chunked<Base: Collection, Subject> {
|
||||
/// predicate.
|
||||
///
|
||||
/// Call `lazy.chunked(by:)` on a collection to create an instance of this type.
|
||||
public struct ChunkedBy<Base: Collection, Subject> {
|
||||
/// The collection that this instance provides a view onto.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -45,7 +47,7 @@ public struct Chunked<Base: Collection, Subject> {
|
||||
}
|
||||
}
|
||||
|
||||
extension Chunked: LazyCollectionProtocol {
|
||||
extension ChunkedBy: LazyCollectionProtocol {
|
||||
/// A position in a chunked collection.
|
||||
public struct Index: Comparable {
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@@ -106,9 +108,9 @@ extension Chunked: LazyCollectionProtocol {
|
||||
}
|
||||
}
|
||||
|
||||
extension Chunked.Index: Hashable where Base.Index: Hashable {}
|
||||
extension ChunkedBy.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension Chunked: BidirectionalCollection
|
||||
extension ChunkedBy: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
/// Returns the index in the base collection of the start of the chunk ending
|
||||
@@ -131,11 +133,64 @@ extension Chunked: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "Chunked")
|
||||
public typealias LazyChunked<Base: Collection, Subject> = Chunked<Base, Subject>
|
||||
@available(*, deprecated, renamed: "ChunkedBy")
|
||||
public typealias LazyChunked<Base: Collection, Subject> = ChunkedBy<Base, Subject>
|
||||
|
||||
@available(*, deprecated, renamed: "ChunkedBy")
|
||||
public typealias Chunked<Base: Collection, Subject> = ChunkedBy<Base, Subject>
|
||||
|
||||
/// A collection wrapper that breaks a collection into chunks based on a
|
||||
/// predicate.
|
||||
///
|
||||
/// Call `lazy.chunked(on:)` on a collection to create an instance of this type.
|
||||
public struct ChunkedOn<Base: Collection, Subject> {
|
||||
@usableFromInline
|
||||
internal var chunked: ChunkedBy<Base, Subject>
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
projection: @escaping (Base.Element) -> Subject,
|
||||
belongInSameGroup: @escaping (Subject, Subject) -> Bool
|
||||
) {
|
||||
self.chunked = ChunkedBy(base: base, projection: projection, belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedOn: LazyCollectionProtocol {
|
||||
public typealias Index = ChunkedBy<Base, Subject>.Index
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
chunked.startIndex
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
chunked.endIndex
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> (Subject, Base.SubSequence) {
|
||||
let subsequence = chunked[position]
|
||||
let subject = chunked.projection(subsequence.first!)
|
||||
return (subject, subsequence)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
chunked.index(after: i)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedOn: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
public func index(before i: Index) -> Index {
|
||||
chunked.index(before: i)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.chunked(by:)
|
||||
// lazy.chunked(by:) / lazy.chunked(on:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazyCollectionProtocol {
|
||||
@@ -146,8 +201,8 @@ extension LazyCollectionProtocol {
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> Chunked<Elements, Element> {
|
||||
Chunked(
|
||||
) -> ChunkedBy<Elements, Element> {
|
||||
ChunkedBy(
|
||||
base: elements,
|
||||
projection: { $0 },
|
||||
belongInSameGroup: belongInSameGroup)
|
||||
@@ -160,8 +215,8 @@ extension LazyCollectionProtocol {
|
||||
@inlinable
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> Chunked<Elements, Subject> {
|
||||
Chunked(
|
||||
) -> ChunkedOn<Elements, Subject> {
|
||||
ChunkedOn(
|
||||
base: elements,
|
||||
projection: projection,
|
||||
belongInSameGroup: ==)
|
||||
@@ -169,32 +224,29 @@ extension LazyCollectionProtocol {
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// chunked(by:)
|
||||
// chunked(by:) / chunked(on:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to the same value according to the given
|
||||
/// predicate.
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
internal func chunked<Subject>(
|
||||
on projection: (Element) throws -> Subject,
|
||||
by belongInSameGroup: (Subject, Subject) throws -> Bool
|
||||
public func chunked(
|
||||
by belongInSameGroup: (Element, Element) throws -> Bool
|
||||
) rethrows -> [SubSequence] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [SubSequence] = []
|
||||
|
||||
var start = startIndex
|
||||
var subject = try projection(self[start])
|
||||
var current = self[start]
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
let nextSubject = try projection(element)
|
||||
if try !belongInSameGroup(subject, nextSubject) {
|
||||
if try !belongInSameGroup(current, element) {
|
||||
result.append(self[start..<index])
|
||||
start = index
|
||||
subject = nextSubject
|
||||
current = element
|
||||
}
|
||||
}
|
||||
|
||||
@@ -204,17 +256,6 @@ extension Collection {
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: (Element, Element) throws -> Bool
|
||||
) rethrows -> [SubSequence] {
|
||||
try chunked(on: { $0 }, by: belongInSameGroup)
|
||||
}
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to the same value.
|
||||
@@ -223,8 +264,27 @@ extension Collection {
|
||||
@inlinable
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: (Element) throws -> Subject
|
||||
) rethrows -> [SubSequence] {
|
||||
try chunked(on: projection, by: ==)
|
||||
) rethrows -> [(Subject, SubSequence)] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [(Subject, SubSequence)] = []
|
||||
|
||||
var start = startIndex
|
||||
var subject = try projection(self[start])
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
let nextSubject = try projection(element)
|
||||
if subject != nextSubject {
|
||||
result.append((subject, self[start..<index]))
|
||||
start = index
|
||||
subject = nextSubject
|
||||
}
|
||||
}
|
||||
|
||||
if start != endIndex {
|
||||
result.append((subject, self[start..<endIndex]))
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Either
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A general-purpose sum type.
|
||||
@usableFromInline
|
||||
internal enum Either<Left, Right> {
|
||||
case left(Left)
|
||||
case right(Right)
|
||||
}
|
||||
|
||||
extension Either: Equatable where Left: Equatable, Right: Equatable {
|
||||
@usableFromInline
|
||||
internal static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case let (.left(lhs), .left(rhs)):
|
||||
return lhs == rhs
|
||||
case let (.right(lhs), .right(rhs)):
|
||||
return lhs == rhs
|
||||
case (.left, .right), (.right, .left):
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Either: Comparable where Left: Comparable, Right: Comparable {
|
||||
@usableFromInline
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case let (.left(lhs), .left(rhs)):
|
||||
return lhs < rhs
|
||||
case let (.right(lhs), .right(rhs)):
|
||||
return lhs < rhs
|
||||
case (.left, .right):
|
||||
return true
|
||||
case (.right, .left):
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// EitherSequence
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that has one of the two specified types.
|
||||
@usableFromInline
|
||||
internal enum EitherSequence<Left: Sequence, Right: Sequence>
|
||||
where Left.Element == Right.Element
|
||||
{
|
||||
case left(Left)
|
||||
case right(Right)
|
||||
}
|
||||
|
||||
extension EitherSequence: Sequence {
|
||||
@usableFromInline
|
||||
internal struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var left: Left.Iterator?
|
||||
|
||||
@usableFromInline
|
||||
internal var right: Right.Iterator?
|
||||
|
||||
@inlinable
|
||||
internal mutating func next() -> Left.Element? {
|
||||
left?.next() ?? right?.next()
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal func makeIterator() -> Iterator {
|
||||
switch self {
|
||||
case .left(let left):
|
||||
return Iterator(left: left.makeIterator(), right: nil)
|
||||
case .right(let right):
|
||||
return Iterator(left: nil, right: right.makeIterator())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension EitherSequence: Collection
|
||||
where Left: Collection, Right: Collection, Left.Element == Right.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Index = Either<Left.Index, Right.Index>
|
||||
|
||||
@inlinable
|
||||
internal var startIndex: Index {
|
||||
switch self {
|
||||
case .left(let s):
|
||||
return .left(s.startIndex)
|
||||
case .right(let s):
|
||||
return .right(s.startIndex)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var endIndex: Index {
|
||||
switch self {
|
||||
case .left(let s):
|
||||
return .left(s.endIndex)
|
||||
case .right(let s):
|
||||
return .right(s.endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Element {
|
||||
switch (self, position) {
|
||||
case let (.left(s), .left(i)):
|
||||
return s[i]
|
||||
case let (.right(s), .right(i)):
|
||||
return s[i]
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(after i: Index) -> Index {
|
||||
switch (self,i) {
|
||||
case let (.left(s), .left(i)):
|
||||
return .left(s.index(after: i))
|
||||
case let (.right(s), .right(i)):
|
||||
return .right(s.index(after: i))
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
switch (self, i, limit) {
|
||||
case let (.left(s), .left(i), .left(limit)):
|
||||
return s.index(i, offsetBy: distance, limitedBy: limit).map { .left($0) }
|
||||
case let (.right(s), .right(i), .right(limit)):
|
||||
return s.index(i, offsetBy: distance, limitedBy: limit).map { .right($0) }
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
switch (self, i) {
|
||||
case let (.left(s), .left(i)):
|
||||
return .left(s.index(i, offsetBy: distance))
|
||||
case let (.right(s), .right(i)):
|
||||
return .right(s.index(i, offsetBy: distance))
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (self, start, end) {
|
||||
case let (.left(s), .left(i), .left(j)):
|
||||
return s.distance(from: i, to: j)
|
||||
case let (.right(s), .right(i), .right(j)):
|
||||
return s.distance(from: i, to: j)
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension EitherSequence: BidirectionalCollection
|
||||
where Left: BidirectionalCollection, Right: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
internal func index(before i: Index) -> Index {
|
||||
switch (self, i) {
|
||||
case let (.left(s), .left(i)):
|
||||
return .left(s.index(before: i))
|
||||
case let (.right(s), .right(i)):
|
||||
return .right(s.index(before: i))
|
||||
default:
|
||||
fatalError()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension EitherSequence: RandomAccessCollection
|
||||
where Left: RandomAccessCollection, Right: RandomAccessCollection {}
|
||||
@@ -0,0 +1,306 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection consisting of all the elements contained in a collection of
|
||||
/// collections.
|
||||
@usableFromInline
|
||||
internal struct FlattenCollection<Base: Collection> where Base.Element: Collection {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let indexOfFirstNonEmptyElement: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
self.indexOfFirstNonEmptyElement = base.endOfPrefix(while: { $0.isEmpty })
|
||||
}
|
||||
}
|
||||
|
||||
extension FlattenCollection: Collection {
|
||||
@usableFromInline
|
||||
internal struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let outer: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Base.Element.Index?
|
||||
|
||||
@inlinable
|
||||
init(outer: Base.Index, inner: Base.Element.Index?) {
|
||||
self.outer = outer
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
guard lhs.outer == rhs.outer else { return lhs.outer < rhs.outer }
|
||||
return lhs.inner == nil ? false : lhs.inner! < rhs.inner!
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var startIndex: Index {
|
||||
let outer = indexOfFirstNonEmptyElement
|
||||
let inner = outer == base.endIndex ? nil : base[outer].startIndex
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var endIndex: Index {
|
||||
Index(outer: base.endIndex, inner: nil)
|
||||
}
|
||||
|
||||
/// Forms an index from a pair of base indices, normalizing
|
||||
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
|
||||
/// necessary.
|
||||
@inlinable
|
||||
internal func normalizeIndex(
|
||||
outer: Base.Index,
|
||||
inner: Base.Element.Index
|
||||
) -> Index {
|
||||
if inner == base[outer].endIndex {
|
||||
let outer = base[base.index(after: outer)...]
|
||||
.endOfPrefix(while: { $0.isEmpty })
|
||||
let inner = outer == base.endIndex ? nil : base[outer].startIndex
|
||||
return Index(outer: outer, inner: inner)
|
||||
} else {
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(after index: Index) -> Index {
|
||||
let element = base[index.outer]
|
||||
let nextInner = element.index(after: index.inner!)
|
||||
return normalizeIndex(outer: index.outer, inner: nextInner)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Base.Element.Element {
|
||||
base[position.outer][position.inner!]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start.outer <= end.outer
|
||||
else { return -distance(from: end, to: start) }
|
||||
guard let startInner = start.inner
|
||||
else { return 0 }
|
||||
guard start.outer != end.outer
|
||||
else { return base[start.outer].distance(from: startInner, to: end.inner!) }
|
||||
|
||||
let firstPart = base[start.outer][startInner...].count
|
||||
let middlePart = base[start.outer..<end.outer].dropFirst()
|
||||
.reduce(0, { $0 + $1.count })
|
||||
let lastPart = end.inner.map { base[end.outer][..<$0].count } ?? 0
|
||||
|
||||
return firstPart + middlePart + lastPart
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(index, by: distance)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
if distance > 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
: offsetForward(index, by: distance)
|
||||
} else {
|
||||
return limit <= index
|
||||
? offsetBackward(index, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit >= index)
|
||||
|
||||
if index.outer == limit.outer {
|
||||
if let indexInner = index.inner, let limitInner = limit.inner {
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
} else {
|
||||
// `index` and `limit` are both `endIndex`
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// `index <= limit` and `index.outer != limit.outer`, so `index != endIndex`
|
||||
let indexInner = index.inner!
|
||||
let element = base[index.outer]
|
||||
|
||||
if let inner = element.index(
|
||||
indexInner,
|
||||
offsetBy: distance,
|
||||
limitedBy: element.endIndex
|
||||
) {
|
||||
return normalizeIndex(outer: index.outer, inner: inner)
|
||||
}
|
||||
|
||||
var remainder = distance - element[indexInner...].count
|
||||
var outer = base.index(after: index.outer)
|
||||
|
||||
while outer != limit.outer {
|
||||
let element = base[outer]
|
||||
|
||||
if let inner = element.index(
|
||||
element.startIndex,
|
||||
offsetBy: remainder,
|
||||
limitedBy: element.endIndex
|
||||
) {
|
||||
return normalizeIndex(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
remainder -= element.count
|
||||
base.formIndex(after: &outer)
|
||||
}
|
||||
|
||||
if let limitInner = limit.inner {
|
||||
let element = base[outer]
|
||||
return element.index(element.startIndex, offsetBy: remainder, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: outer, inner: inner) }
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit <= index)
|
||||
|
||||
if index.outer == limit.outer {
|
||||
if let indexInner = index.inner, let limitInner = limit.inner {
|
||||
return base[index.outer]
|
||||
.index(indexInner, offsetBy: -distance, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: index.outer, inner: inner) }
|
||||
} else {
|
||||
// `index` and `limit` are both `endIndex`
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
var remainder = distance
|
||||
|
||||
if let indexInner = index.inner {
|
||||
let element = base[index.outer]
|
||||
|
||||
if let inner = element.index(
|
||||
indexInner,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
) {
|
||||
return Index(outer: index.outer, inner: inner)
|
||||
}
|
||||
|
||||
remainder -= element[..<indexInner].count
|
||||
}
|
||||
|
||||
var outer = base.index(index.outer, offsetBy: -1)
|
||||
|
||||
while outer != limit.outer {
|
||||
let element = base[outer]
|
||||
|
||||
if let inner = element.index(
|
||||
element.endIndex,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: element.startIndex
|
||||
) {
|
||||
return Index(outer: outer, inner: inner)
|
||||
}
|
||||
|
||||
remainder -= element.count
|
||||
base.formIndex(&outer, offsetBy: -1)
|
||||
}
|
||||
|
||||
let element = base[outer]
|
||||
return element.index(
|
||||
element.endIndex,
|
||||
offsetBy: -remainder,
|
||||
limitedBy: limit.inner!
|
||||
).map { inner in Index(outer: outer, inner: inner) }
|
||||
}
|
||||
}
|
||||
|
||||
extension FlattenCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection, Base.Element: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
internal func index(before index: Index) -> Index {
|
||||
if let inner = index.inner {
|
||||
let element = base[index.outer]
|
||||
|
||||
if inner != element.startIndex {
|
||||
let previousInner = element.index(before: inner)
|
||||
return Index(outer: index.outer, inner: previousInner)
|
||||
}
|
||||
}
|
||||
|
||||
let previousOuter = base[..<index.outer].lastIndex(where: { !$0.isEmpty })!
|
||||
let element = base[previousOuter]
|
||||
let previousInner = element.index(before: element.endIndex)
|
||||
return Index(outer: previousOuter, inner: previousInner)
|
||||
}
|
||||
}
|
||||
|
||||
extension FlattenCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
|
||||
extension FlattenCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol, Base.Element: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// joined()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection where Element: Collection {
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections.
|
||||
@inlinable
|
||||
internal func joined() -> FlattenCollection<Self> {
|
||||
FlattenCollection(base: self)
|
||||
}
|
||||
}
|
||||
@@ -9,6 +9,10 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Intersperse
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that presents the elements of a base sequence of elements
|
||||
/// with a separator between each of those elements.
|
||||
public struct Intersperse<Base: Sequence> {
|
||||
@@ -81,7 +85,7 @@ extension Intersperse: Collection where Base: Collection {
|
||||
/// A position in an `Intersperse` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
enum Representation: Equatable {
|
||||
internal enum Representation: Equatable {
|
||||
case element(Base.Index)
|
||||
case separator(next: Base.Index)
|
||||
}
|
||||
@@ -90,7 +94,7 @@ extension Intersperse: Collection where Base: Collection {
|
||||
internal let representation: Representation
|
||||
|
||||
@inlinable
|
||||
init(representation: Representation) {
|
||||
internal init(representation: Representation) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@@ -107,12 +111,12 @@ extension Intersperse: Collection where Base: Collection {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
static func element(_ index: Base.Index) -> Self {
|
||||
internal static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
static func separator(next: Base.Index) -> Self {
|
||||
internal static func separator(next: Base.Index) -> Self {
|
||||
Self(representation: .separator(next: next))
|
||||
}
|
||||
}
|
||||
@@ -146,21 +150,6 @@ extension Intersperse: Collection where Base: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
switch (i.representation, distance.isMultiple(of: 2)) {
|
||||
case (let .element(index), true):
|
||||
return .element(base.index(index, offsetBy: distance / 2))
|
||||
case (let .element(index), false):
|
||||
return .separator(next: base.index(index, offsetBy: (distance + 1) / 2))
|
||||
case (let .separator(next: index), true):
|
||||
return .separator(next: base.index(index, offsetBy: distance / 2))
|
||||
case (let .separator(next: index), false):
|
||||
return .element(base.index(index, offsetBy: (distance - 1) / 2))
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Implement index(_:offsetBy:limitedBy:)
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
@@ -173,6 +162,98 @@ extension Intersperse: Collection where Base: Collection {
|
||||
return 2 * base.distance(from: start, to: end)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
distance >= 0
|
||||
? offsetForward(index, by: distance)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if distance >= 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
: offsetForward(index, by: distance)
|
||||
} else {
|
||||
return limit <= index
|
||||
? offsetBackward(index, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.separator(next: index), .element(limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.element(index), .separator(next: limit), false),
|
||||
let (.separator(next: index), .element(limit), true),
|
||||
let (.separator(next: index), .separator(next: limit), true):
|
||||
return base.index(index, offsetBy: (distance + 1) / 2, limitedBy: limit)
|
||||
.map { .separator(next: $0) }
|
||||
|
||||
case let (.element(index), .separator(next: limit), true),
|
||||
let (.separator(next: index), .separator(next: limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .element($0) }
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.element(index), .separator(next: limit), true),
|
||||
let (.separator(next: index), .element(limit), false),
|
||||
let (.separator(next: index), .separator(next: limit), false):
|
||||
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .separator(next: limit), false),
|
||||
let (.separator(next: index), .separator(next: limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.map { .separator(next: $0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.separator(next: index), .element(limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .separator(next: $0) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: BidirectionalCollection
|
||||
@@ -199,6 +280,315 @@ extension Intersperse: LazySequenceProtocol
|
||||
extension Intersperse: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// InterspersedMap
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
|
||||
/// A sequence over the results of applying a closure to the sequence's
|
||||
/// elements, with a separator that separates each pair of adjacent transformed
|
||||
/// values.
|
||||
@usableFromInline
|
||||
internal struct InterspersedMap<Base: Sequence, Result> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element) -> Result
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: (Base.Element, Base.Element) -> Result
|
||||
}
|
||||
|
||||
extension InterspersedMap: Sequence {
|
||||
@usableFromInline
|
||||
internal struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element) -> Result
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: (Base.Element, Base.Element) -> Result
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base.Iterator,
|
||||
transform: @escaping (Base.Element) -> Result,
|
||||
separator: @escaping (Base.Element, Base.Element) -> Result
|
||||
) {
|
||||
self.base = base
|
||||
self.transform = transform
|
||||
self.separator = separator
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal enum State {
|
||||
case start
|
||||
case element(Base.Element)
|
||||
case separator(previous: Base.Element)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal mutating func next() -> Result? {
|
||||
switch state {
|
||||
case .start:
|
||||
guard let first = base.next() else { return nil }
|
||||
state = .separator(previous: first)
|
||||
return transform(first)
|
||||
case .separator(let previous):
|
||||
guard let next = base.next() else { return nil }
|
||||
state = .element(next)
|
||||
return separator(previous, next)
|
||||
case .element(let element):
|
||||
state = .separator(previous: element)
|
||||
return transform(element)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func makeIterator() -> Iterator {
|
||||
Iterator(
|
||||
base: base.makeIterator(),
|
||||
transform: transform,
|
||||
separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMap: Collection where Base: Collection {
|
||||
@usableFromInline
|
||||
internal struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal enum Representation: Equatable {
|
||||
case element(Base.Index)
|
||||
case separator(previous: Base.Index, next: Base.Index)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
@inlinable
|
||||
internal init(representation: Representation) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func separator(previous: Base.Index, next: Base.Index) -> Self {
|
||||
Self(representation: .separator(previous: previous, next: next))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)):
|
||||
return lhs == rhs
|
||||
case (.element, .separator), (.separator, .element):
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)),
|
||||
let (.element(lhs), .separator(_, next: rhs)),
|
||||
let (.separator(previous: lhs, _), .element(rhs)):
|
||||
return lhs < rhs
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var startIndex: Index {
|
||||
base.isEmpty ? endIndex : .element(base.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal var endIndex: Index {
|
||||
.separator(previous: base.endIndex, next: base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(after index: Index) -> Index {
|
||||
switch index.representation {
|
||||
case .element(let index):
|
||||
let next = base.index(after: index)
|
||||
return .separator(previous: index, next: next)
|
||||
case .separator(_, let next):
|
||||
return .element(next)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal subscript(position: Index) -> Result {
|
||||
switch position.representation {
|
||||
case .element(let index):
|
||||
return transform(base[index])
|
||||
case let .separator(previous, next):
|
||||
return separator(base[previous], base[next])
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case let (.element(lhs), .element(rhs)),
|
||||
let (.separator(_, next: lhs), .separator(_, next: rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs)
|
||||
case let (.element(lhs), .separator(_, next: rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs) - 1
|
||||
case let (.separator(_, next: lhs), .element(rhs)):
|
||||
return 2 * base.distance(from: lhs, to: rhs) + 1
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(index, by: distance)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return index }
|
||||
|
||||
if distance > 0 {
|
||||
return limit >= index
|
||||
? offsetForward(index, by: distance, limitedBy: limit)
|
||||
: offsetForward(index, by: distance)
|
||||
} else {
|
||||
return limit <= index
|
||||
? offsetBackward(index, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(index, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit >= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.separator(_, next: index), .element(limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.element(index), .separator(_, next: limit), false),
|
||||
let (.separator(_, next: index), .element(limit), true),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), true):
|
||||
return base.index(index, offsetBy: (distance - 1) / 2, limitedBy: limit)
|
||||
.flatMap {
|
||||
guard $0 != limit else { return nil }
|
||||
let next = base.index(after: $0)
|
||||
return next == base.endIndex
|
||||
? endIndex
|
||||
: .separator(previous: $0, next: next)
|
||||
}
|
||||
|
||||
case let (.element(index), .separator(_, next: limit), true),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), false):
|
||||
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
|
||||
.flatMap { $0 == limit ? nil : .element($0) }
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ index: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit <= index)
|
||||
|
||||
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
|
||||
case let (.element(index), .element(limit), true),
|
||||
let (.element(index), .separator(_, next: limit), true),
|
||||
let (.separator(_, next: index), .element(limit), false),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), false):
|
||||
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
|
||||
.map { .element($0) }
|
||||
|
||||
case let (.element(index), .separator(_, next: limit), false),
|
||||
let (.separator(_, next: index), .separator(_, next: limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.map { .separator(previous: base.index($0, offsetBy: -1), next: $0) }
|
||||
|
||||
case let (.element(index), .element(limit), false),
|
||||
let (.separator(_, next: index), .element(limit), true):
|
||||
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
|
||||
.flatMap {
|
||||
$0 == limit
|
||||
? nil
|
||||
: .separator(previous: base.index($0, offsetBy: -1), next: $0)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMap: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
internal func index(before index: Index) -> Index {
|
||||
switch index.representation {
|
||||
case .element(let index):
|
||||
let previous = base.index(before: index)
|
||||
return .separator(previous: previous, next: index)
|
||||
case let .separator(previous, next):
|
||||
let index = next == base.endIndex ? base.index(before: next) : previous
|
||||
return .element(index)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMap.Index.Representation: Hashable
|
||||
where Base.Index: Hashable {}
|
||||
|
||||
extension InterspersedMap: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension InterspersedMap: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// interspersed(with:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns a sequence containing elements of this sequence with the given
|
||||
@@ -234,3 +624,30 @@ extension Sequence {
|
||||
Intersperse(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.interspersed(_:with:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
/// Returns a sequence over the results of applying a closure to the
|
||||
/// sequence's elements, with a separator that separates each pair of adjacent
|
||||
/// transformed values.
|
||||
///
|
||||
/// The transformation closure lets you intersperse a sequence using a
|
||||
/// separator of a different type than the original's sequence's elements.
|
||||
/// Each separator is produced by a closure that is given access to the
|
||||
/// two elements in the original sequence right before and after it.
|
||||
///
|
||||
/// let strings = [1, 2, 2].interspersedMap(String.init,
|
||||
/// with: { $0 == $1 ? " == " : " != " })
|
||||
/// print(strings.joined()) // "1 != 2 == 2"
|
||||
///
|
||||
@usableFromInline
|
||||
internal func interspersedMap<Result>(
|
||||
_ transform: @escaping (Element) -> Result,
|
||||
with separator: @escaping (Element, Element) -> Result
|
||||
) -> InterspersedMap<Self, Result> {
|
||||
InterspersedMap(base: self, transform: transform, separator: separator)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,495 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedBySequence
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that presents the elements of a base sequence of sequences
|
||||
/// concatenated using a given separator.
|
||||
public struct JoinedBySequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<
|
||||
Intersperse<LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Separator) {
|
||||
self.inner = base.lazy
|
||||
.map(EitherSequence.left)
|
||||
.interspersed(with: .right(separator))
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedBySequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var inner: Inner.Iterator
|
||||
|
||||
@inlinable
|
||||
internal init(inner: Inner.Iterator) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element.Element? {
|
||||
inner.next()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(inner: inner.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedBySequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByClosureSequence
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that presents the elements of a base sequence of sequences
|
||||
/// concatenated using a given separator that depends on the sequences right
|
||||
/// before and after it.
|
||||
public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<
|
||||
InterspersedMap<LazySequence<Base>, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
separator: @escaping (Base.Element, Base.Element) -> Separator
|
||||
) {
|
||||
self.inner = base.lazy
|
||||
.interspersedMap(
|
||||
EitherSequence.left,
|
||||
with: { EitherSequence.right(separator($0, $1)) })
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureSequence: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var inner: Inner.Iterator
|
||||
|
||||
@inlinable
|
||||
internal init(inner: Inner.Iterator) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element.Element? {
|
||||
inner.next()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(inner: inner.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByCollection
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection that presents the elements of a base collection of collections
|
||||
/// concatenated using a given separator.
|
||||
public struct JoinedByCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<
|
||||
Intersperse<LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Separator) {
|
||||
self.inner = base.lazy
|
||||
.map(EitherSequence.left)
|
||||
.interspersed(with: .right(separator))
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByCollection: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let inner: Inner.Index
|
||||
|
||||
@inlinable
|
||||
internal init(_ inner: Inner.Index) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner == rhs.inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner < rhs.inner
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(inner.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(inner.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
Index(inner.index(after: index.inner))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.Element.Element {
|
||||
inner[position.inner]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
Index(inner.index(index.inner, offsetBy: distance))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
|
||||
.map(Index.init)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
inner.distance(from: start.inner, to: end.inner)
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
Index(inner.index(before: index.inner))
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension JoinedByCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByClosureCollection
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection that presents the elements of a base collection of collections
|
||||
/// concatenated using a given separator that depends on the collections right
|
||||
/// before and after it.
|
||||
public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<
|
||||
InterspersedMap<LazySequence<Base>, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
separator: @escaping (Base.Element, Base.Element) -> Separator
|
||||
) {
|
||||
self.inner = base.lazy
|
||||
.interspersedMap(
|
||||
EitherSequence.left,
|
||||
with: { EitherSequence.right(separator($0, $1)) })
|
||||
.joined()
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureCollection: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let inner: Inner.Index
|
||||
|
||||
@inlinable
|
||||
internal init(_ inner: Inner.Index) {
|
||||
self.inner = inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner == rhs.inner
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.inner < rhs.inner
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(inner.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(inner.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
Index(inner.index(after: index.inner))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.Element.Element {
|
||||
inner[position.inner]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ index: Index, offsetBy distance: Int) -> Index {
|
||||
Index(inner.index(index.inner, offsetBy: distance))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ index: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
|
||||
.map(Index.init)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
inner.distance(from: start.inner, to: end.inner)
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection,
|
||||
Base.Element: BidirectionalCollection,
|
||||
Separator: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
Index(inner.index(before: index.inner))
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension JoinedByClosureCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Sequence.joined(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence where Element: Sequence {
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the given separator between each sequence.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: 100) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 100, 3, 4, 100, 5, 6
|
||||
@inlinable
|
||||
public func joined(by separator: Element.Element)
|
||||
-> JoinedBySequence<Self, CollectionOfOne<Element.Element>>
|
||||
{
|
||||
joined(by: CollectionOfOne(separator))
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the given separator between each sequence.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: [100, 200]) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 100, 200, 3, 4, 100, 200, 5, 6
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: Separator
|
||||
) -> JoinedBySequence<Self, Separator>
|
||||
where Separator: Collection, Separator.Element == Element.Element
|
||||
{
|
||||
JoinedBySequence(base: self, separator: separator)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func _joined(
|
||||
by update: (inout [Element.Element], Element, Element) throws -> Void
|
||||
) rethrows -> [Element.Element] {
|
||||
var iterator = makeIterator()
|
||||
guard let first = iterator.next() else { return [] }
|
||||
|
||||
var result = Array(first)
|
||||
var previous = first
|
||||
|
||||
while let next = iterator.next() {
|
||||
try update(&result, previous, next)
|
||||
result.append(contentsOf: next)
|
||||
previous = next
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: { $0.last! * $1.first! }) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 6, 3, 4, 20, 5, 6
|
||||
@inlinable
|
||||
public func joined(
|
||||
by separator: (Element, Element) throws -> Element.Element
|
||||
) rethrows -> [Element.Element] {
|
||||
try _joined(by: { $0.append(try separator($1, $2)) })
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: { [100 * $0.last!, 100 * $1.first!] }) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 200, 300, 3, 4, 400, 500, 5, 6
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: (Element, Element) throws -> Separator
|
||||
) rethrows -> [Element.Element]
|
||||
where Separator: Sequence, Separator.Element == Element.Element
|
||||
{
|
||||
try _joined(by: { $0.append(contentsOf: try separator($1, $2)) })
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LazySequenceProtocol.joined(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol where Element: Sequence {
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
@inlinable
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureSequence<Self, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this sequence of sequences,
|
||||
/// inserting the separator produced by the closure between each sequence.
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureSequence<Self, Separator> {
|
||||
JoinedByClosureSequence(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Collection.joined(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection where Element: Collection {
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the given separator between each collection.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: 100) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 100, 3, 4, 100, 5, 6
|
||||
@inlinable
|
||||
public func joined(by separator: Element.Element)
|
||||
-> JoinedByCollection<Self, CollectionOfOne<Element.Element>>
|
||||
{
|
||||
joined(by: CollectionOfOne(separator))
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the given separator between each collection.
|
||||
///
|
||||
/// for x in [[1, 2], [3, 4], [5, 6]].joined(by: [100, 200]) {
|
||||
/// print(x)
|
||||
/// }
|
||||
/// // 1, 2, 100, 200, 3, 4, 100, 200, 5, 6
|
||||
@inlinable
|
||||
public func joined<Separator>(by separator: Separator)
|
||||
-> JoinedByCollection<Self, Separator>
|
||||
{
|
||||
JoinedByCollection(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LazyCollectionProtocol.joined(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazyCollectionProtocol where Element: Collection {
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the separator produced by the closure between each
|
||||
/// sequence.
|
||||
@inlinable
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureCollection<Self, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
/// Returns the concatenation of the elements in this collection of
|
||||
/// collections, inserting the separator produced by the closure between each
|
||||
/// sequence.
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureCollection<Self, Separator> {
|
||||
JoinedByClosureCollection(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
@@ -383,3 +383,102 @@ extension Collection where Element: Comparable {
|
||||
return max(count: count, sortedBy: <)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Simultaneous minimum and maximum evaluation
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Returns both the minimum and maximum elements in the sequence, using the
|
||||
/// given predicate as the comparison between elements.
|
||||
///
|
||||
/// The predicate must be a *strict weak ordering* over the elements. That
|
||||
/// is, for any elements `a`, `b`, and `c`, the following conditions must
|
||||
/// hold:
|
||||
///
|
||||
/// - `areInIncreasingOrder(a, a)` is always `false`. (Irreflexivity)
|
||||
/// - If `areInIncreasingOrder(a, b)` and `areInIncreasingOrder(b, c)` are
|
||||
/// both `true`, then `areInIncreasingOrder(a, c)` is also
|
||||
/// `true`. (Transitive comparability)
|
||||
/// - Two elements are *incomparable* if neither is ordered before the other
|
||||
/// according to the predicate. If `a` and `b` are incomparable, and `b`
|
||||
/// and `c` are incomparable, then `a` and `c` are also incomparable.
|
||||
/// (Transitive incomparability)
|
||||
///
|
||||
/// This example shows how to use the `minAndMax(by:)` method on a
|
||||
/// dictionary to find the key-value pair with the lowest value and the pair
|
||||
/// with the highest value.
|
||||
///
|
||||
/// let hues = ["Heliotrope": 296, "Coral": 16, "Aquamarine": 156]
|
||||
/// if let extremeHues = hues.minAndMax(by: {$0.value < $1.value}) {
|
||||
/// print(extremeHues.min, extremeHues.max)
|
||||
/// } else {
|
||||
/// print("There are no hues")
|
||||
/// }
|
||||
/// // Prints: "(key: "Coral", value: 16) (key: "Heliotrope", value: 296)"
|
||||
///
|
||||
/// - Precondition: The sequence is finite.
|
||||
///
|
||||
/// - Parameter areInIncreasingOrder: A predicate that returns `true`
|
||||
/// if its first argument should be ordered before its second
|
||||
/// argument; otherwise, `false`.
|
||||
/// - Returns: A tuple with the sequence's minimum element, followed by its
|
||||
/// maximum element. If the sequence provides multiple qualifying minimum
|
||||
/// elements, the first equivalent element is returned; of multiple maximum
|
||||
/// elements, the last is returned. If the sequence has no elements, the
|
||||
/// method returns `nil`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
public func minAndMax(
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> (min: Element, max: Element)? {
|
||||
// Check short sequences.
|
||||
var iterator = makeIterator()
|
||||
guard var lowest = iterator.next() else { return nil }
|
||||
guard var highest = iterator.next() else { return (lowest, lowest) }
|
||||
|
||||
// Confirm the initial bounds.
|
||||
if try areInIncreasingOrder(highest, lowest) { swap(&lowest, &highest) }
|
||||
|
||||
// Read the elements in pairwise. Structuring the comparisons around this
|
||||
// is actually faster than loops based on extracting and testing elements
|
||||
// one-at-a-time.
|
||||
while var low = iterator.next() {
|
||||
var high = iterator.next() ?? low
|
||||
if try areInIncreasingOrder(high, low) { swap(&low, &high) }
|
||||
if try areInIncreasingOrder(low, lowest) { lowest = low }
|
||||
if try !areInIncreasingOrder(high, highest) { highest = high }
|
||||
}
|
||||
|
||||
return (lowest, highest)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence where Element: Comparable {
|
||||
/// Returns both the minimum and maximum elements in the sequence.
|
||||
///
|
||||
/// This example finds the smallest and largest values in an array of height
|
||||
/// measurements.
|
||||
///
|
||||
/// let heights = [67.5, 65.7, 64.3, 61.1, 58.5, 60.3, 64.9]
|
||||
/// if let (lowestHeight, greatestHeight) = heights.minAndMax() {
|
||||
/// print(lowestHeight, greatestHeight)
|
||||
/// } else {
|
||||
/// print("The list of heights is empty")
|
||||
/// }
|
||||
/// // Prints: "58.5 67.5"
|
||||
///
|
||||
/// - Precondition: The sequence is finite.
|
||||
///
|
||||
/// - Returns: A tuple with the sequence's minimum element, followed by its
|
||||
/// maximum element. If the sequence provides multiple qualifying minimum
|
||||
/// elements, the first equivalent element is returned; of multiple maximum
|
||||
/// elements, the last is returned. If the sequence has no elements, the
|
||||
/// method returns `nil`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func minAndMax() -> (min: Element, max: Element)? {
|
||||
return minAndMax(by: <)
|
||||
}
|
||||
}
|
||||
@@ -27,6 +27,8 @@ public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
}
|
||||
|
||||
extension Product2: Sequence {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
|
||||
/// The iterator for a `Product2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
|
||||
@@ -7,6 +7,94 @@
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// trimmingPrefix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the start
|
||||
/// of the collection which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimmingPrefix(while:)` to get a substring without the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimmingPrefix(while: \.isWhitespace)) // "hello, world "
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimmingPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let start = try endOfPrefix(while: predicate)
|
||||
return self[start..<endIndex]
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// trimPrefix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection where Self: RangeReplaceableCollection {
|
||||
/// Mutates a `Collection` by discarding all elements at the start
|
||||
/// of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimPrefix(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trimPrefix(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world "
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trimPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
let end = try endOfPrefix(while: predicate)
|
||||
removeSubrange(startIndex..<end)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection where Self == Self.SubSequence {
|
||||
/// Mutates a `Collection` by discarding all elements at the start
|
||||
/// of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimPrefix(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trimPrefix(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world "
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trimPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
self = try trimmingPrefix(while: predicate)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// trimming(while:) / trimmingSuffix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection {
|
||||
@@ -29,8 +117,132 @@ extension BidirectionalCollection {
|
||||
public func trimming(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let start = try endOfPrefix(while: predicate)
|
||||
let end = try self[start...].startOfSuffix(while: predicate)
|
||||
return self[start..<end]
|
||||
return try trimmingPrefix(while: predicate).trimmingSuffix(while: predicate)
|
||||
}
|
||||
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the end
|
||||
/// of the collection which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimmingSuffix(while:)` to get a substring without the white
|
||||
/// space at the end of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimmingSuffix(while: \.isWhitespace)) // " hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimmingSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let end = try startOfSuffix(while: predicate)
|
||||
return self[startIndex..<end]
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// trim(while:) / trimSuffix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the start
|
||||
/// and at the end of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trim(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trim(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trim(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
replaceSubrange(startIndex..<endIndex, with: try trimming(while: predicate))
|
||||
}
|
||||
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
|
||||
/// of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimSuffix(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trimSuffix(while: \.isWhitespace)
|
||||
/// print(myString) // " hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
@_disfavoredOverload
|
||||
public mutating func trimSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
let start = try startOfSuffix(while: predicate)
|
||||
removeSubrange(start..<endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the start
|
||||
/// and at the end of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trim(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trim(while: \.isWhitespace)
|
||||
/// print(myString) // "hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trim(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
self = try trimming(while: predicate)
|
||||
}
|
||||
|
||||
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
|
||||
/// of it which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimSuffix(while:)` to remove the white
|
||||
/// space at the beginning of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// myString.trimSuffix(while: \.isWhitespace)
|
||||
/// print(myString) // " hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public mutating func trimSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
self = try trimmingSuffix(while: predicate)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class AdjacentPairsTests: XCTestCase {
|
||||
func testEmptySequence() {
|
||||
let pairs = (0...).prefix(0).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testOneElementSequence() {
|
||||
let pairs = (0...).prefix(1).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testTwoElementSequence() {
|
||||
let pairs = (0...).prefix(2).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
}
|
||||
|
||||
func testThreeElementSequence() {
|
||||
let pairs = (0...).prefix(3).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
}
|
||||
|
||||
func testManySequences() {
|
||||
for n in 4...100 {
|
||||
let pairs = (0...).prefix(n).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
func testZeroElements() {
|
||||
let pairs = (0..<0).adjacentPairs()
|
||||
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testOneElement() {
|
||||
let pairs = (0..<1).adjacentPairs()
|
||||
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
|
||||
XCTAssertEqualSequences(pairs, [], by: ==)
|
||||
}
|
||||
|
||||
func testTwoElements() {
|
||||
let pairs = (0..<2).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
|
||||
}
|
||||
|
||||
func testThreeElements() {
|
||||
let pairs = (0..<3).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
|
||||
}
|
||||
|
||||
func testManyElements() {
|
||||
for n in 4...100 {
|
||||
let pairs = (0..<n).adjacentPairs()
|
||||
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
func testIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
(0..<0).adjacentPairs(),
|
||||
(0..<1).adjacentPairs(),
|
||||
(0..<2).adjacentPairs(),
|
||||
(0..<5).adjacentPairs())
|
||||
}
|
||||
|
||||
func testLaziness() {
|
||||
XCTAssertLazySequence((0...).lazy.adjacentPairs())
|
||||
XCTAssertLazyCollection((0..<100).lazy.adjacentPairs())
|
||||
}
|
||||
}
|
||||
@@ -47,8 +47,12 @@ final class ChunkedTests: XCTestCase {
|
||||
func testSimple() {
|
||||
// Example
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
let chunks = names.chunked(on: { $0.first })
|
||||
XCTAssertEqualSequences([["David"], ["Kyle", "Karoy"], ["Nate"]], chunks)
|
||||
let chunks = names.chunked(on: { $0.first! })
|
||||
let expected: [(Character, ArraySlice<String>)] = [
|
||||
("D", ["David"]),
|
||||
("K", ["Kyle", "Karoy"]),
|
||||
("N", ["Nate"])]
|
||||
XCTAssertEqualSequences(expected, chunks, by: ==)
|
||||
|
||||
// Empty sequence
|
||||
XCTAssertEqual(0, names.prefix(0).chunked(on: { $0.first }).count)
|
||||
@@ -59,10 +63,11 @@ final class ChunkedTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testChunkedOn() {
|
||||
validateFruitChunks(fruits.chunked(on: { $0.first }))
|
||||
validateFruitChunks(fruits.chunked(on: { $0.first }).map { $1 })
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(on: { $0.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
validateFruitChunks(lazyChunks.map { $1 })
|
||||
validateIndexTraversals(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedBy() {
|
||||
@@ -70,6 +75,7 @@ final class ChunkedTests: XCTestCase {
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(by: { $0.first == $1.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
validateIndexTraversals(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedLazy() {
|
||||
@@ -77,10 +83,10 @@ final class ChunkedTests: XCTestCase {
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `chunks(ofCount:)`
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
func testChunksOfCount() {
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
@testable import Algorithms
|
||||
|
||||
final class IntersperseTests: XCTestCase {
|
||||
func testSequence() {
|
||||
@@ -62,4 +62,31 @@ final class IntersperseTests: XCTestCase {
|
||||
XCTAssertLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
|
||||
XCTAssertLazyCollection("ABCDE".lazy.interspersed(with: "-"))
|
||||
}
|
||||
|
||||
func testInterspersedMap() {
|
||||
XCTAssertEqualSequences(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
[])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
[0])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: { $0 + $1 + 100 }),
|
||||
[0, 101, 1, 103, 2, 105, 3, 107, 4])
|
||||
}
|
||||
|
||||
func testInterspersedMapLazy() {
|
||||
XCTAssertLazySequence(AnySequence([]).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
XCTAssertLazyCollection((0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
}
|
||||
|
||||
func testInterspersedMapIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
(0..<2).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
final class JoinedTests: XCTestCase {
|
||||
let stringArrays = [
|
||||
[],
|
||||
[""],
|
||||
["", ""],
|
||||
["foo"],
|
||||
["foo", "bar"],
|
||||
["", "", "foo", "", "bar", "baz", ""],
|
||||
]
|
||||
|
||||
func testJoined() {
|
||||
let expected = ["", "", "", "foo", "foobar", "foobarbaz"]
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
// regular sequence
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(), expected)
|
||||
|
||||
// lazy sequence
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(), expected)
|
||||
|
||||
// regular collection
|
||||
XCTAssertEqualSequences(strings.joined(), expected)
|
||||
|
||||
// lazy collection
|
||||
XCTAssertEqualSequences(strings.lazy.joined() as FlattenCollection, expected)
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedByElement() {
|
||||
let separator: Character = " "
|
||||
let expected = ["", "", " ", "foo", "foo bar", " foo bar baz "]
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedBySequence() {
|
||||
let separator = ", "
|
||||
let expected = ["", "", ", ", "foo", "foo, bar", ", , foo, , bar, baz, "]
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedByElementClosure() {
|
||||
let separator = { (left: String, right: String) -> Character in
|
||||
left.isEmpty || right.isEmpty ? " " : "-"
|
||||
}
|
||||
|
||||
let expected = ["", "", " ", "foo", "foo-bar", " foo bar-baz "]
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedBySequenceClosure() {
|
||||
let separator = { (left: String, right: String) in
|
||||
"(\(left.count), \(right.count))"
|
||||
}
|
||||
|
||||
let expected = [
|
||||
"",
|
||||
"",
|
||||
"(0, 0)",
|
||||
"foo",
|
||||
"foo(3, 3)bar",
|
||||
"(0, 0)(0, 3)foo(3, 0)(0, 3)bar(3, 3)baz(3, 0)"
|
||||
]
|
||||
|
||||
for (strings, expected) in zip(stringArrays, expected) {
|
||||
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.joined(by: separator), expected)
|
||||
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedLazy() {
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined())
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: 1))
|
||||
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: { _, _ in 1 }))
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined())
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: 1))
|
||||
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: { _, _ in 1 }))
|
||||
}
|
||||
|
||||
func testJoinedIndexTraversals() {
|
||||
// the last test case takes too long to run
|
||||
for strings in stringArrays.dropLast() {
|
||||
validateIndexTraversals(strings.joined() as FlattenCollection)
|
||||
validateIndexTraversals(strings.joined(by: ", "))
|
||||
}
|
||||
|
||||
for (strings, separator) in product(stringArrays.dropLast(), ["", " ", ", "]) {
|
||||
validateIndexTraversals(strings.joined(by: separator))
|
||||
validateIndexTraversals(strings.lazy.joined(by: { _, _ in separator }))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -185,3 +185,90 @@ final class SortedPrefixTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
final class MinAndMaxTests: XCTestCase {
|
||||
/// Confirms that empty sequences yield no results.
|
||||
func testEmpty() {
|
||||
XCTAssertNil(EmptyCollection<Int>().minAndMax())
|
||||
}
|
||||
|
||||
/// Confirms the same element is used when there is only one.
|
||||
func testSingleElement() {
|
||||
let result = CollectionOfOne(2).minAndMax()
|
||||
XCTAssertEqual(result?.min, 2)
|
||||
XCTAssertEqual(result?.max, 2)
|
||||
}
|
||||
|
||||
/// Confirms the same value is used when all the elements have it.
|
||||
func testSingleValueMultipleElements() {
|
||||
let result = repeatElement(3.3, count: 5).minAndMax()
|
||||
XCTAssertEqual(result?.min, 3.3)
|
||||
XCTAssertEqual(result?.max, 3.3)
|
||||
|
||||
// Even count
|
||||
let result2 = repeatElement("c" as Character, count: 6).minAndMax()
|
||||
XCTAssertEqual(result2?.min, "c")
|
||||
XCTAssertEqual(result2?.max, "c")
|
||||
}
|
||||
|
||||
/// Confirms when the minimum value is constantly updated, but the maximum
|
||||
/// never is.
|
||||
func testRampDown() {
|
||||
let result = (1...5).reversed().minAndMax()
|
||||
XCTAssertEqual(result?.min, 1)
|
||||
XCTAssertEqual(result?.max, 5)
|
||||
|
||||
// Even count
|
||||
let result2 = "fedcba".minAndMax()
|
||||
XCTAssertEqual(result2?.min, "a")
|
||||
XCTAssertEqual(result2?.max, "f")
|
||||
}
|
||||
|
||||
/// Confirms when the maximum value is constantly updated, but the minimum
|
||||
/// never is.
|
||||
func testRampUp() {
|
||||
let result = (1...5).minAndMax()
|
||||
XCTAssertEqual(result?.min, 1)
|
||||
XCTAssertEqual(result?.max, 5)
|
||||
|
||||
// Even count
|
||||
let result2 = "abcdef".minAndMax()
|
||||
XCTAssertEqual(result2?.min, "a")
|
||||
XCTAssertEqual(result2?.max, "f")
|
||||
}
|
||||
|
||||
/// Confirms when the maximum and minimum change during a run.
|
||||
func testUpsAndDowns() {
|
||||
let result = [4, 3, 3, 5, 2, 0, 7, 6].minAndMax()
|
||||
XCTAssertEqual(result?.min, 0)
|
||||
XCTAssertEqual(result?.max, 7)
|
||||
|
||||
// Odd count
|
||||
let result2 = "gfabdec".minAndMax()
|
||||
XCTAssertEqual(result2?.min, "a")
|
||||
XCTAssertEqual(result2?.max, "g")
|
||||
}
|
||||
|
||||
/// Confirms that the given predicate is used to find the min/max.
|
||||
func testPredicate() {
|
||||
let result = (1...5).minAndMax(by: >)
|
||||
XCTAssertEqual(result?.min, 5)
|
||||
XCTAssertEqual(result?.max, 1)
|
||||
|
||||
// Odd count
|
||||
let result2 = "gfabdec".minAndMax(by: >)
|
||||
XCTAssertEqual(result2?.min, "g")
|
||||
XCTAssertEqual(result2?.max, "a")
|
||||
}
|
||||
|
||||
/// Confirms that the min and max are "stable" as defined for minAndMax.
|
||||
func testStability() {
|
||||
for n in 1...10 {
|
||||
let result = repeatElement(0, count: n)
|
||||
.enumerated()
|
||||
.minAndMax(by: { $0.element < $1.element })
|
||||
XCTAssertEqual(result?.min.offset, 0)
|
||||
XCTAssertEqual(result?.max.offset, n - 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,12 +13,12 @@ import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class TrimTests: XCTestCase {
|
||||
|
||||
|
||||
func testEmpty() {
|
||||
let results_empty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_empty, [])
|
||||
}
|
||||
|
||||
|
||||
func testNoMatch() {
|
||||
// No match (nothing trimmed).
|
||||
let results_nomatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
|
||||
@@ -26,34 +26,83 @@ final class TrimTests: XCTestCase {
|
||||
}
|
||||
XCTAssertEqual(results_nomatch, [1, 3, 5, 7, 9, 11, 13, 15])
|
||||
}
|
||||
|
||||
|
||||
func testNoTailMatch() {
|
||||
// No tail match (only trim head).
|
||||
let results_notailmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
|
||||
XCTAssertEqual(results_notailmatch, [11, 13, 15])
|
||||
}
|
||||
|
||||
|
||||
func testNoHeadMatch() {
|
||||
// No head match (only trim tail).
|
||||
let results_noheadmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
|
||||
XCTAssertEqual(results_noheadmatch, [1, 3, 5, 7, 9])
|
||||
}
|
||||
|
||||
|
||||
func testBothEndsMatch() {
|
||||
// Both ends match, some string of >1 elements do not (return that string).
|
||||
let results = [2, 10, 11, 15, 20, 21, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results, [11, 15, 20, 21])
|
||||
}
|
||||
|
||||
|
||||
func testEverythingMatches() {
|
||||
// Everything matches (trim everything).
|
||||
let results_allmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
|
||||
XCTAssertEqual(results_allmatch, [])
|
||||
}
|
||||
|
||||
|
||||
func testEverythingButOneMatches() {
|
||||
// Both ends match, one element does not (trim all except that element).
|
||||
let results_one = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_one, [15])
|
||||
}
|
||||
|
||||
func testTrimmingPrefix() {
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingPrefix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results, [15, 20, 100])
|
||||
}
|
||||
|
||||
func testTrimmingSuffix() {
|
||||
let results = [2, 10, 12, 15, 20, 100].trimmingSuffix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results, [2, 10, 12, 15])
|
||||
}
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
values.trim { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15])
|
||||
}
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimPrefixNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
values.trimPrefix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15, 20, 100])
|
||||
}
|
||||
|
||||
// Self == Self.Subsequence
|
||||
func testTrimSuffixNoAmbiguity() {
|
||||
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
|
||||
values.trimSuffix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [2, 10, 12, 15])
|
||||
}
|
||||
|
||||
func testTrimRangeReplaceable() {
|
||||
var values = [2, 10, 12, 15, 20, 100]
|
||||
values.trim { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15])
|
||||
}
|
||||
|
||||
func testTrimPrefixRangeReplaceable() {
|
||||
var values = [2, 10, 12, 15, 20, 100]
|
||||
values.trimPrefix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [15, 20, 100])
|
||||
}
|
||||
|
||||
func testTrimSuffixRangeReplaceable() {
|
||||
var values = [2, 10, 12, 15, 20, 100]
|
||||
values.trimSuffix { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(values, [2, 10, 12, 15])
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user