mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
040eb49b51 |
No files matched your search
@@ -16,7 +16,7 @@ about: Something isn't working as expected
|
||||
|
||||
Replace this paragraph with a short description of the incorrect incorrect behavior. If this is a regression, please note the last version that the behavior was correct in addition to your current version.
|
||||
|
||||
**Swift Algorithms version:** `1.0.0` or the `main` branch, for example.
|
||||
**Swift Algorithms version:** `0.0.1` or the `main` branch, for example.
|
||||
**Swift version:** Paste the output of `swift --version` here.
|
||||
|
||||
### Checklist
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
version: 1
|
||||
builder:
|
||||
configs:
|
||||
- documentation_targets: [Algorithms]
|
||||
|
||||
+6
-121
@@ -4,7 +4,11 @@
|
||||
Add new items at the end of the relevant section under **Unreleased**.
|
||||
-->
|
||||
|
||||
This project follows semantic versioning.
|
||||
This project follows semantic versioning. While still in major version `0`,
|
||||
source-stability is only guaranteed within minor versions (e.g. between
|
||||
`0.0.3` and `0.0.4`). If you want to guard against potentially source-breaking
|
||||
package updates, you can specify your package dependency using
|
||||
`.upToNextMinor(from: "0.1.0")` as the requirement.
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
@@ -12,116 +16,6 @@ This project follows semantic versioning.
|
||||
|
||||
---
|
||||
|
||||
## [1.1.0] - 2023-08-24
|
||||
|
||||
### Additions
|
||||
|
||||
- New nonmutating `partitioned(by:)` methods that return both the failing and passing elements of a sequence or collection in separate arrays. ([#152])
|
||||
|
||||
```swift
|
||||
let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
|
||||
print(longNames)
|
||||
// Prints "["Vivien", "Marlon"]"
|
||||
print(shortNames)
|
||||
// Prints "["Kim", "Karl"]"
|
||||
```
|
||||
|
||||
- A new `evenlyChunked(in:)` method that chunks a sequence or collection into the specified number of evenly-sized subsequences. ([#96])
|
||||
|
||||
```swift
|
||||
let numbers = Array(0..<10)
|
||||
for chunk in numbers.evenlyChunked(in: 4) {
|
||||
print(chunk)
|
||||
}
|
||||
// Prints:
|
||||
// [0, 1, 2]
|
||||
// [3, 4, 5]
|
||||
// [6, 7]
|
||||
// [8, 9]
|
||||
```
|
||||
|
||||
### Changes
|
||||
|
||||
- The package now has a minimum Swift version of Swift 5.4.
|
||||
|
||||
### Fixes
|
||||
|
||||
- Improvements to documentation, including a new DocC-based documentation structure.
|
||||
|
||||
The 1.1.0 release includes contributions from [dickoff], [gwynne], [mdznr], [natecook1000], [ole], [stephentyrone], and [timvermeulen].
|
||||
Thank you!
|
||||
|
||||
---
|
||||
|
||||
## [1.0.0] - 2021-09-08
|
||||
|
||||
### Changes
|
||||
|
||||
- Most sequence and collection types have been renamed, following a more
|
||||
consistent naming structure:
|
||||
- The `Lazy` prefix was dropped.
|
||||
- Either a `Sequence` or `Collection` suffix was added depending on whether or
|
||||
not the type is unconditionally a collection.
|
||||
- The base name was derived from the name of the method that produces it,
|
||||
including an argument label to disambiguate if necessary.
|
||||
```
|
||||
Chain2 -> Chain2Sequence
|
||||
ChunkedBy -> ChunkedByCollection
|
||||
ChunkedOn -> ChunkedOnCollection
|
||||
ChunkedByCount -> ChunksOfCountCollection
|
||||
Combinations -> CombinationsSequence
|
||||
Cycle -> CycledSequence
|
||||
FiniteCycle -> CycledTimesCollection
|
||||
Indexed -> IndexedCollection
|
||||
Intersperse -> InterspersedSequence
|
||||
LazySplitSequence -> SplitSequence
|
||||
LazySplitCollection -> SplitCollection
|
||||
Permutations -> PermutationsSequence
|
||||
UniquePermutations -> UniquePermutationsSequence
|
||||
Product2 -> Product2Sequence
|
||||
ExclusiveReductions -> ExclusiveReductionsSequence
|
||||
InclusiveReductions -> InclusiveReductionsSequence
|
||||
StrideSequence -> StridingSequence
|
||||
StrideCollection -> StridingCollection
|
||||
Uniqued -> UniquedSequence
|
||||
Windows -> WindowsOfCountCollection
|
||||
```
|
||||
- Types that can only be produced from a lazy sequence chain now unconditionally
|
||||
conform to `LazySequenceProtocol` and wrap the base sequence instead of the
|
||||
lazy wrapper, making some return types slightly simpler.
|
||||
- e.g. `[1, 2, 3].lazy.reductions(+)` now returns
|
||||
`ExclusiveReductionsSequence<[Int]>`, not
|
||||
`ExclusiveReductionsSequence<LazySequence<[Int]>>`.
|
||||
- This concerns `JoinedByClosureSequence`, `JoinedByClosureCollection`,
|
||||
`ExclusiveReductionsSequence`, `InclusiveReductionsSequence`.
|
||||
- The generic parameters of the `ExclusiveReductions` type have been swapped,
|
||||
putting the base collection first and the result type second.
|
||||
- The `Indices` associated type of `IndexedCollection` now matches
|
||||
`Base.Indices`.
|
||||
|
||||
### Removals
|
||||
|
||||
- Previously deprecated type and method names have been removed:
|
||||
- The `Chain` type alias for `Chain2Sequence`
|
||||
- The `chained(with:)` method which was replaced with the `chain(_:_:)` free
|
||||
function
|
||||
- The `LazyChunked` and `Chunked` type aliases for `ChunkedByCollection`
|
||||
- The `rotate(subrange:at:)` and `rotate(at:)` methods which were renamed to
|
||||
`rotate(subrange:toStartAt:)` and `rotate(toStartAt:)` respectively
|
||||
|
||||
### Fixes
|
||||
|
||||
- The `StridingSequence` and `StridingCollection` types now conditionally
|
||||
conform to `LazySequenceProtocol`, allowing the `striding(by:)` method to
|
||||
properly propagate laziness in a lazy sequence chain.
|
||||
- Fixed `chunked(by:)` to always compare two consecutive elements rather than
|
||||
each element with the first element of the current chunk. ([#162])
|
||||
|
||||
The 1.0.0 release includes contributions from [iainsmith], [mdznr], and
|
||||
[timvermeulen]. Thank you!
|
||||
|
||||
## [0.2.1] - 2021-06-01
|
||||
|
||||
### Additions
|
||||
@@ -312,9 +206,7 @@ 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/1.1.0...HEAD
|
||||
[1.1.0]: https://github.com/apple/swift-algorithms/compare/1.0.0...1.1.0
|
||||
[1.0.0]: https://github.com/apple/swift-algorithms/compare/0.2.1...1.0.0
|
||||
[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
|
||||
@@ -343,7 +235,6 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[#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
|
||||
[#96]: https://github.com/apple/swift-algorithms/pull/96
|
||||
[#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
|
||||
@@ -352,8 +243,6 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[#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
|
||||
[#152]: https://github.com/apple/swift-algorithms/pull/152
|
||||
[#162]: https://github.com/apple/swift-algorithms/pull/162
|
||||
|
||||
<!-- Link references for contributors -->
|
||||
|
||||
@@ -363,12 +252,9 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[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
|
||||
[dickoff]: https://github.com/apple/swift-algorithms/commits?author=dickoff
|
||||
[egorzhdan]: https://github.com/apple/swift-algorithms/commits?author=egorzhdan
|
||||
[fedeci]: https://github.com/apple/swift-algorithms/commits?author=fedeci
|
||||
[gwynne]: https://github.com/apple/swift-algorithms/commits?author=gwynne
|
||||
[hashemi]: https://github.com/apple/swift-algorithms/commits?author=hashemi
|
||||
[iainsmith]: https://github.com/apple/swift-algorithms/commits?author=iainsmith
|
||||
[IanKeen]: https://github.com/apple/swift-algorithms/commits?author=IanKeen
|
||||
[iSame7]: https://github.com/apple/swift-algorithms/commits?author=iSame7
|
||||
[karwa]: https://github.com/apple/swift-algorithms/commits?author=karwa
|
||||
@@ -381,7 +267,6 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
[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
|
||||
[ole]: https://github.com/apple/swift-algorithms/commits?author=ole
|
||||
[ollieatkinson]: https://github.com/apple/swift-algorithms/commits?author=ollieatkinson
|
||||
[pmtao]: https://github.com/apple/swift-algorithms/commits?author=pmtao
|
||||
[Qata]: https://github.com/apple/swift-algorithms/commits?author=Qata
|
||||
|
||||
+11
-22
@@ -5,8 +5,7 @@
|
||||
|
||||
Lazily iterates over tuples of adjacent elements.
|
||||
|
||||
This operation is available for any sequence by calling the `adjacentPairs()`
|
||||
method.
|
||||
This operation is available for any sequence by calling the `adjacentPairs()` method.
|
||||
|
||||
```swift
|
||||
let numbers = (1...5)
|
||||
@@ -16,26 +15,21 @@ let pairs = numbers.adjacentPairs()
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `adjacentPairs()` method is declared as a `Sequence` extension returning
|
||||
`AdjacentPairsSequence` and as a `Collection` extension returning
|
||||
`AdjacentPairsCollection`.
|
||||
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>
|
||||
public func adjacentPairs() -> AdjacentPairsSequence<Self>
|
||||
}
|
||||
```
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func adjacentPairs() -> AdjacentPairsCollection<Self>
|
||||
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.
|
||||
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
|
||||
|
||||
@@ -43,21 +37,16 @@ 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.
|
||||
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.
|
||||
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.
|
||||
**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`.
|
||||
Note that in Swift, the spelling `zip(s, s.dropFirst())` is undefined behavior for a single-pass sequence `s`.
|
||||
+4
-4
@@ -25,13 +25,13 @@ the shared conformances of the two underlying types.
|
||||
The `chain(_:_:)` function takes two sequences as arguments:
|
||||
|
||||
```swift
|
||||
public func chain<S1, S2>(_ s1: S1, _ s2: S2) -> Chain2Sequence<S1, S2>
|
||||
public func chain<S1, S2>(_ s1: S1, _ s2: S2) -> Chain2<S1, S2>
|
||||
where S1.Element == S2.Element
|
||||
```
|
||||
|
||||
The resulting `Chain2Sequence` type is a sequence, with conditional conformance
|
||||
to `Collection`, `BidirectionalCollection`, and `RandomAccessCollection` when
|
||||
both the first and second arguments conform.
|
||||
The resulting `Chain2` type is a sequence, with conditional conformance to
|
||||
`Collection`, `BidirectionalCollection`, and `RandomAccessCollection` when both
|
||||
the first and second arguments conform.
|
||||
|
||||
### Naming
|
||||
|
||||
|
||||
+37
-67
@@ -3,16 +3,16 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Chunked.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/ChunkedTests.swift)]
|
||||
|
||||
Break a collection into nonoverlapping subsequences:
|
||||
Break a collection into subsequences where consecutive elements pass a binary
|
||||
predicate, or where all elements in each chunk project to the same value.
|
||||
|
||||
* `chunked(by:)` forms chunks of consecutive elements that pass a binary predicate,
|
||||
* `chunked(on:)` forms chunks of consecutive elements that project to equal values,
|
||||
* `chunks(ofCount:)` forms chunks of a given size, and
|
||||
* `evenlyChunked(in:)` forms a given number of equally-sized chunks.
|
||||
Also, includes a `chunks(ofCount:)` that breaks a collection into subsequences
|
||||
of a given `count`.
|
||||
|
||||
`chunked(by:)` uses a binary predicate to test consecutive elements, separating
|
||||
chunks where the predicate returns `false`. For example, you can chunk a
|
||||
collection into ascending sequences using this method:
|
||||
There are two variations of the `chunked` method: `chunked(by:)` and
|
||||
`chunked(on:)`. `chunked(by:)` uses a binary predicate to test consecutive
|
||||
elements, separating chunks where the predicate returns `false`. For example,
|
||||
you can chunk a collection into ascending sequences using this method:
|
||||
|
||||
```swift
|
||||
let numbers = [10, 20, 30, 10, 40, 40, 10, 20]
|
||||
@@ -20,10 +20,10 @@ let chunks = numbers.chunked(by: { $0 <= $1 })
|
||||
// [[10, 20, 30], [10, 40, 40], [10, 20]]
|
||||
```
|
||||
|
||||
The `chunked(on:)` method, by contrast, takes a projection of each element and
|
||||
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:
|
||||
The result includes both the projected value and the subsequence
|
||||
that groups elements with that projected value:
|
||||
|
||||
```swift
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
@@ -31,10 +31,11 @@ let chunks = names.chunked(on: \.first!)
|
||||
// [("D", ["David"]), ("K", ["Kyle", "Karoy"]), ("N", ["Nate"])]
|
||||
```
|
||||
|
||||
The `chunks(ofCount:)` method takes a `count` parameter (required to be > 0) and
|
||||
separates the collection into chunks of this given count. If the length of the
|
||||
collection is a multiple of the `count` parameter, all chunks will have the
|
||||
a count equal 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"]
|
||||
@@ -45,26 +46,11 @@ let remaining = names.chunks(ofCount: 3)
|
||||
// equivalent to [["David", "Kyle", "Karoy"], ["Nate"]]
|
||||
```
|
||||
|
||||
The `chunks(ofCount:)` method was previously [proposed](proposal) for inclusion
|
||||
in the standard library.
|
||||
The `chunks(ofCount:)` is the subject of an [existing SE proposal][proposal].
|
||||
|
||||
The `evenlyChunked(in:)` method takes a `count` parameter and divides the
|
||||
collection into `count` number of equally-sized chunks. If the length of the
|
||||
collection is not a multiple of the `count` parameter, the chunks at the start
|
||||
will be longer than the chunks at the end.
|
||||
|
||||
```swift
|
||||
let evenChunks = (0..<15).evenlyChunked(in: 3)
|
||||
// equivalent to [0..<5, 5..<10, 10..<15]
|
||||
|
||||
let nearlyEvenChunks = (0..<15).evenlyChunked(in: 4)
|
||||
// equivalent to [0..<4, 4..<8, 8..<12, 12..<15]
|
||||
```
|
||||
|
||||
When "chunking" a collection, the entire collection is included in the result,
|
||||
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 results in a collection equivalent
|
||||
to the original.
|
||||
Joining the result of a chunking method call recreates the original collection.
|
||||
|
||||
```swift
|
||||
c.elementsEqual(c.chunked(...).joined())
|
||||
@@ -75,9 +61,8 @@ c.elementsEqual(c.chunked(...).joined())
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The four methods are added to `Collection`, with matching versions of
|
||||
`chunked(by:)` and `chunked(on:)` that return a lazy wrapper added to
|
||||
`LazyCollectionProtocol`.
|
||||
The two methods are added as extension to `Collection`, with two matching
|
||||
versions that return a lazy wrapper added to `LazyCollectionProtocol`.
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
@@ -86,56 +71,41 @@ extension Collection {
|
||||
) -> [SubSequence]
|
||||
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: (Element) -> Subject
|
||||
) -> [SubSequence]
|
||||
|
||||
public func chunks(ofCount count: Int) -> ChunkedByCount<Self>
|
||||
|
||||
public func evenlyChunked(in count: Int) -> EvenlyChunkedCollection<Self>
|
||||
}
|
||||
on projection: (Element) -> Subject
|
||||
) -> [(Subject, SubSequence)]
|
||||
}
|
||||
|
||||
extension LazyCollectionProtocol {
|
||||
extension LazyCollectionProtocol {
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> ChunkedByCollection<Elements>
|
||||
) -> ChunkedBy<Elements, Element>
|
||||
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> ChunkedOnCollection<Elements, Subject>
|
||||
) -> ChunkedOn<Elements, Subject>
|
||||
}
|
||||
```
|
||||
|
||||
Each of the "chunked" collection types are bidirectional when the wrapped
|
||||
collection is bidirectional. `ChunksOfCountCollection` and
|
||||
`EvenlyChunkedCollection` also conform to `RandomAccessCollection` and
|
||||
`LazySequenceProtocol` when their base collections conform.
|
||||
The `ChunkedBy` and `ChunkedOn` types are bidirectional when the wrapped collection is
|
||||
bidirectional.
|
||||
|
||||
### Complexity
|
||||
|
||||
The eager methods are O(_n_) where _n_ is the number of elements in the
|
||||
collection. The lazy methods are O(_n_) because the start index is pre-computed.
|
||||
The eager methods are O(_n_), the lazy methods are O(_1_).
|
||||
|
||||
### Naming
|
||||
|
||||
The operation performed by these methods is similar to other ways of breaking a
|
||||
collection up into subsequences. In particular, the predicate-based
|
||||
`split(where:)` method looks similar to `chunked(on:)`. You can draw a
|
||||
distinction between these different operations based on the resulting
|
||||
subsequences:
|
||||
The operation performed by these methods is similar to other ways of breaking a collection up into subsequences. In particular, the predicate-based `split(where:)` method looks similar to `chunked(on:)`. You can draw a distinction between these different operations based on the resulting subsequences:
|
||||
|
||||
- `split`: *In the standard library.* Breaks a collection into subsequences, removing any elements that are considered "separators". The original collection cannot be recovered from the result of splitting.
|
||||
- `chunked`: *In this package.* Breaks a collection into subsequences, preserving each element in its initial ordering. Joining the resulting subsequences re-forms the original collection.
|
||||
- `sliced`: *Not included in this package or the stdlib.* Breaks a collection into potentially overlapping subsequences.
|
||||
|
||||
- `split`: *In the standard library.* Breaks a collection into subsequences,
|
||||
removing any elements that are considered "separators". The original collection
|
||||
cannot be recovered from the result of splitting.
|
||||
- `chunked`: *In this package.* Breaks a collection into subsequences,
|
||||
preserving each element in its initial ordering. Joining the resulting
|
||||
subsequences re-forms the original collection.
|
||||
- `sliced`: *Not included in this package or the stdlib.* Breaks a collection
|
||||
into potentially overlapping subsequences.
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**Ruby:** Ruby’s `Enumerable` class defines `chunk_while` and `chunk`, which map
|
||||
to the proposed `chunked(by:)` and `chunked(on:)` methods.
|
||||
|
||||
**Rust:** Rust defines a variety of size-based `chunks` methods, of which the
|
||||
standard version corresponds to the `chunks(ofCount:)` method defined here.
|
||||
**Rust:** Rust defines a variety of size-based `chunks` methods, but doesn’t
|
||||
include any with the functionality described here.
|
||||
+10
-11
@@ -60,28 +60,27 @@ for combo in numbers.combinations(ofCount: 2...3) {
|
||||
## Detailed Design
|
||||
|
||||
The `combinations(ofCount:)` method is declared as a `Collection` extension,
|
||||
and returns a `CombinationsSequence` type:
|
||||
and returns a `Combinations` type:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func combinations(ofCount k: Int) -> CombinationsSequence<Self>
|
||||
public func combinations(ofCount k: Int) -> Combinations<Self>
|
||||
}
|
||||
```
|
||||
|
||||
Since the `CombinationsSequence` type needs to store an array of the
|
||||
collection’s indices and mutate the array to generate each permutation,
|
||||
`CombinationsSequence` only has `Sequence` conformance. Adding `Collection`
|
||||
conformance would require storing the array in the index type, which would in
|
||||
turn lead to copying the array at every index advancement.
|
||||
`CombinationsSequence` does conform to `LazySequenceProtocol` when the base type
|
||||
conforms.
|
||||
Since the `Combinations` type needs to store an array of the collection’s
|
||||
indices and mutate the array to generate each permutation, `Combinations` only
|
||||
has `Sequence` conformance. Adding `Collection` conformance would require
|
||||
storing the array in the index type, which would in turn lead to copying the
|
||||
array at every index advancement. `Combinations` does conform to
|
||||
`LazySequenceProtocol` when the base type conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling `combinations(ofCount:)` accesses the count of the collection, so it’s
|
||||
an O(1) operation for random-access collections, or an O(_n_) operation
|
||||
otherwise. Creating the iterator for a `CombinationsSequence` instance and each
|
||||
call to `CombinationsSequence.Iterator.next()` is an O(_n_) operation.
|
||||
otherwise. Creating the iterator for a `Combinations` instance and each call to
|
||||
`Combinations.Iterator.next()` is an O(_n_) operation.
|
||||
|
||||
### Naming
|
||||
|
||||
|
||||
+2
-3
@@ -37,9 +37,8 @@ extension Collection {
|
||||
|
||||
The `Sequence` version of `compacted()` returns a `CompactedSequence` type,
|
||||
while the `Collection` version returns `CompactedCollection`. The collection
|
||||
has conditional conformance to `BidirectionalCollection` when the base
|
||||
collection conforms, and both have conditional conformance to
|
||||
`LazySequenceProtocol` when the base collection conforms.
|
||||
has conditional conformance to `BidirectionalCollection` and
|
||||
`LazyCollectionProtocol` when the base collection conforms.
|
||||
|
||||
### Naming
|
||||
|
||||
|
||||
+9
-9
@@ -26,20 +26,20 @@ Two new methods are added to collections:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
func cycled() -> CycledSequence<Self>
|
||||
func cycled() -> Cycle<Self>
|
||||
|
||||
func cycled(times: Int) -> CycledTimesCollection<Self>
|
||||
func cycled(times: Int) -> FiniteCycle<Self>
|
||||
}
|
||||
```
|
||||
|
||||
The new `CycledSequence` type is a sequence only, given that the `Collection`
|
||||
protocol design makes infinitely large types impossible/impractical.
|
||||
`CycledSequence` also conforms to `LazySequenceProtocol` when the base type
|
||||
conforms.
|
||||
The new `Cycle` type is a sequence only, given that the `Collection` protocol
|
||||
design makes infinitely large types impossible/impractical. `Cycle` also
|
||||
conforms to `LazySequenceProtocol` when the base type conforms.
|
||||
|
||||
The `CycledTimesCollection` type always has `Collection` conformance, with
|
||||
`BidirectionalCollection`, `RandomAccessCollection`, and `LazySequenceProtocol`
|
||||
conformance when the base type conforms.
|
||||
The `FiniteCycle` type always has `Collection` conformance, with
|
||||
`BidirectionalCollection` conformance
|
||||
when called on a bidirectional collection. `FiniteCycle` also
|
||||
conforms to `LazyCollectionProtocol` when the base type conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
|
||||
+5
-5
@@ -21,15 +21,15 @@ for (i, n) in numbers.indexed() {
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `indexed` method returns an `IndexedCollection` type:
|
||||
The `indexed` method returns an `Indexed` type:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
func indexed() -> IndexedCollection<Self>
|
||||
func indexed() -> Indexed<Self>
|
||||
}
|
||||
```
|
||||
|
||||
`IndexedCollection` scales from a collection up to a random-access collection,
|
||||
depending on its base type. `Indexed` also conforms to `LazySequenceProtocol`
|
||||
when the base type conforms.
|
||||
`Indexed` scales from a collection up to a random-access collection, depending on
|
||||
its base type. `Indexed` also conforms to `LazySequenceProtocol` and
|
||||
`LazyCollectionProtocol` when the base type conforms.
|
||||
|
||||
@@ -25,14 +25,14 @@ A new method is added to sequence:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
func interspersed(with separator: Element) -> InterspersedSequence<Self>
|
||||
func interspersed(with separator: Element) -> Intersperse<Self>
|
||||
}
|
||||
```
|
||||
|
||||
The new `InterspersedSequence` type represents the sequence when the separator
|
||||
is inserted between each element. `InterspersedSequence` conforms to
|
||||
`Collection`, `BidirectionalCollection`, `RandomAccessCollection` and
|
||||
`LazySequenceProtocol` when the base sequence conforms to those respective
|
||||
The new `Intersperse` type represents the sequence when the separator is
|
||||
inserted between each element. `Intersperse` conforms to `Collection`,
|
||||
`BidirectionalCollection`, `RandomAccessCollection`, `LazySequenceProtocol` and
|
||||
`LazyCollectionProtocol` when the base sequence conforms to those respective
|
||||
protocols.
|
||||
|
||||
### Complexity
|
||||
|
||||
+5
-3
@@ -70,7 +70,8 @@ Note that the sequence separator of the closure-less version defined on
|
||||
general be iterated over multiple times.
|
||||
|
||||
The closure-based versions also have lazy variants that are defined on both
|
||||
lazy sequences and collections for the same reason as explained above:
|
||||
`LazySequenceProtocol` and `LazyCollectionProtocol` for the same reason as
|
||||
explained above:
|
||||
|
||||
```swift
|
||||
extension LazySequenceProtocol where Element: Sequence {
|
||||
@@ -83,7 +84,7 @@ extension LazySequenceProtocol where Element: Sequence {
|
||||
) -> JoinedByClosureSequence<Self, Separator>
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol where Self: Collection, Element: Collection {
|
||||
extension LazyCollectionProtocol where Element: Collection {
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureCollection<Self, CollectionOfOne<Element.Element>>
|
||||
@@ -97,4 +98,5 @@ extension LazySequenceProtocol where Self: Collection, Element: Collection {
|
||||
`JoinedBySequence`, `JoinedByClosureSequence`, `JoinedByCollection`, and
|
||||
`JoinedByClosureCollection` conform to `LazySequenceProtocol` when the base
|
||||
sequence conforms. `JoinedByCollection` and `JoinedByClosureCollection` also
|
||||
conform to `BidirectionalCollection` when the base collection conforms.
|
||||
conform to `LazyCollectionProtocol` and `BidirectionalCollection` when the base
|
||||
collection conforms.
|
||||
@@ -0,0 +1,80 @@
|
||||
# LazySplit
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/LazySplit.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/LazySplitTests.swift)]
|
||||
|
||||
Lazily-evaluating versions of
|
||||
[`split(maxSplits:omittingEmptySubsequences:whereSeparator:)`](https://developer.apple.com/documentation/swift/sequence/3128814-split)
|
||||
and [`split(separator:maxSplits:omittingEmptySubsequences:)`](https://developer.apple.com/documentation/swift/sequence/3128818-split),
|
||||
performing the same operation as their counterparts defined on
|
||||
`Sequence` and `Collection`, are added to `LazySequence` and
|
||||
`LazyCollection`. The `LazyCollection` methods allow splitting a
|
||||
collection without allocating additional storage on the heap.
|
||||
|
||||
```swift
|
||||
// Splitting a lazy sequence.
|
||||
let numbers = stride(from: 1, through: 16, by: 1)
|
||||
for subsequence in numbers.lazy.split(
|
||||
whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
) {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints:
|
||||
[1, 2]
|
||||
[4]
|
||||
[7, 8]
|
||||
[11]
|
||||
[13, 14]
|
||||
[16]
|
||||
*/
|
||||
|
||||
// Splitting a lazy collection.
|
||||
let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
for subsequence in line.lazy.split(separator: " ") {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints
|
||||
BLANCHE:
|
||||
I
|
||||
don't
|
||||
want
|
||||
realism.
|
||||
I
|
||||
want
|
||||
magic!
|
||||
*/
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
`LazySequence` and `LazyCollection` are each extended with
|
||||
`split(maxSplits:omittingEmptySubsequences:whereSeparator:)` and
|
||||
`split(separator:maxSplits:omittingEmptySubsequences:)`.
|
||||
|
||||
The `LazySequence` versions of those methods return an instance of
|
||||
`LazySplitSequence`. The `LazyCollection` versions return an instance of
|
||||
`LazySplitCollection`.
|
||||
|
||||
`LazySplitSequence` wraps the sequence to be split, and provides an
|
||||
iterator whose `next` method returns a newly-allocated array containing
|
||||
the elements of each subsequence in the split sequence in turn.
|
||||
|
||||
`LazySplitCollection` wraps the collection to be split. Its `Index`
|
||||
wraps a range of base collection indices. `startIndex` is computed at
|
||||
initialization. Subscripting a `LazySplitCollection` instance returns
|
||||
the slice of the original collection which is the subsequence of the
|
||||
split collection at the given index's position.
|
||||
|
||||
### Complexity
|
||||
|
||||
Iterating a `LazySplitSequence` instance is O(_n_) in time and space,
|
||||
since each subsequence returned is a newly-allocated array.
|
||||
|
||||
Iterating a `LazySplitCollection` instance is O(_n_) in time and O(1) in
|
||||
space, since each subsequence returned is a slice of the base
|
||||
collection. Since `startIndex` is computed at initialization, some or
|
||||
all of the time cost may be paid at initialization. For example, if the
|
||||
base collection contains no elements determined to be separators, it
|
||||
will be iterated entirely on initialization of the split collection, and
|
||||
all subsequent operations on the split collection, such as
|
||||
`index(after:)`, will have complexity O(1).
|
||||
+10
-34
@@ -3,13 +3,9 @@
|
||||
[[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)]
|
||||
|
||||
Returns the smallest or largest elements of this collection, sorted by a
|
||||
predicate or in the order defined by `Comparable` conformance.
|
||||
Returns the smallest or largest elements of this collection, sorted by a predicate or in the order defined by `Comparable` conformance.
|
||||
|
||||
If you need to sort a collection but only need access to a prefix or suffix of
|
||||
the sorted elements, using these methods can give you a performance boost over
|
||||
sorting the entire collection. The order of equal elements is guaranteed to be
|
||||
preserved.
|
||||
If you need to sort a collection but only need access to a prefix or suffix of the sorted elements, using these methods can give you a performance boost over sorting the entire collection. The order of equal elements is guaranteed to be preserved.
|
||||
|
||||
```swift
|
||||
let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
@@ -17,12 +13,9 @@ 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.
|
||||
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.
|
||||
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]
|
||||
@@ -59,8 +52,7 @@ extension Sequence {
|
||||
}
|
||||
```
|
||||
|
||||
Additionally, versions of these methods for `Comparable` types are also
|
||||
provided:
|
||||
Additionally, versions of these methods for `Comparable` types are also provided:
|
||||
|
||||
```swift
|
||||
extension Collection where Element: Comparable {
|
||||
@@ -76,34 +68,18 @@ extension Sequence where Element: Comparable {
|
||||
|
||||
### Complexity
|
||||
|
||||
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)`.
|
||||
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):
|
||||
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.
|
||||
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. It also defines a
|
||||
`minmax_element` function that scans a range for its minimal and maximal
|
||||
elements.
|
||||
**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.
|
||||
**Python:** Defines a `heapq` priority queue that can be used to manually achieve the same result.
|
||||
|
||||
+1
-24
@@ -42,20 +42,6 @@ let p = numbers.partitioningIndex(where: { $0.isMultiple(of: 20) })
|
||||
// numbers[p...] = [20, 40, 60]
|
||||
```
|
||||
|
||||
The standard library’s existing `filter(_:)` method provides functionality to
|
||||
get the elements that do match a given predicate. `partitioned(by:)` returns
|
||||
both the elements that match the predicate as well as those that don’t, as a
|
||||
tuple.
|
||||
|
||||
```swift
|
||||
let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
print(longNames)
|
||||
// Prints "["Vivien", "Marlon"]"
|
||||
print(shortNames)
|
||||
// Prints "["Kim", "Karl"]"
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
All mutating methods are declared as extensions to `MutableCollection`.
|
||||
@@ -83,17 +69,11 @@ extension Collection {
|
||||
where belongsInSecondPartition: (Element) throws -> Bool
|
||||
) rethrows -> Index
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
public func partitioned(
|
||||
by predicate: (Element) throws -> Bool
|
||||
) rethrows -> (falseElements: [Element], trueElements: [Element])
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The existing partition is an O(_n_) operation, where _n_ is the length of the
|
||||
The existing partition is an O(_n_) operations, where _n_ is the length of the
|
||||
range to be partitioned, while the stable partition is O(_n_ log _n_). Both
|
||||
partitions have algorithms with improved performance for bidirectional
|
||||
collections, so it would be ideal for those to be customization points were they
|
||||
@@ -102,9 +82,6 @@ to eventually land in the standard library.
|
||||
`partitioningIndex(where:)` is a slight generalization of a binary search, and
|
||||
is an O(log _n_) operation for random-access collections; O(_n_) otherwise.
|
||||
|
||||
`partitioned(by:)` is an O(_n_) operation, where _n_ is the number of elements
|
||||
in the original sequence.
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**C++:** The `<algorithm>` library defines `partition`, `stable_partition`, and
|
||||
|
||||
+13
-15
@@ -98,20 +98,19 @@ for perm in numbers.permutations(ofCount: 0...) {
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `permutations(ofCount:)` and `uniquePermutations(ofCount:)` methods are
|
||||
declared as `Collection` extensions, and return `PermutationsSequence` and
|
||||
`UniquePermutationsSequence` instances, respectively:
|
||||
The `permutations(ofCount:)` and `uniquePermutations(ofCount:)` methods are declared as `Collection` extensions,
|
||||
and return `Permutations` and `UniquePermutations` instances, respectively:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func permutations(ofCount k: Int? = nil) -> PermutationsSequence<Self>
|
||||
public func permutations<R>(ofCount kRange: R) -> PermutationsSequence<Self>
|
||||
public func permutations(ofCount k: Int? = nil) -> Permutations<Self>
|
||||
public func permutations<R>(ofCount kRange: R) -> Permutations<Self>
|
||||
where R: RangeExpression, R.Bound == Int
|
||||
}
|
||||
|
||||
extension Collection where Element: Hashable {
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutationsSequence<Self>
|
||||
public func uniquePermutations<R>(ofCount kRange: R) -> UniquePermutationsSequence<Self>
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutations<Self>
|
||||
public func uniquePermutations<R>(ofCount kRange: R) -> UniquePermutations<Self>
|
||||
where R: RangeExpression, R.Bound == Int
|
||||
}
|
||||
```
|
||||
@@ -120,19 +119,18 @@ Since both result types need to store an array of the collection’s
|
||||
indices and mutate the array to generate each permutation, they only
|
||||
have `Sequence` conformance. Adding `Collection` conformance would require
|
||||
storing the array in the index type, which would in turn lead to copying the
|
||||
array at every index advancement. The `PermutationsSequence` and
|
||||
`UniquePermutationsSequence` types conforms to `LazySequenceProtocol` when their
|
||||
base type conforms.
|
||||
array at every index advancement. The `Permutations` type
|
||||
conforms to `LazySequenceProtocol` when its base type conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling `permutations()` is an O(1) operation. Creating the iterator for a
|
||||
`PermutationsSequence` instance and each call to
|
||||
`PermutationsSequence.Iterator.next()` is an O(_n_) operation.
|
||||
`Permutations` instance and each call to `Permutations.Iterator.next()` is an
|
||||
O(_n_) operation.
|
||||
|
||||
Calling `uniquePermutations()` is an O(_n_) operation, because it preprocesses
|
||||
the collection to find duplicate elements. Creating the iterator for and each
|
||||
call to `next()` is also an O(_n_) operation.
|
||||
Calling `uniquePermutations()` is an O(_n_) operation, because it preprocesses the
|
||||
collection to find duplicate elements. Creating the iterator for and each call to
|
||||
`next()` is also an O(_n_) operation.
|
||||
|
||||
### Naming
|
||||
|
||||
|
||||
+7
-7
@@ -25,26 +25,26 @@ When either collection is empty, the resulting wrapper collection is also empty.
|
||||
## Detailed Design
|
||||
|
||||
The `product` function takes (at minimum) a sequence and a collection and
|
||||
returns a `Product2Sequence` type:
|
||||
returns a `Product2` type:
|
||||
|
||||
```swift
|
||||
public func product<Base1: Sequence, Base2: Collection>(
|
||||
_ s1: Base1, _ s2: Base2
|
||||
) -> Product2Sequence<Base1, Base2>
|
||||
) -> Product2<Base1, Base2>
|
||||
```
|
||||
|
||||
We require `Collection` conformance for `Base2`, since it needs to be iterated
|
||||
over multiple times. `Base1`, by contrast, is only iterated over a single time,
|
||||
so it can be a sequence.
|
||||
|
||||
The `Product2Sequence` type wraps the base sequence and collection, and acts as
|
||||
a sequence in the base case, upgrading to a collection, a bidirectional
|
||||
The `Product2` type wraps the base sequence and collection, and acts as a
|
||||
sequence in the base case, upgrading to a collection, a bidirectional
|
||||
collection, and a random-access collection when both base collections have those
|
||||
conformances.
|
||||
|
||||
We don't provide higher arities (like `Product3Sequence`, `Product4Sequence`,
|
||||
etc.) at this time to match the standard library's `Zip2Sequence` type. Users
|
||||
can compose multiple calls to `product` if they would like higher arities.
|
||||
We don't provide higher arities (like `Product3`, `Product4`, etc.) at this
|
||||
time to match the standard library's `Zip2` type. Users can compose multiple
|
||||
calls to `product` if they would like higher arities.
|
||||
|
||||
### Complexity
|
||||
|
||||
|
||||
@@ -17,7 +17,7 @@ source.randomSample(count: 4)
|
||||
// e.g. [30, 10, 70, 50]
|
||||
source.randomStableSample(count: 4)
|
||||
// e.g. [20, 30, 80, 100]
|
||||
|
||||
//
|
||||
var rng = SplitMix64(seed: 0)
|
||||
source.randomSample(count: 4, using: &rng)
|
||||
```
|
||||
@@ -146,4 +146,4 @@ performance characteristics as the collection itself, so a user can call
|
||||
The stable version of sampling could theoretically return a lazy wrapper
|
||||
instead of eagerly creating the sample. However, this isn’t well-motivated and
|
||||
poses some challenges, such as needing to store a copy of the random generator
|
||||
and potentially needing to cache the randomly-generated values.
|
||||
and potentially needing to cache the randomly-generated values.
|
||||
+26
-25
@@ -3,8 +3,7 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Reductions.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/ReductionsTests.swift)]
|
||||
|
||||
Produces all the intermediate results of reducing a sequence's elements using a
|
||||
closure.
|
||||
Produces all the intermediate results of reducing a sequence's elements using a closure.
|
||||
|
||||
```swift
|
||||
let exclusiveRunningTotal = (1...5).reductions(0, +)
|
||||
@@ -27,37 +26,39 @@ sequence and another trio are added to `Sequence` which are eagerly evaluated.
|
||||
|
||||
```swift
|
||||
extension LazySequenceProtocol {
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductionsSequence<Result, Self>
|
||||
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductionsSequence<Result, Self>
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductions<Result, Self>
|
||||
|
||||
public func reductions(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductionsSequence<Self>
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductions<Result, Self>
|
||||
|
||||
public func reductions(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductions<Self>
|
||||
}
|
||||
```
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result]
|
||||
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result]
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result]
|
||||
|
||||
public func reductions(
|
||||
_ transform: (Element, Element) throws -> Element
|
||||
) rethrows -> [Element]
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result]
|
||||
|
||||
public func reductions(
|
||||
_ transform: (Element, Element) throws -> Element
|
||||
) rethrows -> [Element]
|
||||
}
|
||||
```
|
||||
|
||||
@@ -101,7 +102,7 @@ takes an initial value to use for the first element in the returned sequence,
|
||||
and another which uses the first value of the base sequence as the initial
|
||||
value. C++ calls these variants exclusive and inclusive respectively and so
|
||||
these terms carry through as the name for the lazy sequences;
|
||||
`ExclusiveReductionsSequence` and `InclusiveReductionsSequence`.
|
||||
`ExclusiveReductions` and `InclusiveReductions`.
|
||||
|
||||
[SE-0045]: https://forums.swift.org/t/review-se-0045-add-scan-prefix-while-drop-while-and-iterate-to-the-stdlib/2382
|
||||
[Issue 25]: https://github.com/apple/swift-algorithms/issues/25
|
||||
|
||||
@@ -1,79 +0,0 @@
|
||||
# Split
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Split.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/SplitTests.swift)]
|
||||
|
||||
Lazily-evaluating versions of
|
||||
[`split(maxSplits:omittingEmptySubsequences:whereSeparator:)`](https://developer.apple.com/documentation/swift/sequence/3128814-split)
|
||||
and [`split(separator:maxSplits:omittingEmptySubsequences:)`](https://developer.apple.com/documentation/swift/sequence/3128818-split),
|
||||
performing the same operation as their counterparts defined on
|
||||
`Sequence` and `Collection`, are added to `LazySequence` and
|
||||
`LazyCollection`. The `LazyCollection` methods allow splitting a
|
||||
collection without allocating additional storage on the heap.
|
||||
|
||||
```swift
|
||||
// Splitting a lazy sequence.
|
||||
let numbers = stride(from: 1, through: 16, by: 1)
|
||||
for subsequence in numbers.lazy.split(
|
||||
whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
) {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints:
|
||||
[1, 2]
|
||||
[4]
|
||||
[7, 8]
|
||||
[11]
|
||||
[13, 14]
|
||||
[16]
|
||||
*/
|
||||
|
||||
// Splitting a lazy collection.
|
||||
let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
for subsequence in line.lazy.split(separator: " ") {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints
|
||||
BLANCHE:
|
||||
I
|
||||
don't
|
||||
want
|
||||
realism.
|
||||
I
|
||||
want
|
||||
magic!
|
||||
*/
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
`LazySequence` and `LazyCollection` are each extended with
|
||||
`split(maxSplits:omittingEmptySubsequences:whereSeparator:)` and
|
||||
`split(separator:maxSplits:omittingEmptySubsequences:)`.
|
||||
|
||||
The `LazySequence` versions of those methods return an instance of
|
||||
`SplitSequence`. The `LazyCollection` versions return an instance of
|
||||
`SplitCollection`.
|
||||
|
||||
`SplitSequence` wraps the sequence to be split, and provides an iterator whose
|
||||
`next` method returns a newly-allocated array containing the elements of each
|
||||
subsequence in the split sequence in turn.
|
||||
|
||||
`SplitCollection` wraps the collection to be split. Its `Index` wraps a range of
|
||||
base collection indices. `startIndex` is computed at initialization.
|
||||
Subscripting a `SplitCollection` instance returns the slice of the original
|
||||
collection which is the subsequence of the split collection at the given index's
|
||||
position.
|
||||
|
||||
### Complexity
|
||||
|
||||
Iterating a `SplitSequence` instance is O(_n_) in time and space, since each
|
||||
subsequence returned is a newly-allocated array.
|
||||
|
||||
Iterating a `SplitCollection` instance is O(_n_) in time and O(1) in space,
|
||||
since each subsequence returned is a slice of the base collection. Since
|
||||
`startIndex` is computed at initialization, some or all of the time cost may be
|
||||
paid at initialization. For example, if the base collection contains no elements
|
||||
determined to be separators, it will be iterated entirely on initialization of
|
||||
the split collection, and all subsequent operations on the split collection,
|
||||
such as `index(after:)`, will have complexity O(1).
|
||||
+18
-25
@@ -3,7 +3,7 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Stride.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/StrideTests.swift)]
|
||||
|
||||
Step over the elements of a sequence elements by a specified amount.
|
||||
A type that steps over sequence elements by the specified amount.
|
||||
|
||||
This is available through the `striding(by:)` method on any `Sequence`.
|
||||
|
||||
@@ -11,39 +11,33 @@ This is available through the `striding(by:)` method on any `Sequence`.
|
||||
(0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
```
|
||||
|
||||
If the stride is larger than the length of the sequence, the resulting wrapper
|
||||
only contains the first element.
|
||||
If the stride is larger than the count, the resulting wrapper only contains the
|
||||
first element.
|
||||
|
||||
The stride amount must be a positive value.
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `striding(by:)` method is declared in extension of both `Sequence` and
|
||||
`Collection`:
|
||||
The `striding(by:)` method is declared as a `Sequence` extension, and returns a
|
||||
`Stride` type:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func striding(by step: Int) -> StridingSequence<Self>
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
public func striding(by step: Int) -> StridingCollection<Self>
|
||||
public func striding(by step: Int) -> Stride<Self>
|
||||
}
|
||||
```
|
||||
|
||||
The reason for this distinction is subtle. The `StridingSequence.Iterator` type
|
||||
is unable to skip over multiple elements of the wrapped iterator at once since
|
||||
that's not part of `IteratorProtocol`'s interface. In order to efficiently
|
||||
stride over collections that provide a fast way of skipping multiple elements at
|
||||
once, the `StridingCollection` type was added which does not provide a custom
|
||||
`Iterator` type and therefore always strides over the underlying collection in
|
||||
the fastest way possible. See the related
|
||||
[GitHub issue](https://github.com/apple/swift-algorithms/issues/63) for more
|
||||
information.
|
||||
A custom `Index` type is defined so that it's not possible to get confused when trying
|
||||
to access an index of the stride collection.
|
||||
|
||||
A careful thought was given to the composition of these strides by giving a
|
||||
custom implementation to `index(_:offsetBy:limitedBy)` which multiplies the
|
||||
offset by the stride amount.
|
||||
```swift
|
||||
[0, 1, 2, 3, 4].striding(by: 2)[1] // == 1
|
||||
[0, 1, 2, 3, 4].striding(by: 2).map { $0 }[1] // == 2
|
||||
```
|
||||
|
||||
A careful thought was given to the composition of these strides by giving a custom
|
||||
implementation to `index(_:offsetBy:limitedBy)` which multiplies the offset by the
|
||||
stride amount.
|
||||
|
||||
```swift
|
||||
base.index(i.base, offsetBy: distance * stride, limitedBy: base.endIndex)
|
||||
@@ -58,9 +52,8 @@ The following two lines of code are equivalent, including performance:
|
||||
|
||||
### Complexity
|
||||
|
||||
The call to `striding(by: k)` is always O(_1_) and access to the next value in
|
||||
the stride is O(_1_) if the collection conforms to `RandomAccessCollection`,
|
||||
otherwise O(_k_).
|
||||
The call to `striding(by: k)` is always O(_1_) and access to the next value in the stride
|
||||
is O(_1_) if the collection conforms to `RandomAccessCollection`, otherwise O(_k_).
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
|
||||
+14
-14
@@ -3,37 +3,37 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Suffix.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/SuffixTests.swift)]
|
||||
|
||||
This function returns a subsequence containing the elements from the end of the
|
||||
collection until predicate returns `false` and skipping the remaining elements.
|
||||
|
||||
This example uses `suffix(while: )` to iterate through collection of integers
|
||||
from the end until the predicate returns false, in this case when `$0 <= 5`
|
||||
This function returns a subsequence containing the elements from the end of the collection until predicate returns `false` and skipping the remaining elements.
|
||||
|
||||
This example uses `suffix(while: )` to iterate through collection of integers from the end until the predicate returns false, in this case when `$0 <= 5`
|
||||
```swift
|
||||
(0...10).suffix(while: { $0 > 5 } // == [6,7,8,9,10]
|
||||
```
|
||||
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `suffix(while:)` function is added as a method on an extension of
|
||||
`BidirectionalCollection`.
|
||||
The `suffix(while:)` function is added as a method on an extension of `BidirectionalCollection`.
|
||||
|
||||
|
||||
```swift
|
||||
extension BidirectionalCollection {
|
||||
public func suffix(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
|
||||
public func suffix(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
}
|
||||
```
|
||||
|
||||
This method requires `BidirectionalCollection` for an efficient implementation
|
||||
which visits as few elements as possible. Swift's protocol allows for backward
|
||||
traversal of a collection as well as access to *last* property of a collection.
|
||||
This method requires `BidirectionalCollection` for an efficient implementation which visits as few elements as possible. Swift's protocol allows for backward traversal of a collection as well as access to *last* property of a collection.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling this method is O(*n*), where *n* is the length of the collection.
|
||||
|
||||
|
||||
### Naming
|
||||
|
||||
The function's name resembles that of an existing Swift function
|
||||
`prefix(while:)`, which performs same operation however in the forward direction
|
||||
of the collection. Hence, as this function traverses from the end of the
|
||||
collection, `suffix(while:)` is an appropriate name.
|
||||
The function's name resembles that of an existing Swift function `prefix(while:)`, which performs same operation however in the forward direction of the collection. Hence, as this function traverses from the end of the collection, `suffix(while:)` is an appropriate name.
|
||||
|
||||
|
||||
|
||||
+36
-52
@@ -3,11 +3,10 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Trim.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/TrimTests.swift)]
|
||||
|
||||
Returns a `SubSequence` formed by discarding all elements at the start and end
|
||||
of the collection which satisfy the given predicate.
|
||||
Returns a `SubSequence` formed by discarding all elements at the start and end of the collection
|
||||
which satisfy the given predicate.
|
||||
|
||||
This example uses `trimming(while:)` to get a substring without the white space
|
||||
at the beginning and end of the string.
|
||||
This example uses `trimming(while:)` to get a substring without the white space at the beginning and end of the string.
|
||||
|
||||
```swift
|
||||
let myString = " hello, world "
|
||||
@@ -23,42 +22,37 @@ A new method is added to `BidirectionalCollection`:
|
||||
|
||||
```swift
|
||||
extension BidirectionalCollection {
|
||||
public func trimming(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
|
||||
public func trimming(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
}
|
||||
```
|
||||
|
||||
This method requires `BidirectionalCollection` for an efficient implementation
|
||||
which visits as few elements as possible.
|
||||
This method requires `BidirectionalCollection` for an efficient implementation which visits as few elements as possible.
|
||||
|
||||
A less-efficient implementation is _possible_ for any `Collection`, which would
|
||||
involve always traversing the entire collection. This implementation is not
|
||||
provided, as it would mean developers of generic algorithms who forget to add
|
||||
the `BidirectionalCollection` constraint will receive that inefficient
|
||||
implementation:
|
||||
A less-efficient implementation is _possible_ for any `Collection`, which would involve always traversing the
|
||||
entire collection. This implementation is not provided, as it would mean developers of generic algorithms who forget
|
||||
to add the `BidirectionalCollection` constraint will receive that inefficient implementation:
|
||||
|
||||
```swift
|
||||
func myAlgorithm<Input>(input: Input) where Input: Collection {
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses least-efficient implementation.
|
||||
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses least-efficient implementation.
|
||||
}
|
||||
|
||||
func myAlgorithm2<Input>(input: Input) where Input: BidirectionalCollection {
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses most-efficient implementation.
|
||||
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses most-efficient implementation.
|
||||
}
|
||||
```
|
||||
|
||||
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.
|
||||
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.
|
||||
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 "
|
||||
@@ -66,8 +60,7 @@ 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.
|
||||
Also mutating variants for all the methods already existing and the new ones are added.
|
||||
```swift
|
||||
var myString = " hello, world "
|
||||
myString.trim(while: \.isWhitespace)
|
||||
@@ -80,8 +73,7 @@ Calling this method is O(_n_).
|
||||
|
||||
### Naming
|
||||
|
||||
The name `trim` has precedent in other programming languages. Another popular
|
||||
alternative might be `strip`.
|
||||
The name `trim` has precedent in other programming languages. Another popular alternative might be `strip`.
|
||||
|
||||
| Example usage | Languages |
|
||||
|-|-|
|
||||
@@ -106,38 +98,30 @@ alternative might be `strip`.
|
||||
| TRIM(''string'') | SQL |
|
||||
| String.trim ''string'' | OCaml 4+ |
|
||||
|
||||
Note: This is an abbreviated list from Wikipedia.
|
||||
[Full table](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim)
|
||||
Note: This is an abbreviated list from Wikipedia. [Full table](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim)
|
||||
|
||||
The standard library includes a variety of methods which perform similar
|
||||
operations:
|
||||
The standard library includes a variety of methods which perform similar operations:
|
||||
|
||||
- Firstly, there are `dropFirst(Int)` and `dropLast(Int)`. These return slices
|
||||
but do not support user-defined predicates. If the collection's `count` is less
|
||||
than the number of elements to drop, they return an empty slice.
|
||||
- Secondly, there is `drop(while:)`, which also returns a slice and is
|
||||
equivalent to a 'left-trim' (trimming from the head but not the tail). If the
|
||||
entire collection is dropped, this method returns an empty slice.
|
||||
- Thirdly, there are `removeFirst(Int)` and `removeLast(Int)` which do not
|
||||
return slices and actually mutate the collection. If the collection's `count` is
|
||||
less than the number of elements to remove, this method triggers a runtime
|
||||
error.
|
||||
- Lastly, there are the `popFirst()` and `popLast()` methods, which work like
|
||||
`removeFirst()` and `removeLast()`, except they do not trigger a runtime error
|
||||
for empty collections.
|
||||
- Firstly, there are `dropFirst(Int)` and `dropLast(Int)`. These return slices but do not support user-defined predicates.
|
||||
If the collection's `count` is less than the number of elements to drop, they return an empty slice.
|
||||
- Secondly, there is `drop(while:)`, which also returns a slice and is equivalent to a 'left-trim' (trimming from the head but not the tail).
|
||||
If the entire collection is dropped, this method returns an empty slice.
|
||||
- Thirdly, there are `removeFirst(Int)` and `removeLast(Int)` which do not return slices and actually mutate the collection.
|
||||
If the collection's `count` is less than the number of elements to remove, this method triggers a runtime error.
|
||||
- Lastly, there are the `popFirst()` and `popLast()` methods, which work like `removeFirst()` and `removeLast()`,
|
||||
except they do not trigger a runtime error for empty collections.
|
||||
|
||||
The closest neighbours to this function would be the `drop` family of methods.
|
||||
Unfortunately, unlike `dropFirst(Int)`,the name `drop(while:)` does not specify
|
||||
which end(s) of the collection it operates on. Moreover, one could easily
|
||||
The closest neighbours to this function would be the `drop` family of methods. Unfortunately, unlike `dropFirst(Int)`,
|
||||
the name `drop(while:)` does not specify which end(s) of the collection it operates on. Moreover, one could easily
|
||||
mistake code such as:
|
||||
|
||||
```swift
|
||||
let result = myString.drop(while: \.isWhitespace)
|
||||
```
|
||||
|
||||
With a lazy filter that drops _all_ whitespace characters regardless of where
|
||||
they are in the string. Besides that, the root `trim` leads to clearer, more
|
||||
concise code, which is more aligned with other programming languages:
|
||||
With a lazy filter that drops _all_ whitespace characters regardless of where they are in the string.
|
||||
Besides that, the root `trim` leads to clearer, more concise code, which is more aligned with other programming
|
||||
languages:
|
||||
|
||||
```swift
|
||||
// Does `result` contain the input, trimmed of certain elements?
|
||||
@@ -146,4 +130,4 @@ let result = input.dropFromBothEnds(while: { ... })
|
||||
|
||||
// No such ambiguity here.
|
||||
let result = input.trimming(while: { ... })
|
||||
```
|
||||
```
|
||||
+12
-11
@@ -5,9 +5,10 @@
|
||||
|
||||
Methods to strip repeated elements from a sequence or collection.
|
||||
|
||||
The `uniqued()` method returns a sequence, dropping duplicate elements from a
|
||||
sequence. The `uniqued(on:)` method does the same, using the result of the given
|
||||
closure to determine the "uniqueness" of each element.
|
||||
The `uniqued()` method returns a sequence, dropping duplicate elements
|
||||
from a sequence. The `uniqued(on:)` method does the same, using
|
||||
the result of the given closure to determine the "uniqueness" of each
|
||||
element.
|
||||
|
||||
```swift
|
||||
let numbers = [1, 2, 3, 3, 2, 3, 3, 2, 2, 2, 1]
|
||||
@@ -18,14 +19,14 @@ let unique = numbers.uniqued()
|
||||
|
||||
## Detailed Design
|
||||
|
||||
Both methods are available for sequences, with the simplest limited to when the
|
||||
element type conforms to `Hashable`. Both methods preserve the relative order of
|
||||
the elements. `uniqued(on:)` has a matching lazy version that is added to
|
||||
`LazySequenceProtocol`.
|
||||
Both methods are available for sequences, with the simplest limited to
|
||||
when the element type conforms to `Hashable`. Both methods preserve
|
||||
the relative order of the elements. `uniqued(on:)` has a matching lazy
|
||||
version that is added to `LazySequenceProtocol`.
|
||||
|
||||
```swift
|
||||
extension Sequence where Element: Hashable {
|
||||
func uniqued() -> UniquedSequence<Self, Element>
|
||||
func uniqued() -> Uniqued<Self, Element>
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
@@ -34,15 +35,15 @@ extension Sequence {
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
func uniqued<Subject>(on projection: @escaping (Element) -> Subject) -> UniquedSequence<Self, Subject>
|
||||
func uniqued<Subject>(on projection: @escaping (Element) -> Subject) -> Uniqued<Self, Subject>
|
||||
where Subject: Hashable
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The eager `uniqued(on:)` method is O(_n_) in both time and space complexity. The
|
||||
lazy versions are O(_1_).
|
||||
The eager `uniqued(on:)` method is O(_n_) in both time and space complexity.
|
||||
The lazy versions are O(_1_).
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
|
||||
+8
-12
@@ -6,9 +6,7 @@
|
||||
Break a collection into overlapping subsequences where
|
||||
elements are slices from the original collection.
|
||||
|
||||
The `windows(ofCount:)` method takes a size as a parameter and returns a
|
||||
collection of subsequences. Each element of the returned collection is a
|
||||
successive overlapping slice of the given size.
|
||||
The `windows(ofCount:)` method takes a size as a parameter and returns a collection of subsequences. Each element of the returned collection is a successive overlapping slice of the given size.
|
||||
|
||||
```swift
|
||||
let swift = "swift"
|
||||
@@ -23,26 +21,24 @@ The `windows(ofCount:)` method is added as an extension `Collection` method:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func windows(ofCount count: Int) -> WindowsOfCountCollection<Self>
|
||||
public func windows(ofCount count: Int) -> Windows<Self>
|
||||
}
|
||||
```
|
||||
|
||||
If a size larger than the collection's length is specified, the returned
|
||||
collection is empty.
|
||||
If a size larger than the collection's length is specified, the returned collection is empty.
|
||||
|
||||
```swift
|
||||
[1, 2, 3].windows(ofCount: 5).isEmpty // true
|
||||
```
|
||||
|
||||
The resulting `WindowsOfCountCollection` type is a collection, with conditional
|
||||
conformance to the `BidirectionalCollection`, `RandomAccessCollection`, and
|
||||
`LazySequenceProtocol` protocols when the base collection conforms.
|
||||
The resulting `Windows` type is a collection, with conditional conformance to the
|
||||
`BidirectionalCollection`, `RandomAccessCollection`, and
|
||||
`LazyCollectionProtocol` protocols when the base collection conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
The call to `windows(ofCount: k)` is O(1) if the collection conforms to
|
||||
`RandomAccessCollection`, otherwise O(_k_). Access to each successive window is
|
||||
O(1).
|
||||
`RandomAccessCollection`, otherwise O(_k_). Access to each successive window is O(1).
|
||||
|
||||
### Naming
|
||||
|
||||
@@ -55,5 +51,5 @@ and `permutations(ofCount:)`.
|
||||
### Comparison with other languages
|
||||
|
||||
[rust](https://doc.rust-lang.org/std/slice/struct.Windows.html) has
|
||||
`std::slice::Windows` which is a method available on slices. It has the same
|
||||
`std::slice::Windows` which is a method available on slices. It has the same
|
||||
semantics as described here.
|
||||
+2
-2
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:5.4
|
||||
// swift-tools-version:5.1
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
@@ -20,7 +20,7 @@ let package = Package(
|
||||
targets: ["Algorithms"]),
|
||||
],
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-numerics.git", from: "1.0.0"),
|
||||
.package(url: "https://github.com/apple/swift-numerics", from: "0.0.1"),
|
||||
],
|
||||
targets: [
|
||||
.target(
|
||||
|
||||
@@ -27,7 +27,6 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
#### Subsetting operations
|
||||
|
||||
- [`compacted()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Compacted.md): Drops the `nil`s from a sequence or collection, unwrapping the remaining elements.
|
||||
- [`partitioned(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): Returns the elements in a sequence or collection that do and do not match a given predicate.
|
||||
- [`randomSample(count:)`, `randomSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection.
|
||||
- [`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.
|
||||
@@ -49,7 +48,7 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
- [`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/Split.md): Lazy versions of the Standard Library's eager operations that split sequences and collections into subsequences separated by the specified separator element.
|
||||
- [`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.
|
||||
|
||||
## Adding Swift Algorithms as a Dependency
|
||||
@@ -58,25 +57,32 @@ To use the `Algorithms` library in a SwiftPM project,
|
||||
add the following line to the dependencies in your `Package.swift` file:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-algorithms", from: "1.0.0"),
|
||||
.package(url: "https://github.com/apple/swift-algorithms", from: "0.0.1"),
|
||||
```
|
||||
|
||||
Include `"Algorithms"` as a dependency for your executable target:
|
||||
Because `Algorithms` is under active development,
|
||||
source-stability is only guaranteed within minor versions (e.g. between `0.0.3` and `0.0.4`).
|
||||
If you don't want potentially source-breaking package updates,
|
||||
use this dependency specification instead:
|
||||
|
||||
```swift
|
||||
.target(name: "<target>", dependencies: [
|
||||
.product(name: "Algorithms", package: "swift-algorithms"),
|
||||
]),
|
||||
.package(url: "https://github.com/apple/swift-algorithms", .upToNextMinor(from: "0.1.0")),
|
||||
```
|
||||
|
||||
Finally, add `import Algorithms` to your source code.
|
||||
Finally, include `"Algorithms"` as a dependency for your executable target:
|
||||
|
||||
## Source Stability
|
||||
|
||||
The Swift Algorithms package is source stable; version numbers follow [Semantic Versioning](https://semver.org/). Source breaking changes to public API can only land in a new major version.
|
||||
|
||||
The public API of version 1.0 of the `swift-algorithms` package consists of non-underscored declarations that are marked `public` in the `Algorithms` module. Interfaces that aren't part of the public API may continue to change in any release, including patch releases.
|
||||
|
||||
Future minor versions of the package may introduce changes to these rules as needed.
|
||||
|
||||
We'd like this package to quickly embrace Swift language and toolchain improvements that are relevant to its mandate. Accordingly, from time to time, we expect that new versions of this package will require clients to upgrade to a more recent Swift toolchain release. Requiring a new Swift release will only require a minor version bump.
|
||||
```swift
|
||||
let package = Package(
|
||||
// name, platforms, products, etc.
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-algorithms", from: "0.1.0"),
|
||||
// other dependencies
|
||||
],
|
||||
targets: [
|
||||
.target(name: "<target>", dependencies: [
|
||||
.product(name: "Algorithms", package: "swift-algorithms"),
|
||||
]),
|
||||
// other targets
|
||||
]
|
||||
)
|
||||
```
|
||||
@@ -10,13 +10,13 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a sequence of overlapping adjacent pairs of the elements of this
|
||||
/// 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:
|
||||
/// sequence.
|
||||
/// The following example uses the `adjacentPairs()` method to iterate over
|
||||
/// adjacent pairs of integers:
|
||||
///
|
||||
/// for pair in (1...).prefix(5).adjacentPairs() {
|
||||
/// print(pair)
|
||||
@@ -25,11 +25,6 @@ extension Sequence {
|
||||
/// // Prints "(2, 3)"
|
||||
/// // Prints "(3, 4)"
|
||||
/// // Prints "(4, 5)"
|
||||
///
|
||||
/// The resulting sequence is empty when called on an empty or single-element
|
||||
/// sequence.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func adjacentPairs() -> AdjacentPairsSequence<Self> {
|
||||
AdjacentPairsSequence(base: self)
|
||||
@@ -37,7 +32,7 @@ extension Sequence {
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of overlapping adjacent pairs of the elements of this
|
||||
/// A collection of adjacent pairs of elements built from an underlying
|
||||
/// collection.
|
||||
///
|
||||
/// In an `AdjacentPairsCollection`, the elements of the *i*th pair are the
|
||||
@@ -52,11 +47,6 @@ extension Collection {
|
||||
/// // Prints "(2, 3)"
|
||||
/// // Prints "(3, 4)"
|
||||
/// // Prints "(4, 5)"
|
||||
///
|
||||
/// The resulting collection is empty when called on an empty or
|
||||
/// single-element collection.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func adjacentPairs() -> AdjacentPairsCollection<Self> {
|
||||
AdjacentPairsCollection(base: self)
|
||||
@@ -79,8 +69,7 @@ public struct AdjacentPairsSequence<Base: Sequence> {
|
||||
}
|
||||
|
||||
extension AdjacentPairsSequence {
|
||||
/// The iterator for an `AdjacentPairsSequence` or `AdjacentPairsCollection`
|
||||
/// instance.
|
||||
/// The iterator for an `AdjacentPairsSequence` or `AdjacentPairsCollection`.
|
||||
public struct Iterator {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
@@ -137,20 +126,44 @@ public struct AdjacentPairsCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let secondBaseIndex: Base.Index
|
||||
public let startIndex: Index
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
self.secondBaseIndex = base.isEmpty
|
||||
? base.endIndex
|
||||
: base.index(after: base.startIndex)
|
||||
|
||||
// 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 {
|
||||
/// A position in an `AdjacentPairsCollection` instance.
|
||||
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
|
||||
@@ -165,7 +178,7 @@ extension AdjacentPairsCollection {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
public static func ==(lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.first == rhs.first
|
||||
}
|
||||
|
||||
@@ -177,13 +190,6 @@ extension AdjacentPairsCollection {
|
||||
}
|
||||
|
||||
extension AdjacentPairsCollection: Collection {
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(
|
||||
first: secondBaseIndex == base.endIndex ? base.endIndex : base.startIndex,
|
||||
second: secondBaseIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(first: base.endIndex, second: base.endIndex)
|
||||
@@ -299,7 +305,7 @@ extension AdjacentPairsCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension AdjacentPairsCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension AdjacentPairsCollection.Index: Hashable where Base.Index: Hashable {
|
||||
@inlinable
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A concatenation of two sequences with the same element type.
|
||||
public struct Chain2Sequence<Base1: Sequence, Base2: Sequence>
|
||||
public struct Chain2<Base1: Sequence, Base2: Sequence>
|
||||
where Base1.Element == Base2.Element
|
||||
{
|
||||
/// The first sequence in this chain.
|
||||
@@ -28,8 +28,8 @@ public struct Chain2Sequence<Base1: Sequence, Base2: Sequence>
|
||||
}
|
||||
}
|
||||
|
||||
extension Chain2Sequence: Sequence {
|
||||
/// The iterator for a `Chain2Sequence` instance.
|
||||
extension Chain2: Sequence {
|
||||
/// The iterator for a `Chain2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator1: Base1.Iterator
|
||||
@@ -38,7 +38,7 @@ extension Chain2Sequence: Sequence {
|
||||
internal var iterator2: Base2.Iterator
|
||||
|
||||
@inlinable
|
||||
internal init(_ concatenation: Chain2Sequence) {
|
||||
internal init(_ concatenation: Chain2) {
|
||||
iterator1 = concatenation.base1.makeIterator()
|
||||
iterator2 = concatenation.base2.makeIterator()
|
||||
}
|
||||
@@ -55,8 +55,8 @@ extension Chain2Sequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection {
|
||||
/// A position in a `Chain2Sequence` instance.
|
||||
extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
/// A position in a `Chain2` collection.
|
||||
public struct Index: Comparable {
|
||||
// The internal index representation, which can either be an index of the
|
||||
// first collection or the second. The `endIndex` of the first collection
|
||||
@@ -64,7 +64,7 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
// from the penultimate index of the first collection to the start of the
|
||||
// second.
|
||||
@usableFromInline
|
||||
internal enum Representation: Equatable {
|
||||
internal enum Representation : Equatable {
|
||||
case first(Base1.Index)
|
||||
case second(Base2.Index)
|
||||
}
|
||||
@@ -115,7 +115,7 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(second: base2.endIndex)
|
||||
return Index(second: base2.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
@@ -263,7 +263,7 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
|
||||
}
|
||||
}
|
||||
|
||||
extension Chain2Sequence: BidirectionalCollection
|
||||
extension Chain2: BidirectionalCollection
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
@@ -280,7 +280,7 @@ extension Chain2Sequence: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension Chain2Sequence: RandomAccessCollection
|
||||
extension Chain2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -314,6 +314,20 @@ extension Chain2Sequence: RandomAccessCollection
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func chain<S1, S2>(_ s1: S1, _ s2: S2) -> Chain2Sequence<S1, S2> {
|
||||
Chain2Sequence(base1: s1, base2: s2)
|
||||
public func chain<S1, S2>(_ s1: S1, _ s2: S2) -> Chain2<S1, S2> {
|
||||
Chain2(base1: s1, base2: s2)
|
||||
}
|
||||
|
||||
// MARK: - Deprecations
|
||||
|
||||
@available(*, deprecated, renamed: "Chain2")
|
||||
public typealias Chain = Chain2
|
||||
|
||||
extension Sequence {
|
||||
@available(*, deprecated, message: "Use the chain(_:_:) function, instead.")
|
||||
public func chained<S: Sequence>(with other: S) -> Chain2<Self, S>
|
||||
where Element == S.Element
|
||||
{
|
||||
Chain2(base1: self, base2: other)
|
||||
}
|
||||
}
|
||||
+100
-393
@@ -13,7 +13,7 @@
|
||||
/// predicate.
|
||||
///
|
||||
/// Call `lazy.chunked(by:)` on a collection to create an instance of this type.
|
||||
public struct ChunkedByCollection<Base: Collection, Subject> {
|
||||
public struct ChunkedBy<Base: Collection, Subject> {
|
||||
/// The collection that this instance provides a view onto.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -26,9 +26,9 @@ public struct ChunkedByCollection<Base: Collection, Subject> {
|
||||
@usableFromInline
|
||||
internal let belongInSameGroup: (Subject, Subject) -> Bool
|
||||
|
||||
/// The end index of the first chunk.
|
||||
/// The upper bound of the first chunk.
|
||||
@usableFromInline
|
||||
internal var endOfFirstChunk: Base.Index
|
||||
internal var firstUpperBound: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
@@ -39,15 +39,15 @@ public struct ChunkedByCollection<Base: Collection, Subject> {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
self.belongInSameGroup = belongInSameGroup
|
||||
self.endOfFirstChunk = base.startIndex
|
||||
self.firstUpperBound = base.startIndex
|
||||
|
||||
if !base.isEmpty {
|
||||
endOfFirstChunk = endOfChunk(startingAt: base.startIndex)
|
||||
firstUpperBound = endOfChunk(startingAt: base.startIndex)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCollection: Collection {
|
||||
extension ChunkedBy: LazyCollectionProtocol {
|
||||
/// A position in a chunked collection.
|
||||
public struct Index: Comparable {
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@@ -77,18 +77,14 @@ extension ChunkedByCollection: Collection {
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func endOfChunk(startingAt start: Base.Index) -> Base.Index {
|
||||
var subject = projection(base[start])
|
||||
|
||||
return base[base.index(after: start)...].endOfPrefix(while: { element in
|
||||
let nextSubject = projection(element)
|
||||
defer { subject = nextSubject }
|
||||
return belongInSameGroup(subject, nextSubject)
|
||||
})
|
||||
let subject = projection(base[start])
|
||||
return base[base.index(after: start)...]
|
||||
.endOfPrefix(while: { belongInSameGroup(subject, projection($0)) })
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex..<endOfFirstChunk)
|
||||
Index(base.startIndex..<firstUpperBound)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
@@ -112,9 +108,9 @@ extension ChunkedByCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
extension ChunkedBy.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension ChunkedByCollection: BidirectionalCollection
|
||||
extension ChunkedBy: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
/// Returns the index in the base collection of the start of the chunk ending
|
||||
@@ -122,13 +118,11 @@ extension ChunkedByCollection: BidirectionalCollection
|
||||
@inlinable
|
||||
internal func startOfChunk(endingAt end: Base.Index) -> Base.Index {
|
||||
let indexBeforeEnd = base.index(before: end)
|
||||
var subject = projection(base[indexBeforeEnd])
|
||||
|
||||
return base[..<indexBeforeEnd].startOfSuffix(while: { element in
|
||||
let nextSubject = projection(element)
|
||||
defer { subject = nextSubject }
|
||||
return belongInSameGroup(nextSubject, subject)
|
||||
})
|
||||
// Get the projected value of the last element in the range ending at `end`.
|
||||
let subject = projection(base[indexBeforeEnd])
|
||||
return base[..<indexBeforeEnd]
|
||||
.startOfSuffix(while: { belongInSameGroup(projection($0), subject) })
|
||||
}
|
||||
|
||||
@inlinable
|
||||
@@ -139,30 +133,32 @@ extension ChunkedByCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCollection: LazyCollectionProtocol {}
|
||||
@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 ChunkedOnCollection<Base: Collection, Subject: Equatable> {
|
||||
public struct ChunkedOn<Base: Collection, Subject> {
|
||||
@usableFromInline
|
||||
internal var chunked: ChunkedByCollection<Base, Subject>
|
||||
internal var chunked: ChunkedBy<Base, Subject>
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
projection: @escaping (Base.Element) -> Subject
|
||||
projection: @escaping (Base.Element) -> Subject,
|
||||
belongInSameGroup: @escaping (Subject, Subject) -> Bool
|
||||
) {
|
||||
self.chunked = ChunkedByCollection(
|
||||
base: base,
|
||||
projection: projection,
|
||||
belongInSameGroup: ==)
|
||||
self.chunked = ChunkedBy(base: base, projection: projection, belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedOnCollection: Collection {
|
||||
public typealias Index = ChunkedByCollection<Base, Subject>.Index
|
||||
extension ChunkedOn: LazyCollectionProtocol {
|
||||
public typealias Index = ChunkedBy<Base, Subject>.Index
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
@@ -187,258 +183,43 @@ extension ChunkedOnCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedOnCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
extension ChunkedOn: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
public func index(before i: Index) -> Index {
|
||||
chunked.index(before: i)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedOnCollection: LazyCollectionProtocol {}
|
||||
|
||||
/// A collection wrapper that evenly breaks a collection into a given number of
|
||||
/// chunks.
|
||||
public struct EvenlyChunkedCollection<Base: Collection> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// The number of equal chunks the base collection is divided into.
|
||||
@usableFromInline
|
||||
internal let numberOfChunks: Int
|
||||
|
||||
/// The count of the base collection.
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The upper bound of the first chunk.
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, numberOfChunks: Int) {
|
||||
self.base = base
|
||||
self.numberOfChunks = numberOfChunks
|
||||
self.baseCount = base.count
|
||||
self.firstUpperBound = base.startIndex
|
||||
|
||||
if numberOfChunks > 0 {
|
||||
firstUpperBound = endOfChunk(startingAt: base.startIndex, offset: 0)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension EvenlyChunkedCollection {
|
||||
/// Returns the number of chunks with size `smallChunkSize + 1` at the start
|
||||
/// of this collection.
|
||||
@inlinable
|
||||
internal var numberOfLargeChunks: Int {
|
||||
baseCount % numberOfChunks
|
||||
}
|
||||
|
||||
/// Returns the size of a chunk at a given offset.
|
||||
@inlinable
|
||||
internal func sizeOfChunk(offset: Int) -> Int {
|
||||
let isLargeChunk = offset < numberOfLargeChunks
|
||||
return baseCount / numberOfChunks + (isLargeChunk ? 1 : 0)
|
||||
}
|
||||
|
||||
/// Returns the index in the base collection of the end of the chunk starting
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func endOfChunk(startingAt start: Base.Index, offset: Int) -> Base.Index {
|
||||
base.index(start, offsetBy: sizeOfChunk(offset: offset))
|
||||
}
|
||||
|
||||
/// Returns the index in the base collection of the start of the chunk ending
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func startOfChunk(endingAt end: Base.Index, offset: Int) -> Base.Index {
|
||||
base.index(end, offsetBy: -sizeOfChunk(offset: offset))
|
||||
}
|
||||
|
||||
/// Returns the index that corresponds to the chunk that starts at the given
|
||||
/// base index.
|
||||
@inlinable
|
||||
internal func indexOfChunk(startingAt start: Base.Index, offset: Int) -> Index {
|
||||
guard offset != numberOfChunks else { return endIndex }
|
||||
let end = endOfChunk(startingAt: start, offset: offset)
|
||||
return Index(start..<end, offset: offset)
|
||||
}
|
||||
|
||||
/// Returns the index that corresponds to the chunk that ends at the given
|
||||
/// base index.
|
||||
@inlinable
|
||||
internal func indexOfChunk(endingAt end: Base.Index, offset: Int) -> Index {
|
||||
let start = startOfChunk(endingAt: end, offset: offset)
|
||||
return Index(start..<end, offset: offset)
|
||||
}
|
||||
}
|
||||
|
||||
extension EvenlyChunkedCollection: Collection {
|
||||
public struct Index: Comparable {
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@usableFromInline
|
||||
internal var baseRange: Range<Base.Index>
|
||||
|
||||
/// The offset corresponding to the chunk at this position. The first chunk
|
||||
/// has offset `0` and all other chunks have an offset `1` greater than the
|
||||
/// previous.
|
||||
@usableFromInline
|
||||
internal var offset: Int
|
||||
|
||||
@inlinable
|
||||
internal init(_ baseRange: Range<Base.Index>, offset: Int) {
|
||||
self.baseRange = baseRange
|
||||
self.offset = offset
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.offset == rhs.offset
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.offset < rhs.offset
|
||||
}
|
||||
}
|
||||
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex..<firstUpperBound, offset: 0)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base.endIndex..<base.endIndex, offset: numberOfChunks)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
let start = i.baseRange.upperBound
|
||||
return indexOfChunk(startingAt: start, offset: i.offset + 1)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Element {
|
||||
precondition(position != endIndex)
|
||||
return base[position.baseRange]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
/// Returns the base distance between two `EvenChunksCollection` indices
|
||||
/// from the end of one to the start of the other, when given their offsets.
|
||||
func baseDistance(from offsetA: Int, to offsetB: Int) -> Int {
|
||||
let smallChunkSize = baseCount / numberOfChunks
|
||||
let numberOfChunks = (offsetB - offsetA) - 1
|
||||
|
||||
let largeChunksEnd = Swift.min(self.numberOfLargeChunks, offsetB)
|
||||
let largeChunksStart = Swift.min(self.numberOfLargeChunks, offsetA + 1)
|
||||
let numberOfLargeChunks = largeChunksEnd - largeChunksStart
|
||||
|
||||
return smallChunkSize * numberOfChunks + numberOfLargeChunks
|
||||
}
|
||||
|
||||
if distance == 0 {
|
||||
return i
|
||||
} else if distance > 0 {
|
||||
let offset = i.offset + distance
|
||||
let baseOffset = baseDistance(from: i.offset, to: offset)
|
||||
let start = base.index(i.baseRange.upperBound, offsetBy: baseOffset)
|
||||
return indexOfChunk(startingAt: start, offset: offset)
|
||||
} else {
|
||||
let offset = i.offset + distance
|
||||
let baseOffset = baseDistance(from: offset, to: i.offset)
|
||||
let end = base.index(i.baseRange.lowerBound, offsetBy: -baseOffset)
|
||||
return indexOfChunk(endingAt: end, offset: offset)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int, limitedBy limit: Index) -> Index? {
|
||||
if distance >= 0 {
|
||||
if (0..<distance).contains(self.distance(from: i, to: limit)) {
|
||||
return nil
|
||||
}
|
||||
} else {
|
||||
if (0..<(-distance)).contains(self.distance(from: limit, to: i)) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
return index(i, offsetBy: distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
end.offset - start.offset
|
||||
}
|
||||
}
|
||||
|
||||
extension EvenlyChunkedCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension EvenlyChunkedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't advance before startIndex")
|
||||
return indexOfChunk(endingAt: i.baseRange.lowerBound, offset: i.offset - 1)
|
||||
}
|
||||
}
|
||||
|
||||
extension EvenlyChunkedCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension EvenlyChunkedCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension EvenlyChunkedCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.chunked(by:) / lazy.chunked(on:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
extension LazyCollectionProtocol {
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Parameter belongInSameGroup: A closure that takes two adjacent elements
|
||||
/// of the sequence and returns whether or not they belong in the same group.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> ChunkedByCollection<Elements, Element> {
|
||||
ChunkedByCollection(
|
||||
) -> ChunkedBy<Elements, Element> {
|
||||
ChunkedBy(
|
||||
base: elements,
|
||||
projection: { $0 },
|
||||
belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to equal values.
|
||||
///
|
||||
/// - Parameter projection: A closure that takes an element in the sequence
|
||||
/// and returns an `Equatable` value that can be used to determine if adjacent
|
||||
/// elements belong in the same group.
|
||||
/// grouping elements that project to the same value.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunked<Subject>(
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> ChunkedOnCollection<Elements, Subject> {
|
||||
ChunkedOnCollection(
|
||||
) -> ChunkedOn<Elements, Subject> {
|
||||
ChunkedOn(
|
||||
base: elements,
|
||||
projection: projection)
|
||||
projection: projection,
|
||||
belongInSameGroup: ==)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -447,12 +228,8 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of subsequences of this collection, chunked by the
|
||||
/// given predicate.
|
||||
///
|
||||
/// - Parameter belongInSameGroup: A closure that takes two adjacent elements
|
||||
/// of the collection and returns whether or not they belong in the same
|
||||
/// group.
|
||||
/// 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
|
||||
@@ -469,23 +246,19 @@ extension Collection {
|
||||
if try !belongInSameGroup(current, element) {
|
||||
result.append(self[start..<index])
|
||||
start = index
|
||||
current = element
|
||||
}
|
||||
current = element
|
||||
}
|
||||
|
||||
if start != endIndex {
|
||||
result.append(self[start...])
|
||||
result.append(self[start..<endIndex])
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to equal values.
|
||||
///
|
||||
/// - Parameter projection: A closure that takes an element in the collection
|
||||
/// and returns an `Equatable` value that can be used to determine if adjacent
|
||||
/// elements belong in the same group.
|
||||
/// grouping elements that project to the same value.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
@@ -508,7 +281,7 @@ extension Collection {
|
||||
}
|
||||
|
||||
if start != endIndex {
|
||||
result.append((subject, self[start...]))
|
||||
result.append((subject, self[start..<endIndex]))
|
||||
}
|
||||
|
||||
return result
|
||||
@@ -519,18 +292,17 @@ extension Collection {
|
||||
// chunks(ofCount:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection that presents the elements of its base collection in
|
||||
/// `SubSequence` chunks of any given count.
|
||||
/// A collection that presents the elements of its base collection
|
||||
/// in `SubSequence` chunks of any given count.
|
||||
///
|
||||
/// A `ChunksOfCountCollection` is a lazy view on the base `Collection`, but it
|
||||
/// does not implicitly confer laziness on algorithms applied to its result. In
|
||||
/// other words, for ordinary collections `c`:
|
||||
/// A `ChunkedByCount` is a lazy view on the base Collection, but it does not implicitly confer
|
||||
/// laziness on algorithms applied to its result. In other words, for ordinary collections `c`:
|
||||
///
|
||||
/// * `c.chunks(ofCount: 3)` does not create new storage
|
||||
/// * `c.chunks(ofCount: 3).map(f)` maps eagerly and returns a new array
|
||||
/// * `c.lazy.chunks(ofCount: 3).map(f)` maps lazily and returns a
|
||||
/// `LazyMapCollection`
|
||||
public struct ChunksOfCountCollection<Base: Collection> {
|
||||
/// * `c.lazy.chunks(ofCount: 3).map(f)` maps lazily and returns a `LazyMapCollection`
|
||||
public struct ChunkedByCount<Base: Collection> {
|
||||
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
@usableFromInline
|
||||
@@ -540,10 +312,10 @@ public struct ChunksOfCountCollection<Base: Collection> {
|
||||
internal let chunkCount: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var endOfFirstChunk: Base.Index
|
||||
internal var startUpperBound: Base.Index
|
||||
|
||||
/// Creates a view instance that presents the elements of `base` in
|
||||
/// `SubSequence` chunks of the given count.
|
||||
/// Creates a view instance that presents the elements of `base`
|
||||
/// in `SubSequence` chunks of the given count.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
@@ -551,16 +323,16 @@ public struct ChunksOfCountCollection<Base: Collection> {
|
||||
self.base = _base
|
||||
self.chunkCount = _chunkCount
|
||||
|
||||
// Compute the start index upfront in order to make start index a O(1)
|
||||
// lookup.
|
||||
self.endOfFirstChunk = _base.index(
|
||||
// Compute the start index upfront in order to make
|
||||
// start index a O(1) lookup.
|
||||
self.startUpperBound = _base.index(
|
||||
_base.startIndex, offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunksOfCountCollection: Collection {
|
||||
extension ChunkedByCount: Collection {
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
internal let baseRange: Range<Base.Index>
|
||||
@@ -574,9 +346,8 @@ extension ChunksOfCountCollection: Collection {
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(_baseRange: base.startIndex..<endOfFirstChunk)
|
||||
Index(_baseRange: base.startIndex..<startUpperBound)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(_baseRange: base.endIndex..<base.endIndex)
|
||||
@@ -585,13 +356,13 @@ extension ChunksOfCountCollection: Collection {
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Element {
|
||||
precondition(i != endIndex, "Index out of range")
|
||||
precondition(i < endIndex, "Index out of range")
|
||||
return base[i.baseRange]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Advancing past end index")
|
||||
precondition(i < endIndex, "Advancing past end index")
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.upperBound, offsetBy: chunkCount,
|
||||
limitedBy: base.endIndex
|
||||
@@ -600,30 +371,30 @@ extension ChunksOfCountCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunksOfCountCollection.Index: Comparable {
|
||||
extension ChunkedByCount.Index: Comparable {
|
||||
@inlinable
|
||||
public static func == (lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index) -> Bool {
|
||||
public static func == (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: ChunksOfCountCollection.Index,
|
||||
rhs: ChunksOfCountCollection.Index) -> Bool {
|
||||
public static func < (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunksOfCountCollection:
|
||||
extension ChunkedByCount:
|
||||
BidirectionalCollection, RandomAccessCollection
|
||||
where Base: RandomAccessCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Advancing past start index")
|
||||
precondition(i > startIndex, "Advancing past start index")
|
||||
|
||||
var offset = chunkCount
|
||||
if i.baseRange.lowerBound == base.endIndex {
|
||||
let remainder = base.count % chunkCount
|
||||
let remainder = base.count%chunkCount
|
||||
if remainder != 0 {
|
||||
offset = remainder
|
||||
}
|
||||
@@ -637,7 +408,7 @@ where Base: RandomAccessCollection {
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunksOfCountCollection {
|
||||
extension ChunkedByCount {
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
let distance =
|
||||
@@ -705,12 +476,12 @@ extension ChunksOfCountCollection {
|
||||
_ i: Index, _ distance: Int
|
||||
) -> Int {
|
||||
if i == endIndex {
|
||||
let remainder = base.count % chunkCount
|
||||
let remainder = base.count%chunkCount
|
||||
// We have to take it into account when calculating offsets.
|
||||
if remainder != 0 {
|
||||
// Distance "minus" one (at this point distance is negative) because we
|
||||
// need to adjust for the last position that have a variadic (remainder)
|
||||
// number of elements.
|
||||
// Distance "minus" one(at this point distance is negative)
|
||||
// because we need to adjust for the last position that have
|
||||
// a variadic(remainder) number of elements.
|
||||
return ((distance + 1) * chunkCount) - remainder
|
||||
}
|
||||
}
|
||||
@@ -731,7 +502,7 @@ extension ChunksOfCountCollection {
|
||||
)
|
||||
}
|
||||
|
||||
// Helper to compute `index(offsetBy:)` index.
|
||||
// Helper to compute index(offsetBy:) index.
|
||||
@inlinable
|
||||
internal func makeOffsetIndex(
|
||||
from i: Index, baseBound: Base.Index, distance: Int, baseDistance: Int,
|
||||
@@ -744,12 +515,13 @@ extension ChunksOfCountCollection {
|
||||
|
||||
if let limit = limit {
|
||||
if baseIdx == nil {
|
||||
// If we passed the bounds while advancing forward, and the limit is the
|
||||
// `endIndex`, since the computation on `base` don't take into account
|
||||
// the remainder, we have to make sure that passing the bound was
|
||||
// because of the distance not just because of a remainder. Special
|
||||
// casing is less expensive than always using `count` (which could be
|
||||
// O(n) for non-random access collection base) to compute the base
|
||||
// If we past the bounds while advancing forward and the
|
||||
// limit is the `endIndex`, since the computation on base
|
||||
// don't take into account the remainder, we have to make
|
||||
// sure that passing the bound was because of the distance
|
||||
// not just because of a remainder. Special casing is less
|
||||
// expensive than always use count(which could be O(n) for
|
||||
// non-random access collection base) to compute the base
|
||||
// distance taking remainder into account.
|
||||
if baseDistance > 0 && limit == endIndex {
|
||||
if self.distance(from: i, to: limit) < distance {
|
||||
@@ -777,98 +549,33 @@ extension ChunksOfCountCollection {
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of subsequences, each with up to the specified
|
||||
/// length.
|
||||
/// Returns a `ChunkedCollection<Self>` view presenting the elements
|
||||
/// in chunks with count of the given count parameter.
|
||||
///
|
||||
/// If the number of elements in the collection is evenly divided by `count`,
|
||||
/// then every chunk will have a length equal to `count`. Otherwise, every
|
||||
/// chunk but the last will have a length equal to `count`, with the
|
||||
/// remaining elements in the last chunk.
|
||||
/// - Parameter size: The size of the chunks. If the count parameter
|
||||
/// is evenly divided by the count of the base `Collection` all the
|
||||
/// chunks will have the count equals to size.
|
||||
/// Otherwise, the last chunk will contain the remaining elements.
|
||||
///
|
||||
/// let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
/// for chunk in numbers.chunks(ofCount: 5) {
|
||||
/// print(chunk)
|
||||
/// }
|
||||
/// // [1, 2, 3, 4, 5]
|
||||
/// // [6, 7, 8, 9, 10]
|
||||
/// let c = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
/// print(c.chunks(ofCount: 5).map(Array.init))
|
||||
/// // [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
|
||||
///
|
||||
/// for chunk in numbers.chunks(ofCount: 3) {
|
||||
/// print(chunk)
|
||||
/// }
|
||||
/// // [1, 2, 3]
|
||||
/// // [4, 5, 5]
|
||||
/// // [7, 8, 9]
|
||||
/// // [10]
|
||||
///
|
||||
/// - Parameter count: The desired size of each chunk.
|
||||
/// - Returns: A collection of consescutive, non-overlapping subseqeunces of
|
||||
/// this collection, where each subsequence (except possibly the last) has
|
||||
/// the length `count`.
|
||||
///
|
||||
/// - Complexity: O(1) if the collection conforms to `RandomAccessCollection`;
|
||||
/// otherwise, O(*k*), where *k* is equal to `count`.
|
||||
/// print(c.chunks(ofCount: 3).map(Array.init))
|
||||
/// // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunks(ofCount count: Int) -> ChunksOfCountCollection<Self> {
|
||||
public func chunks(ofCount count: Int) -> ChunkedByCount<Self> {
|
||||
precondition(count > 0, "Cannot chunk with count <= 0!")
|
||||
return ChunksOfCountCollection(_base: self, _chunkCount: count)
|
||||
return ChunkedByCount(_base: self, _chunkCount: count)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunksOfCountCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
extension ChunkedByCount.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension ChunksOfCountCollection: LazySequenceProtocol
|
||||
// Lazy conditional conformance.
|
||||
extension ChunkedByCount: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension ChunksOfCountCollection: LazyCollectionProtocol
|
||||
extension ChunkedByCount: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// evenlyChunked(in:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of evenly divided consecutive subsequences of this
|
||||
/// collection.
|
||||
///
|
||||
/// This method divides the collection into a given number of evenly sized
|
||||
/// chunks. If the length of the collection is not divisible by `count`, the
|
||||
/// chunks at the start will be longer than the chunks at the end, like in
|
||||
/// this example:
|
||||
///
|
||||
/// for chunk in "Hello, world!".evenlyChunked(in: 5) {
|
||||
/// print(chunk)
|
||||
/// }
|
||||
/// // "Hel"
|
||||
/// // "lo,"
|
||||
/// // " wo"
|
||||
/// // "rl"
|
||||
/// // "d!"
|
||||
///
|
||||
/// If the number passed as `count` is greater than the number of elements in
|
||||
/// the collection, the result will include one or more empty subsequences.
|
||||
///
|
||||
/// for chunk in "Hi!".evenlyChunked(in: 5) {
|
||||
/// print(chunk)
|
||||
/// }
|
||||
/// // "H"
|
||||
/// // "i"
|
||||
/// // "!"
|
||||
/// // ""
|
||||
/// // ""
|
||||
///
|
||||
/// - Parameter count: The number of chunks to evenly divide this collection
|
||||
/// into. If this collection is non-empty, `count` must be greater than
|
||||
/// zero; otherwise, `count` may be zero or greater.
|
||||
/// - Returns: A collection of `count` subsequences of this collection,
|
||||
/// divided as evenly as possible.
|
||||
///
|
||||
/// - Complexity: O(1) if the collection conforms to `RandomAccessCollection`;
|
||||
/// otherwise, O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func evenlyChunked(in count: Int) -> EvenlyChunkedCollection<Self> {
|
||||
precondition(count >= 0, "Can't divide into a negative number of chunks")
|
||||
precondition(count > 0 || isEmpty, "Can't divide a non-empty collection into 0 chunks")
|
||||
return EvenlyChunkedCollection(base: self, numberOfChunks: count)
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection wrapper that generates combinations of a base collection.
|
||||
public struct CombinationsSequence<Base: Collection> {
|
||||
public struct Combinations<Base: Collection> {
|
||||
/// The collection to iterate over for combinations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -19,15 +19,12 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The range of accepted sizes of combinations.
|
||||
///
|
||||
/// - Note: This may be `nil` if the attempted range entirely exceeds the
|
||||
/// upper bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>?
|
||||
|
||||
/// Initializes a `CombinationsSequence` for all combinations of `base` of
|
||||
/// size `k`.
|
||||
///
|
||||
/// Initializes a `Combinations` for all combinations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for combinations.
|
||||
/// - k: The expected size of each combination.
|
||||
@@ -36,9 +33,8 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
self.init(base, kRange: k...k)
|
||||
}
|
||||
|
||||
/// Initializes a `CombinationsSequence` for all combinations of `base` of
|
||||
/// sizes within a given range.
|
||||
///
|
||||
/// Initializes a `Combinations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for combinations.
|
||||
/// - kRange: The range of accepted sizes of combinations.
|
||||
@@ -80,14 +76,13 @@ public struct CombinationsSequence<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension CombinationsSequence: Sequence {
|
||||
/// The iterator for a `CombinationsSequence` instance.
|
||||
extension Combinations: Sequence {
|
||||
/// The iterator for a `Combinations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// The current range of accepted sizes of combinations.
|
||||
///
|
||||
/// - Note: The range is contracted until empty while iterating over
|
||||
/// combinations of different sizes. When the range is empty, iteration is
|
||||
/// finished.
|
||||
@@ -104,7 +99,7 @@ extension CombinationsSequence: Sequence {
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@inlinable
|
||||
internal init(_ combinations: CombinationsSequence) {
|
||||
internal init(_ combinations: Combinations) {
|
||||
self.base = combinations.base
|
||||
self.kRange = combinations.kRange ?? 0..<0
|
||||
self.indexes = Array(combinations.base.indices.prefix(kRange.lowerBound))
|
||||
@@ -180,14 +175,12 @@ extension CombinationsSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
}
|
||||
}
|
||||
|
||||
extension CombinationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension Combinations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// combinations(ofCount:)
|
||||
@@ -250,16 +243,16 @@ extension Collection {
|
||||
/// limited range is empty, the resulting sequence has no elements.
|
||||
///
|
||||
/// - Parameter kRange: The range of numbers of elements to include in each
|
||||
/// combination.
|
||||
/// combination.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `CombinationsSequence` accesses the `count` of the base collection.
|
||||
/// is the number of elements in the base collection, since `Combinations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func combinations<R: RangeExpression>(
|
||||
ofCount kRange: R
|
||||
) -> CombinationsSequence<Self> where R.Bound == Int {
|
||||
CombinationsSequence(self, kRange: kRange)
|
||||
) -> Combinations<Self> where R.Bound == Int {
|
||||
return Combinations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Returns a collection of combinations of this collection's elements, with
|
||||
@@ -289,11 +282,11 @@ extension Collection {
|
||||
/// - Parameter k: The number of elements to include in each combination.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `CombinationsSequence` accesses the `count` of the base collection.
|
||||
/// is the number of elements in the base collection, since `Combinations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func combinations(ofCount k: Int) -> CombinationsSequence<Self> {
|
||||
public func combinations(ofCount k: Int) -> Combinations<Self> {
|
||||
precondition(k >= 0, "Can't have combinations with a negative number of elements.")
|
||||
return CombinationsSequence(self, k: k)
|
||||
return Combinations(self, k: k)
|
||||
}
|
||||
}
|
||||
@@ -9,8 +9,7 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A `Sequence` that iterates over every non-nil element from the original
|
||||
/// `Sequence`.
|
||||
/// A `Sequence` that iterates over every non-nil element from the original `Sequence`.
|
||||
public struct CompactedSequence<Base: Sequence, Element>: Sequence
|
||||
where Base.Element == Element? {
|
||||
|
||||
@@ -43,15 +42,14 @@ public struct CompactedSequence<Base: Sequence, Element>: Sequence
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator())
|
||||
return Iterator(base: base.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a new `Sequence` that iterates over every non-nil element from the
|
||||
/// original `Sequence`.
|
||||
///
|
||||
/// Produces the same result as `c.compactMap { $0 }`.
|
||||
/// Returns a new `Sequence` that iterates over every non-nil element
|
||||
/// from the original `Sequence`.
|
||||
/// It produces the same result as `c.compactMap { $0 }`.
|
||||
///
|
||||
/// let c = [1, nil, 2, 3, nil]
|
||||
/// for num in c.compacted() {
|
||||
@@ -73,8 +71,7 @@ extension Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
/// A `Collection` that iterates over every non-nil element from the original
|
||||
/// `Collection`.
|
||||
/// A `Collection` that iterates over every non-nil element from the original `Collection`.
|
||||
public struct CompactedCollection<Base: Collection, Element>: Collection
|
||||
where Base.Element == Element? {
|
||||
|
||||
@@ -146,10 +143,9 @@ extension CompactedCollection.Index: Hashable
|
||||
where Base.Index: Hashable {}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a new `Collection` that iterates over every non-nil element from
|
||||
/// the original `Collection`.
|
||||
///
|
||||
/// Produces the same result as `c.compactMap { $0 }`.
|
||||
/// Returns a new `Collection` that iterates over every non-nil element
|
||||
/// from the original `Collection`.
|
||||
/// It produces the same result as `c.compactMap { $0 }`.
|
||||
///
|
||||
/// let c = [1, nil, 2, 3, nil]
|
||||
/// for num in c.compacted() {
|
||||
@@ -163,12 +159,11 @@ extension Collection {
|
||||
/// element and iterates over every non-nil element from the original
|
||||
/// `Collection`.
|
||||
///
|
||||
/// Complexity: O(*n*) where *n* is the number of elements in the
|
||||
/// Complexity: O(*n*) where *n* is the number of elements in the
|
||||
/// original `Collection`.
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
|
||||
where Element == Unwrapped?
|
||||
{
|
||||
where Element == Unwrapped? {
|
||||
CompactedCollection(base: self)
|
||||
}
|
||||
}
|
||||
@@ -180,5 +175,7 @@ extension Collection {
|
||||
extension CompactedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension CompactedCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
extension CompactedCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension CompactedCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
@@ -0,0 +1,114 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
@available(macOS 12.0, *)
|
||||
extension Collection {
|
||||
public func parallelMap<T>(
|
||||
parallelism requestedParallelism: Int? = nil,
|
||||
_ transform: @escaping (Element) async throws -> T) async throws -> [T]
|
||||
{
|
||||
let defaultParallelism = 2
|
||||
let parallelism = requestedParallelism ?? defaultParallelism
|
||||
|
||||
let count = self.count
|
||||
let buffer = UnsafeMutableBufferPointer<T>.allocate(capacity: count)
|
||||
defer { buffer.deallocate() }
|
||||
|
||||
return try await withThrowingTaskGroup(of: (Int, T).self) { group in
|
||||
var current = self.startIndex
|
||||
var submitted = 0
|
||||
|
||||
func submitNext() async throws {
|
||||
group.async { [submitted, i = current] in
|
||||
let value = try await transform(self[i])
|
||||
return (submitted, value)
|
||||
}
|
||||
submitted += 1
|
||||
formIndex(after: ¤t)
|
||||
}
|
||||
|
||||
// Submit initial tasks.
|
||||
for _ in 0..<Swift.min(parallelism, count) {
|
||||
try await submitNext()
|
||||
}
|
||||
|
||||
// Store transformed elements in the buffer, submitting a new transform
|
||||
// as each one completes.
|
||||
while let (index, result) = try await group.next() {
|
||||
(buffer.baseAddress! + index).initialize(to: result)
|
||||
|
||||
// If the task is cancelled, we stop submitting new transformations,
|
||||
// but don't exit yet. We need to complete all the outstanding work
|
||||
// so that we have a contiguous region of the buffer to deinitialize.
|
||||
if !Task.isCancelled && current < endIndex {
|
||||
try await submitNext()
|
||||
}
|
||||
}
|
||||
|
||||
// Handle mid-stream cancellation here.
|
||||
if Task.isCancelled {
|
||||
buffer.baseAddress!.deinitialize(count: submitted)
|
||||
throw CancellationError()
|
||||
}
|
||||
|
||||
precondition(submitted == buffer.count)
|
||||
return Array(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
public func parallelFirstIndex(
|
||||
parallelism requestedParallelism: Int? = nil,
|
||||
where predicate: @escaping (Element) async throws -> Bool) async throws -> Index?
|
||||
{
|
||||
let defaultParallelism = 2
|
||||
let parallelism = requestedParallelism ?? defaultParallelism
|
||||
var found: Index?
|
||||
|
||||
return try await withThrowingTaskGroup(of: Index?.self) { group in
|
||||
var current = self.startIndex
|
||||
|
||||
func submitNext() async throws {
|
||||
group.async { [i = current] in
|
||||
try await predicate(self[i]) ? i : nil
|
||||
}
|
||||
formIndex(after: ¤t)
|
||||
}
|
||||
|
||||
// Submit initial tasks.
|
||||
for _ in 0..<Swift.min(parallelism, count) {
|
||||
try await submitNext()
|
||||
}
|
||||
|
||||
// Capture results until a success is found.
|
||||
while case let .some(index) = try await group.next() {
|
||||
if index != nil {
|
||||
found = index
|
||||
break
|
||||
}
|
||||
if Task.isCancelled { return nil }
|
||||
if current < endIndex {
|
||||
try await submitNext()
|
||||
}
|
||||
}
|
||||
|
||||
// Capture outstanding results, looking for an earlier index that may
|
||||
// have finished after the first success.
|
||||
while case let .some(index) = try await group.next() {
|
||||
if let index = index, index < found! {
|
||||
found = index
|
||||
}
|
||||
if Task.isCancelled { return nil }
|
||||
}
|
||||
|
||||
return found
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection wrapper that repeats the elements of a base collection.
|
||||
public struct CycledSequence<Base: Collection> {
|
||||
public struct Cycle<Base: Collection> {
|
||||
/// The collection to repeat.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -21,8 +21,8 @@ public struct CycledSequence<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension CycledSequence: Sequence {
|
||||
/// The iterator for a `CycledSequence` instance.
|
||||
extension Cycle: Sequence {
|
||||
/// The iterator for a `Cycle` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -55,33 +55,36 @@ extension CycledSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension CycledSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension Cycle: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
|
||||
/// A collection wrapper that repeats the elements of a base collection for a
|
||||
/// finite number of times.
|
||||
public struct CycledTimesCollection<Base: Collection> {
|
||||
/// A `Product2Sequence` instance for iterating the base collection.
|
||||
public struct FiniteCycle<Base: Collection> {
|
||||
/// A Product2 instance for iterating the Base collection.
|
||||
@usableFromInline
|
||||
internal let product: Product2Sequence<Range<Int>, Base>
|
||||
internal let product: Product2<Range<Int>, Base>
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, times: Int) {
|
||||
self.product = Product2Sequence(0..<times, base)
|
||||
self.product = Product2(0..<times, base)
|
||||
}
|
||||
}
|
||||
|
||||
extension CycledTimesCollection: Collection {
|
||||
extension FiniteCycle: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol { }
|
||||
|
||||
extension FiniteCycle: Collection {
|
||||
|
||||
public typealias Element = Base.Element
|
||||
|
||||
public struct Index: Comparable {
|
||||
/// The index corresponding to the `Product2Sequence` index at this
|
||||
/// position.
|
||||
/// The index corresponding to the Product2 index at this position.
|
||||
@usableFromInline
|
||||
internal let productIndex: Product2Sequence<Range<Int>, Base>.Index
|
||||
internal let productIndex: Product2<Range<Int>, Base>.Index
|
||||
|
||||
@inlinable
|
||||
internal init(_ productIndex: Product2Sequence<Range<Int>, Base>.Index) {
|
||||
internal init(_ productIndex: Product2<Range<Int>, Base>.Index) {
|
||||
self.productIndex = productIndex
|
||||
}
|
||||
|
||||
@@ -134,11 +137,11 @@ extension CycledTimesCollection: Collection {
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard let productIndex = product.index(
|
||||
i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex)
|
||||
else { return nil }
|
||||
guard let productIndex = product.index(i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex) else {
|
||||
return nil
|
||||
}
|
||||
return Index(productIndex)
|
||||
}
|
||||
|
||||
@@ -148,7 +151,7 @@ extension CycledTimesCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension CycledTimesCollection: BidirectionalCollection
|
||||
extension FiniteCycle: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
@@ -157,12 +160,9 @@ extension CycledTimesCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension CycledTimesCollection: RandomAccessCollection
|
||||
extension FiniteCycle: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension CycledTimesCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// cycled()
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -194,8 +194,8 @@ extension Collection {
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func cycled() -> CycledSequence<Self> {
|
||||
CycledSequence(base: self)
|
||||
public func cycled() -> Cycle<Self> {
|
||||
Cycle(base: self)
|
||||
}
|
||||
|
||||
/// Returns a sequence that repeats the elements of this collection the
|
||||
@@ -216,7 +216,7 @@ extension Collection {
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func cycled(times: Int) -> CycledTimesCollection<Self> {
|
||||
CycledTimesCollection(base: self, times: times)
|
||||
public func cycled(times: Int) -> FiniteCycle<Self> {
|
||||
FiniteCycle(base: self, times: times)
|
||||
}
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
# ``Algorithms``
|
||||
|
||||
**Swift Algorithms** is an open-source package of sequence and collection algorithms,
|
||||
along with their related types.
|
||||
|
||||
## Overview
|
||||
|
||||
The Algorithms package provides a variety of sequence and collection operations, letting you cycle over a collection's elements, find combinations and permutations, create a random sample, and more.
|
||||
|
||||
For example, the package includes a group of "chunking" methods, each of which breaks a collection into consecutive subsequences. One version tests adjacent elements to find the breaking point between chunks — you can use it to quickly separate an array into ascending runs:
|
||||
|
||||
```swift
|
||||
let numbers = [10, 20, 30, 10, 40, 40, 10, 20]
|
||||
let chunks = numbers.chunked(by: { $0 <= $1 })
|
||||
// [[10, 20, 30], [10, 40, 40], [10, 20]]
|
||||
```
|
||||
|
||||
Another version looks for a change in the transformation of each successive value. You can use that to separate a list of names into groups by the first character:
|
||||
|
||||
```swift
|
||||
let names = ["Cassie", "Chloe", "Jasmine", "Jordan", "Taylor"]
|
||||
let chunks = names.chunked(on: \.first)
|
||||
// [["Cassie", "Chloe"], ["Jasmine", "Jordan"], ["Taylor"]]
|
||||
```
|
||||
|
||||
Explore more chunking methods and the remainder of the Algorithms package, grouped in the following topics.
|
||||
|
||||
## Topics
|
||||
|
||||
- <doc:CombinationsPermutations>
|
||||
- <doc:SlicingSplitting>
|
||||
- <doc:Chunking>
|
||||
- <doc:Joining>
|
||||
- <doc:Extending>
|
||||
- <doc:Trimming>
|
||||
- <doc:Sampling>
|
||||
- <doc:MinAndMax>
|
||||
- <doc:Selecting>
|
||||
- <doc:Filtering>
|
||||
- <doc:Reductions>
|
||||
- <doc:Partitioning>
|
||||
@@ -1,40 +0,0 @@
|
||||
# Chunking
|
||||
|
||||
Break collections into consecutive chunks by length, count, or based on closure-based logic.
|
||||
|
||||
## Overview
|
||||
|
||||
_Chunking_ is the process of breaking a collection into consecutive subsequences, without dropping or duplicating any of the collection's elements. After chunking a collection, joining the resulting subsequences produces the original collection of elements, unlike _splitting_, which consumes the separator element(s).
|
||||
|
||||
```swift
|
||||
let names = ["Ji-sun", "Jin-su", "Min-jae", "Young-ho"]
|
||||
let evenlyChunked = names.chunks(ofCount: 2)
|
||||
// ~ [["Ji-sun", "Jin-su"], ["Min-jae", "Young-ho"]]
|
||||
|
||||
let chunkedByFirstLetter = names.chunked(on: \.first)
|
||||
// equivalent to [("J", ["Ji-sun", "Jin-su"]), ("M", ["Min-jae"]), ("Y", ["Young-ho"])]
|
||||
```
|
||||
|
||||
## Topics
|
||||
|
||||
### Chunking a Collection by Count
|
||||
|
||||
- ``Swift/Collection/chunks(ofCount:)``
|
||||
- ``Swift/Collection/evenlyChunked(in:)``
|
||||
|
||||
### Chunking a Collection by Predicate
|
||||
|
||||
- ``Swift/Collection/chunked(by:)``
|
||||
- ``Swift/LazySequenceProtocol/chunked(by:)``
|
||||
|
||||
### Chunking a Collection by Subject
|
||||
|
||||
- ``Swift/Collection/chunked(on:)``
|
||||
- ``Swift/LazySequenceProtocol/chunked(on:)``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``ChunkedByCollection``
|
||||
- ``ChunkedOnCollection``
|
||||
- ``ChunksOfCountCollection``
|
||||
- ``EvenlyChunkedCollection``
|
||||
@@ -1,32 +0,0 @@
|
||||
# Combinations and Permutations
|
||||
|
||||
Find the combinations and permutations of any collection's elements,
|
||||
or the product of two different collections.
|
||||
|
||||
## Topics
|
||||
|
||||
### Combinations
|
||||
|
||||
- ``Swift/Collection/combinations(ofCount:)-26o4x``
|
||||
- ``Swift/Collection/combinations(ofCount:)-53jql``
|
||||
|
||||
### Permutations
|
||||
|
||||
- ``Swift/Collection/permutations(ofCount:)-7rc99``
|
||||
- ``Swift/Collection/permutations(ofCount:)-5zvhn``
|
||||
|
||||
### Unique Permutations
|
||||
|
||||
- ``Swift/Collection/uniquePermutations(ofCount:)-2extq``
|
||||
- ``Swift/Collection/uniquePermutations(ofCount:)-48r1k``
|
||||
|
||||
### Product
|
||||
|
||||
- ``product(_:_:)``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``CombinationsSequence``
|
||||
- ``PermutationsSequence``
|
||||
- ``UniquePermutationsSequence``
|
||||
- ``Product2Sequence``
|
||||
@@ -1,14 +0,0 @@
|
||||
# DeprecatedScan
|
||||
|
||||
These methods are deprecated; use the `reductions` family of methods instead.
|
||||
|
||||
See: <doc:Reductions>
|
||||
|
||||
## Topics
|
||||
|
||||
- ``Swift/Sequence/scan(_:)``
|
||||
- ``Swift/Sequence/scan(_:_:)``
|
||||
- ``Swift/Sequence/scan(into:_:)``
|
||||
- ``Swift/LazySequenceProtocol/scan(_:)``
|
||||
- ``Swift/LazySequenceProtocol/scan(_:_:)``
|
||||
- ``Swift/LazySequenceProtocol/scan(into:_:)``
|
||||
@@ -1,42 +0,0 @@
|
||||
# Extending
|
||||
|
||||
Chain two collections end-to-end,
|
||||
or repeat a collection forever or a specific number of times.
|
||||
|
||||
## Overview
|
||||
|
||||
_Chaining_ two collections
|
||||
|
||||
```swift
|
||||
let letters = chain("abcd", "EFGH")
|
||||
// String(letters) == "abcdEFGH"
|
||||
|
||||
for (num, letter) in zip((1...3).cycled(), letters) {
|
||||
print(num, letter)
|
||||
}
|
||||
// 1 a
|
||||
// 2 b
|
||||
// 3 c
|
||||
// 1 d
|
||||
// 2 E
|
||||
// 3 F
|
||||
// 1 G
|
||||
// 2 H
|
||||
```
|
||||
|
||||
## Topics
|
||||
|
||||
### Chaining Two Collections
|
||||
|
||||
- ``chain(_:_:)``
|
||||
|
||||
### Cycling a Collection
|
||||
|
||||
- ``Swift/Collection/cycled()``
|
||||
- ``Swift/Collection/cycled(times:)``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``Chain2Sequence``
|
||||
- ``CycledSequence``
|
||||
- ``CycledTimesCollection``
|
||||
@@ -1,41 +0,0 @@
|
||||
# Filtering
|
||||
|
||||
Remove duplicated elements or strip the `nil` values from a sequence or collection.
|
||||
|
||||
## Overview
|
||||
|
||||
Use the _uniquing_ methods to remove duplicates from a sequence or collection, or to remove elements that have a duplicated property.
|
||||
|
||||
```swift
|
||||
let numbers = [1, 2, 3, 3, 2, 3, 3, 2, 2, 2, 1]
|
||||
|
||||
let unique = numbers.uniqued()
|
||||
// Array(unique) == [1, 2, 3]
|
||||
```
|
||||
|
||||
The `compacted()` method removes all `nil` values from a sequence or collection of optionals:
|
||||
|
||||
```swift
|
||||
let array: [Int?] = [10, nil, 30, nil, 2, 3, nil, 5]
|
||||
let withNoNils = array.compacted()
|
||||
// Array(withNoNils) == [10, 30, 2, 3, 5]
|
||||
```
|
||||
|
||||
## Topics
|
||||
|
||||
### Uniquing Elements
|
||||
|
||||
- ``Swift/Sequence/uniqued()``
|
||||
- ``Swift/Sequence/uniqued(on:)``
|
||||
- ``Swift/LazySequenceProtocol/uniqued(on:)``
|
||||
|
||||
### Filtering out `nil` Elements
|
||||
|
||||
- ``Swift/Collection/compacted()``
|
||||
- ``Swift/Sequence/compacted()``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``UniquedSequence``
|
||||
- ``CompactedSequence``
|
||||
- ``CompactedCollection``
|
||||
@@ -1,35 +0,0 @@
|
||||
# Joining
|
||||
|
||||
Join the parts of a collection of collections,
|
||||
providing a connecting element or collection,
|
||||
or a closure that produces the connector.
|
||||
|
||||
## Topics
|
||||
|
||||
### Joining by an Element
|
||||
|
||||
- ``Swift/Sequence/joined(by:)-6mrf9``
|
||||
- ``Swift/Sequence/joined(by:)-9hyaf``
|
||||
- ``Swift/Collection/joined(by:)-430ue``
|
||||
- ``Swift/LazySequenceProtocol/joined(by:)-3yjw0``
|
||||
- ``Swift/LazySequenceProtocol/joined(by:)-47xvy``
|
||||
|
||||
### Joining by a Collection
|
||||
|
||||
- ``Swift/Sequence/joined(by:)-62j1h``
|
||||
- ``Swift/Sequence/joined(by:)-9b108``
|
||||
- ``Swift/Collection/joined(by:)-28n3b``
|
||||
- ``Swift/LazySequenceProtocol/joined(by:)-4neii``
|
||||
- ``Swift/LazySequenceProtocol/joined(by:)-49xws``
|
||||
|
||||
### Interspersing Elements
|
||||
|
||||
- ``Swift/Sequence/interspersed(with:)``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``JoinedBySequence``
|
||||
- ``JoinedByCollection``
|
||||
- ``JoinedByClosureSequence``
|
||||
- ``JoinedByClosureCollection``
|
||||
- ``InterspersedSequence``
|
||||
@@ -1,23 +0,0 @@
|
||||
# Finding the Minimum and Maximum
|
||||
|
||||
Find the minimum and maximum elements simultaneously,
|
||||
or a specific number of elements at the minimum and maximum.
|
||||
|
||||
## Topics
|
||||
|
||||
### Finding Minimum or Maximum Elements
|
||||
|
||||
- ``Swift/Sequence/min(count:)``
|
||||
- ``Swift/Collection/min(count:)``
|
||||
- ``Swift/Sequence/min(count:sortedBy:)``
|
||||
- ``Swift/Collection/min(count:sortedBy:)``
|
||||
- ``Swift/Sequence/max(count:)``
|
||||
- ``Swift/Collection/max(count:)``
|
||||
- ``Swift/Sequence/max(count:sortedBy:)``
|
||||
- ``Swift/Collection/max(count:sortedBy:)``
|
||||
|
||||
### Finding the Minimum and Maximum Elements Simulataneously
|
||||
|
||||
- ``Swift/Sequence/minAndMax()``
|
||||
- ``Swift/Sequence/minAndMax(by:)``
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
# Partitioning and Rotating
|
||||
|
||||
Partition a collection according to a unary predicate,
|
||||
rotate a collection around a particular index,
|
||||
or find the index where a collection is already partitioned.
|
||||
|
||||
## Overview
|
||||
|
||||
A _stable partition_ maintains the relative order of elements within both partitions.
|
||||
|
||||
```swift
|
||||
// partition(by:) - unstable ordering
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let p1 = numbers.partition(by: { $0.isMultiple(of: 20) })
|
||||
// p1 == 4
|
||||
// numbers == [10, 70, 30, 50, 40, 60, 20, 80]
|
||||
// ^ start of second partition
|
||||
|
||||
// stablePartition(by:) - maintains relative ordering
|
||||
numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let p2 = numbers.stablePartition(by: { $0.isMultiple(of: 20) })
|
||||
// p2 == 4
|
||||
// numbers == [10, 30, 50, 70, 20, 40, 60, 80]
|
||||
// ^ start of second partition
|
||||
```
|
||||
|
||||
Use the `rotate` method to shift the elements of a collection to start at a new position, moving the displaced elements to the end:
|
||||
|
||||
```swift
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let p = numbers.rotate(toStartAt: 2)
|
||||
// numbers == [30, 40, 50, 60, 70, 80, 10, 20]
|
||||
// p == 6 -- numbers[p] == 10
|
||||
```
|
||||
|
||||
## Topics
|
||||
|
||||
### Stable Partition
|
||||
|
||||
- ``Swift/MutableCollection/stablePartition(by:)``
|
||||
- ``Swift/MutableCollection/stablePartition(subrange:by:)``
|
||||
- ``Swift/Sequence/partitioned(by:)``
|
||||
- ``Swift/Collection/partitioned(by:)``
|
||||
|
||||
### Partition of Subranges
|
||||
|
||||
- ``Swift/MutableCollection/partition(subrange:by:)-5vdh7``
|
||||
- ``Swift/MutableCollection/partition(subrange:by:)-4gpqz``
|
||||
|
||||
### Finding a Partition Index
|
||||
|
||||
- ``Swift/Collection/partitioningIndex(where:)``
|
||||
|
||||
### Rotation
|
||||
|
||||
- ``Swift/MutableCollection/rotate(toStartAt:)-9fp48``
|
||||
- ``Swift/MutableCollection/rotate(toStartAt:)-2r55j``
|
||||
- ``Swift/MutableCollection/rotate(subrange:toStartAt:)-ov6a``
|
||||
- ``Swift/MutableCollection/rotate(subrange:toStartAt:)-5teoq``
|
||||
|
||||
### Reversing
|
||||
|
||||
- ``Swift/MutableCollection/reverse(subrange:)``
|
||||
@@ -1,35 +0,0 @@
|
||||
# Reductions
|
||||
|
||||
Find the incremental values of a sequence "reduce" operation.
|
||||
|
||||
## Overview
|
||||
|
||||
Call one of the `reductions` methods when you want the result of a `reduce` operation along with all of its intermediate values:
|
||||
|
||||
```swift
|
||||
let exclusiveRunningTotal = (1...5).reductions(0, +)
|
||||
print(exclusiveRunningTotal)
|
||||
// prints [0, 1, 3, 6, 10, 15]
|
||||
|
||||
let inclusiveRunningTotal = (1...5).reductions(+)
|
||||
print(inclusiveRunningTotal)
|
||||
// prints [1, 3, 6, 10, 15]
|
||||
```
|
||||
|
||||
## Topics
|
||||
|
||||
- ``Swift/Sequence/reductions(_:)``
|
||||
- ``Swift/Sequence/reductions(_:_:)``
|
||||
- ``Swift/Sequence/reductions(into:_:)``
|
||||
- ``Swift/LazySequenceProtocol/reductions(_:)``
|
||||
- ``Swift/LazySequenceProtocol/reductions(_:_:)``
|
||||
- ``Swift/LazySequenceProtocol/reductions(into:_:)``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``InclusiveReductionsSequence``
|
||||
- ``ExclusiveReductionsSequence``
|
||||
|
||||
### Deprecated Methods
|
||||
|
||||
- <doc:DeprecatedScan>
|
||||
@@ -1,17 +0,0 @@
|
||||
# Random Sampling
|
||||
|
||||
Choose a specified number of random elements from a sequence or collection.
|
||||
|
||||
## Topics
|
||||
|
||||
### Random Sampling
|
||||
|
||||
- ``Swift/Sequence/randomSample(count:)``
|
||||
- ``Swift/Collection/randomSample(count:)``
|
||||
- ``Swift/Collection/randomStableSample(count:)``
|
||||
|
||||
### Random Sampling with a Generator
|
||||
|
||||
- ``Swift/Sequence/randomSample(count:using:)``
|
||||
- ``Swift/Collection/randomSample(count:using:)``
|
||||
- ``Swift/Collection/randomStableSample(count:using:)``
|
||||
@@ -1,25 +0,0 @@
|
||||
# Selecting Elements
|
||||
|
||||
Select elements at a particular interval, the first mapped value,
|
||||
or iterate of elements with their indices.
|
||||
|
||||
## Topics
|
||||
|
||||
### Selecting Elements at an Interval
|
||||
|
||||
- ``Swift/Sequence/striding(by:)``
|
||||
- ``Swift/Collection/striding(by:)``
|
||||
|
||||
### Conditionally Finding the First Mapped Value
|
||||
|
||||
- ``Swift/Sequence/firstNonNil(_:)``
|
||||
|
||||
### Iterating Over Elements with Their Indices
|
||||
|
||||
- ``Swift/Collection/indexed()``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``IndexedCollection``
|
||||
- ``StridingSequence``
|
||||
- ``StridingCollection``
|
||||
@@ -1,29 +0,0 @@
|
||||
# Slicing and Splitting
|
||||
|
||||
Iterate over tuple pairs of adjacent elements, overlapping windows of a specified size, or lazily-calculated splits.
|
||||
|
||||
## Topics
|
||||
|
||||
### Adjacent Pairs
|
||||
|
||||
- ``Swift/Sequence/adjacentPairs()``
|
||||
- ``Swift/Collection/adjacentPairs()``
|
||||
|
||||
### Windows
|
||||
|
||||
- ``Swift/Collection/windows(ofCount:)``
|
||||
|
||||
### Lazily Splitting a Collection
|
||||
|
||||
- ``Swift/LazySequenceProtocol/split(separator:maxSplits:omittingEmptySubsequences:)-4q4x8``
|
||||
- ``Swift/LazySequenceProtocol/split(maxSplits:omittingEmptySubsequences:whereSeparator:)-68oqf``
|
||||
- ``Swift/LazySequenceProtocol/split(separator:maxSplits:omittingEmptySubsequences:)-a46s``
|
||||
- ``Swift/LazySequenceProtocol/split(maxSplits:omittingEmptySubsequences:whereSeparator:)-3rwee``
|
||||
|
||||
### Supporting Types
|
||||
|
||||
- ``AdjacentPairsSequence``
|
||||
- ``AdjacentPairsCollection``
|
||||
- ``WindowsOfCountCollection``
|
||||
- ``SplitSequence``
|
||||
- ``SplitCollection``
|
||||
@@ -1,27 +0,0 @@
|
||||
# Trimming
|
||||
|
||||
Remove unwanted elements from the start, the end, or both ends of a collection.
|
||||
|
||||
## Topics
|
||||
|
||||
### Trimming Both Ends of a Collection
|
||||
|
||||
- ``Swift/BidirectionalCollection/trimming(while:)``
|
||||
- ``Swift/BidirectionalCollection/trim(while:)-781az``
|
||||
- ``Swift/BidirectionalCollection/trim(while:)-6cbz3``
|
||||
|
||||
### Trimming from the Start
|
||||
|
||||
- ``Swift/Collection/trimmingPrefix(while:)``
|
||||
- ``Swift/Collection/trimPrefix(while:)-2r8n8``
|
||||
- ``Swift/Collection/trimPrefix(while:)-93obt``
|
||||
|
||||
### Trimming from the End
|
||||
|
||||
- ``Swift/BidirectionalCollection/trimmingSuffix(while:)``
|
||||
- ``Swift/BidirectionalCollection/trimSuffix(while:)-33ubj``
|
||||
- ``Swift/BidirectionalCollection/trimSuffix(while:)-3o6x9``
|
||||
|
||||
### Finding the Suffix of a Collection
|
||||
|
||||
- ``Swift/BidirectionalCollection/suffix(while:)``
|
||||
@@ -13,7 +13,7 @@
|
||||
// firstNonNil(_:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
public extension Sequence {
|
||||
/// Returns the first non-`nil` result obtained from applying the given
|
||||
/// transformation to the elements of the sequence.
|
||||
///
|
||||
@@ -30,8 +30,7 @@ extension Sequence {
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements at the start of
|
||||
/// the sequence that result in `nil` when applying the transformation.
|
||||
@inlinable
|
||||
public func firstNonNil<Result>(
|
||||
func firstNonNil<Result>(
|
||||
_ transform: (Element) throws -> Result?
|
||||
) rethrows -> Result? {
|
||||
for value in self {
|
||||
|
||||
@@ -12,9 +12,7 @@
|
||||
/// A collection consisting of all the elements contained in a collection of
|
||||
/// collections.
|
||||
@usableFromInline
|
||||
internal struct FlattenCollection<Base: Collection>
|
||||
where Base.Element: Collection
|
||||
{
|
||||
internal struct FlattenCollection<Base: Collection> where Base.Element: Collection {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -99,9 +97,7 @@ extension FlattenCollection: Collection {
|
||||
guard let startInner = start.inner
|
||||
else { return 0 }
|
||||
guard start.outer != end.outer
|
||||
else {
|
||||
return base[start.outer].distance(from: startInner, to: end.inner!)
|
||||
}
|
||||
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()
|
||||
@@ -203,10 +199,7 @@ extension FlattenCollection: Collection {
|
||||
|
||||
if let limitInner = limit.inner {
|
||||
let element = base[outer]
|
||||
return element.index(
|
||||
element.startIndex,
|
||||
offsetBy: remainder,
|
||||
limitedBy: limitInner)
|
||||
return element.index(element.startIndex, offsetBy: remainder, limitedBy: limitInner)
|
||||
.map { inner in Index(outer: outer, inner: inner) }
|
||||
} else {
|
||||
return nil
|
||||
@@ -294,8 +287,10 @@ extension FlattenCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension FlattenCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
extension FlattenCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
|
||||
extension FlattenCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol, Base.Element: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// joined()
|
||||
|
||||
@@ -11,7 +11,10 @@
|
||||
|
||||
/// A collection wrapper that iterates over the indices and elements of a
|
||||
/// collection together.
|
||||
public struct IndexedCollection<Base: Collection> {
|
||||
public struct Indexed<Base: Collection> {
|
||||
/// The element type for an `Indexed` collection.
|
||||
public typealias Element = (index: Base.Index, element: Base.Element)
|
||||
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -22,10 +25,7 @@ public struct IndexedCollection<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexedCollection: Collection {
|
||||
/// The element type for an `IndexedCollection` collection.
|
||||
public typealias Element = (index: Base.Index, element: Base.Element)
|
||||
|
||||
extension Indexed: Collection {
|
||||
@inlinable
|
||||
public var startIndex: Base.Index {
|
||||
base.startIndex
|
||||
@@ -52,11 +52,7 @@ extension IndexedCollection: Collection {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Base.Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Base.Index
|
||||
) -> Base.Index? {
|
||||
public func index(_ i: Base.Index, offsetBy distance: Int, limitedBy limit: Base.Index) -> Base.Index? {
|
||||
base.index(i, offsetBy: distance, limitedBy: limit)
|
||||
}
|
||||
|
||||
@@ -64,27 +60,18 @@ extension IndexedCollection: Collection {
|
||||
public func distance(from start: Base.Index, to end: Base.Index) -> Int {
|
||||
base.distance(from: start, to: end)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var indices: Base.Indices {
|
||||
base.indices
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
extension Indexed: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Base.Index) -> Base.Index {
|
||||
base.index(before: i)
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexedCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension IndexedCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension Indexed: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
extension Indexed: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// indexed()
|
||||
@@ -94,10 +81,6 @@ extension Collection {
|
||||
/// Returns a collection of pairs *(i, x)*, where *i* represents an index of
|
||||
/// the collection, and *x* represents an element.
|
||||
///
|
||||
/// The `indexed()` method is similar to the standard library's `enumerated()`
|
||||
/// method, but provides the index with each element instead of a zero-based
|
||||
/// counter.
|
||||
///
|
||||
/// This example iterates over the indices and elements of a set, building an
|
||||
/// array consisting of indices of names with five or fewer letters.
|
||||
///
|
||||
@@ -109,9 +92,9 @@ extension Collection {
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// - Returns: A collection of paired indices and elements of this collection.
|
||||
/// Returns: A collection of paired indices and elements of this collection.
|
||||
@inlinable
|
||||
public func indexed() -> IndexedCollection<Self> {
|
||||
IndexedCollection(base: self)
|
||||
public func indexed() -> Indexed<Self> {
|
||||
Indexed(base: self)
|
||||
}
|
||||
}
|
||||
@@ -13,9 +13,9 @@
|
||||
// Intersperse
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that presents the elements of a base sequence of elements with a
|
||||
/// separator between each of those elements.
|
||||
public struct InterspersedSequence<Base: Sequence> {
|
||||
/// 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> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -29,16 +29,9 @@ public struct InterspersedSequence<Base: Sequence> {
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedSequence: Sequence {
|
||||
/// The iterator for an `InterspersedSequence` sequence.
|
||||
extension Intersperse: Sequence {
|
||||
/// The iterator for an `Intersperse` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum State {
|
||||
case start
|
||||
case element(Base.Element)
|
||||
case separator
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
@@ -53,6 +46,13 @@ extension InterspersedSequence: Sequence {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
enum State {
|
||||
case start
|
||||
case element(Base.Element)
|
||||
case separator
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
@@ -76,13 +76,13 @@ extension InterspersedSequence: Sequence {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> InterspersedSequence<Base>.Iterator {
|
||||
public func makeIterator() -> Intersperse<Base>.Iterator {
|
||||
Iterator(iterator: base.makeIterator(), separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedSequence: Collection where Base: Collection {
|
||||
/// A position in an `InterspersedSequence` instance.
|
||||
extension Intersperse: Collection where Base: Collection {
|
||||
/// A position in an `Intersperse` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal enum Representation: Equatable {
|
||||
@@ -256,7 +256,7 @@ extension InterspersedSequence: Collection where Base: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedSequence: BidirectionalCollection
|
||||
extension Intersperse: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
@@ -271,14 +271,14 @@ extension InterspersedSequence: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedSequence: RandomAccessCollection
|
||||
extension Intersperse: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension InterspersedSequence: LazySequenceProtocol
|
||||
extension Intersperse: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension InterspersedSequence: LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol & Collection {}
|
||||
extension Intersperse: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// InterspersedMap
|
||||
@@ -289,7 +289,7 @@ extension InterspersedSequence: LazyCollectionProtocol
|
||||
/// elements, with a separator that separates each pair of adjacent transformed
|
||||
/// values.
|
||||
@usableFromInline
|
||||
internal struct InterspersedMapSequence<Base: Sequence, Result> {
|
||||
internal struct InterspersedMap<Base: Sequence, Result> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -300,16 +300,9 @@ internal struct InterspersedMapSequence<Base: Sequence, Result> {
|
||||
internal let separator: (Base.Element, Base.Element) -> Result
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence: Sequence {
|
||||
extension InterspersedMap: Sequence {
|
||||
@usableFromInline
|
||||
internal struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal enum State {
|
||||
case start
|
||||
case element(Base.Element)
|
||||
case separator(previous: Base.Element)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
@@ -332,6 +325,13 @@ extension InterspersedMapSequence: Sequence {
|
||||
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? {
|
||||
@@ -360,11 +360,11 @@ extension InterspersedMapSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
extension InterspersedMap: Collection where Base: Collection {
|
||||
@usableFromInline
|
||||
internal struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal enum Representation {
|
||||
internal enum Representation: Equatable {
|
||||
case element(Base.Index)
|
||||
case separator(previous: Base.Index, next: Base.Index)
|
||||
}
|
||||
@@ -561,7 +561,7 @@ extension InterspersedMapSequence: Collection where Base: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence: BidirectionalCollection
|
||||
extension InterspersedMap: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
@@ -577,31 +577,20 @@ extension InterspersedMapSequence: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension InterspersedMapSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
@inlinable
|
||||
internal func hash(into hasher: inout Hasher) {
|
||||
switch representation {
|
||||
case .element(let base):
|
||||
hasher.combine(false)
|
||||
hasher.combine(base)
|
||||
case .separator(_, let next):
|
||||
hasher.combine(true)
|
||||
hasher.combine(next)
|
||||
}
|
||||
}
|
||||
}
|
||||
extension InterspersedMap.Index.Representation: Hashable
|
||||
where Base.Index: Hashable {}
|
||||
|
||||
extension InterspersedMapSequence: LazySequenceProtocol {}
|
||||
extension InterspersedMapSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
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
|
||||
/// separator inserted in between each element.
|
||||
///
|
||||
@@ -631,15 +620,13 @@ extension Sequence {
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func interspersed(
|
||||
with separator: Element
|
||||
) -> InterspersedSequence<Self> {
|
||||
InterspersedSequence(base: self, separator: separator)
|
||||
public func interspersed(with separator: Element) -> Intersperse<Self> {
|
||||
Intersperse(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.interspersedMap(_:with:)
|
||||
// lazy.interspersed(_:with:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
@@ -660,10 +647,7 @@ extension LazySequenceProtocol {
|
||||
internal func interspersedMap<Result>(
|
||||
_ transform: @escaping (Element) -> Result,
|
||||
with separator: @escaping (Element, Element) -> Result
|
||||
) -> InterspersedMapSequence<Elements, Result> {
|
||||
InterspersedMapSequence(
|
||||
base: elements,
|
||||
transform: transform,
|
||||
separator: separator)
|
||||
) -> InterspersedMap<Self, Result> {
|
||||
InterspersedMap(base: self, transform: transform, separator: separator)
|
||||
}
|
||||
}
|
||||
@@ -19,8 +19,8 @@ public struct JoinedBySequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
internal typealias Inner = FlattenSequence<
|
||||
Intersperse<LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
@@ -70,8 +70,8 @@ public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
|
||||
where Base.Element: Sequence, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenSequence<InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>>>
|
||||
internal typealias Inner = FlattenSequence<
|
||||
InterspersedMap<LazySequence<Base>, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
@@ -111,7 +111,8 @@ extension JoinedByClosureSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureSequence: LazySequenceProtocol {}
|
||||
extension JoinedByClosureSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByCollection
|
||||
@@ -123,8 +124,8 @@ public struct JoinedByCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<InterspersedSequence<
|
||||
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
internal typealias Inner = FlattenCollection<
|
||||
Intersperse<LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
@@ -211,8 +212,10 @@ extension JoinedByCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
extension JoinedByCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension JoinedByCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// JoinedByClosureCollection
|
||||
@@ -225,8 +228,8 @@ public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
|
||||
where Base.Element: Collection, Base.Element.Element == Separator.Element
|
||||
{
|
||||
@usableFromInline
|
||||
internal typealias Inner = FlattenCollection<InterspersedMapSequence<
|
||||
Base, EitherSequence<Base.Element, Separator>>>
|
||||
internal typealias Inner = FlattenCollection<
|
||||
InterspersedMap<LazySequence<Base>, EitherSequence<Base.Element, Separator>>>
|
||||
|
||||
@usableFromInline
|
||||
internal let inner: Inner
|
||||
@@ -317,7 +320,10 @@ extension JoinedByClosureCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension JoinedByClosureCollection: LazyCollectionProtocol {}
|
||||
extension JoinedByClosureCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension JoinedByClosureCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Sequence.joined(by:)
|
||||
@@ -414,7 +420,7 @@ extension LazySequenceProtocol where Element: Sequence {
|
||||
@inlinable
|
||||
public func joined(
|
||||
by separator: @escaping (Element, Element) -> Element.Element
|
||||
) -> JoinedByClosureSequence<Elements, CollectionOfOne<Element.Element>> {
|
||||
) -> JoinedByClosureSequence<Self, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
@@ -423,8 +429,8 @@ extension LazySequenceProtocol where Element: Sequence {
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureSequence<Elements, Separator> {
|
||||
JoinedByClosureSequence(base: elements, separator: separator)
|
||||
) -> JoinedByClosureSequence<Self, Separator> {
|
||||
JoinedByClosureSequence(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -463,17 +469,17 @@ extension Collection where Element: Collection {
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LazySequenceProtocol.joined(by:) where Self: Collection
|
||||
// LazyCollectionProtocol.joined(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol where Elements: Collection, Element: Collection {
|
||||
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<Elements, CollectionOfOne<Element.Element>> {
|
||||
) -> JoinedByClosureCollection<Self, CollectionOfOne<Element.Element>> {
|
||||
joined(by: { CollectionOfOne(separator($0, $1)) })
|
||||
}
|
||||
|
||||
@@ -483,7 +489,7 @@ extension LazySequenceProtocol where Elements: Collection, Element: Collection {
|
||||
@inlinable
|
||||
public func joined<Separator>(
|
||||
by separator: @escaping (Element, Element) -> Separator
|
||||
) -> JoinedByClosureCollection<Elements, Separator> {
|
||||
JoinedByClosureCollection(base: elements, separator: separator)
|
||||
) -> JoinedByClosureCollection<Self, Separator> {
|
||||
JoinedByClosureCollection(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
@@ -10,9 +10,8 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SplitSequence
|
||||
// LazySplitSequence
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that lazily splits a base sequence into subsequences separated by
|
||||
/// elements that satisfy the given `whereSeparator` predicate.
|
||||
///
|
||||
@@ -22,7 +21,7 @@
|
||||
/// x.split(separator:maxSplits:omittingEmptySubsequences)
|
||||
///
|
||||
/// where `x` conforms to `LazySequenceProtocol`.
|
||||
public struct SplitSequence<Base: Sequence> {
|
||||
public struct LazySplitSequence<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -49,7 +48,7 @@ public struct SplitSequence<Base: Sequence> {
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitSequence: Sequence {
|
||||
extension LazySplitSequence {
|
||||
public struct Iterator {
|
||||
public typealias Element = [Base.Element]
|
||||
|
||||
@@ -86,19 +85,9 @@ extension SplitSequence: Sequence {
|
||||
self.omittingEmptySubsequences = omittingEmptySubsequences
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(
|
||||
base: base.makeIterator(),
|
||||
whereSeparator: self.isSeparator,
|
||||
maxSplits: self.maxSplits,
|
||||
omittingEmptySubsequences: self.omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitSequence.Iterator: IteratorProtocol {
|
||||
extension LazySplitSequence.Iterator: IteratorProtocol {
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
var currentElement = base.next()
|
||||
@@ -139,7 +128,17 @@ extension SplitSequence.Iterator: IteratorProtocol {
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitSequence: LazySequenceProtocol {}
|
||||
extension LazySplitSequence: LazySequenceProtocol {
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
return Iterator(
|
||||
base: base.makeIterator(),
|
||||
whereSeparator: self.isSeparator,
|
||||
maxSplits: self.maxSplits,
|
||||
omittingEmptySubsequences: self.omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
/// Lazily returns the longest possible subsequences of the sequence, in
|
||||
@@ -231,10 +230,10 @@ extension LazySequenceProtocol {
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true,
|
||||
whereSeparator isSeparator: @escaping (Element) -> Bool
|
||||
) -> SplitSequence<Elements> {
|
||||
) -> LazySplitSequence<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return SplitSequence(
|
||||
return LazySplitSequence(
|
||||
base: elements,
|
||||
isSeparator: isSeparator,
|
||||
maxSplits: maxSplits,
|
||||
@@ -321,10 +320,10 @@ extension LazySequenceProtocol where Element: Equatable {
|
||||
separator: Element,
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true
|
||||
) -> SplitSequence<Elements> {
|
||||
) -> LazySplitSequence<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return SplitSequence(
|
||||
return LazySplitSequence(
|
||||
base: elements,
|
||||
isSeparator: { $0 == separator },
|
||||
maxSplits: maxSplits,
|
||||
@@ -334,9 +333,8 @@ extension LazySequenceProtocol where Element: Equatable {
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// SplitCollection
|
||||
// LazySplitCollection
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection that lazily splits a base collection into subsequences
|
||||
/// separated by elements that satisfy the given `whereSeparator` predicate.
|
||||
///
|
||||
@@ -345,8 +343,8 @@ extension LazySequenceProtocol where Element: Equatable {
|
||||
/// x.split(maxSplits:omittingEmptySubsequences:whereSeparator)
|
||||
/// x.split(separator:maxSplits:omittingEmptySubsequences)
|
||||
///
|
||||
/// where `x` conforms to `LazySequenceProtocol` and `Collection`.
|
||||
public struct SplitCollection<Base: Collection> {
|
||||
/// where `x` conforms to `LazyCollectionProtocol`.
|
||||
public struct LazySplitCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -400,7 +398,7 @@ public struct SplitCollection<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitCollection: Collection {
|
||||
extension LazySplitCollection: LazyCollectionProtocol {
|
||||
/// Position of a subsequence in a split collection.
|
||||
public struct Index: Comparable {
|
||||
/// The range corresponding to the subsequence at this position.
|
||||
@@ -477,7 +475,7 @@ extension SplitCollection: Collection {
|
||||
}
|
||||
|
||||
var updatedSplitCount = splitCount
|
||||
if end != base.endIndex {
|
||||
if end < base.endIndex {
|
||||
// This subsequence ends on a separator (and perhaps includes other
|
||||
// separators, if we're omitting empty subsequences), so we've performed
|
||||
// another split.
|
||||
@@ -549,16 +547,13 @@ extension SplitCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitCollection.Index: Hashable {
|
||||
@inlinable
|
||||
extension LazySplitCollection.Index: Hashable {
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(sequenceLength)
|
||||
}
|
||||
}
|
||||
|
||||
extension SplitCollection: LazyCollectionProtocol {}
|
||||
|
||||
extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
extension LazyCollectionProtocol {
|
||||
/// Lazily returns the longest possible subsequences of the collection, in
|
||||
/// order, that don't contain elements satisfying the given predicate.
|
||||
///
|
||||
@@ -646,10 +641,10 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true,
|
||||
whereSeparator isSeparator: @escaping (Element) -> Bool
|
||||
) -> SplitCollection<Elements> {
|
||||
) -> LazySplitCollection<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return SplitCollection(
|
||||
return LazySplitCollection(
|
||||
base: elements,
|
||||
isSeparator: isSeparator,
|
||||
maxSplits: maxSplits,
|
||||
@@ -658,9 +653,8 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol
|
||||
where Self: Collection, Elements: Collection, Element: Equatable
|
||||
{
|
||||
extension LazyCollectionProtocol
|
||||
where Element: Equatable {
|
||||
/// Lazily returns the longest possible subsequences of the collection, in
|
||||
/// order, around elements equal to the given element.
|
||||
///
|
||||
@@ -743,10 +737,10 @@ extension LazySequenceProtocol
|
||||
separator: Element,
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true
|
||||
) -> SplitCollection<Elements> {
|
||||
) -> LazySplitCollection<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return SplitCollection(
|
||||
return LazySplitCollection(
|
||||
base: elements,
|
||||
isSeparator: { $0 == separator },
|
||||
maxSplits: maxSplits,
|
||||
@@ -28,9 +28,11 @@ extension Sequence {
|
||||
while let e = iterator.next() {
|
||||
// To be part of `result`, `e` must be strictly less than `result.last`.
|
||||
guard try areInIncreasingOrder(e, result.last!) else { continue }
|
||||
result.removeLast()
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
|
||||
assert(insertionIndex != result.endIndex)
|
||||
result.removeLast()
|
||||
result.insert(e, at: insertionIndex)
|
||||
}
|
||||
|
||||
@@ -125,7 +127,7 @@ extension Sequence {
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let largestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// let smallestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its largest
|
||||
@@ -188,7 +190,7 @@ extension Sequence where Element: Comparable {
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(count: Int) -> [Element] {
|
||||
min(count: count, sortedBy: <)
|
||||
return min(count: count, sortedBy: <)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this sequence.
|
||||
@@ -197,7 +199,7 @@ extension Sequence where Element: Comparable {
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let largestThree = numbers.max(count: 3)
|
||||
/// let smallestThree = numbers.max(count: 3)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its largest
|
||||
@@ -214,7 +216,7 @@ extension Sequence where Element: Comparable {
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(count: Int) -> [Element] {
|
||||
max(count: count, sortedBy: <)
|
||||
return max(count: count, sortedBy: <)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -280,7 +282,7 @@ extension Collection {
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let largestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// let smallestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a collection but only need to access its largest
|
||||
@@ -352,7 +354,7 @@ extension Collection where Element: Comparable {
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(count: Int) -> [Element] {
|
||||
min(count: count, sortedBy: <)
|
||||
return min(count: count, sortedBy: <)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this collection.
|
||||
@@ -378,7 +380,7 @@ extension Collection where Element: Comparable {
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(count: Int) -> [Element] {
|
||||
max(count: count, sortedBy: <)
|
||||
return max(count: count, sortedBy: <)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -390,8 +392,9 @@ 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:
|
||||
/// 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
|
||||
@@ -402,9 +405,9 @@ extension Sequence {
|
||||
/// 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.
|
||||
/// 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}) {
|
||||
@@ -416,9 +419,9 @@ extension Sequence {
|
||||
///
|
||||
/// - 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`.
|
||||
/// - 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
|
||||
@@ -426,7 +429,6 @@ extension Sequence {
|
||||
/// method returns `nil`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func minAndMax(
|
||||
by areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> (min: Element, max: Element)? {
|
||||
@@ -477,6 +479,6 @@ extension Sequence where Element: Comparable {
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func minAndMax() -> (min: Element, max: Element)? {
|
||||
minAndMax(by: <)
|
||||
return minAndMax(by: <)
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020-2021 Apple Inc. and the Swift project authors
|
||||
// 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
|
||||
@@ -14,9 +14,9 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension MutableCollection {
|
||||
/// Moves all elements satisfying `belongsInSecondPartition` into a suffix of
|
||||
/// the collection, preserving their relative order, and returns the start of
|
||||
/// the resulting suffix.
|
||||
/// Moves all elements satisfying `belongsInSecondPartition` into a suffix
|
||||
/// of the collection, preserving their relative order, and returns the
|
||||
/// start of the resulting suffix.
|
||||
///
|
||||
/// - Complexity: O(*n* log *n*), where *n* is the number of elements.
|
||||
/// - Precondition:
|
||||
@@ -25,7 +25,7 @@ extension MutableCollection {
|
||||
internal mutating func stablePartition(
|
||||
count n: Int,
|
||||
subrange: Range<Index>,
|
||||
by belongsInSecondPartition: (Element) throws -> Bool
|
||||
by belongsInSecondPartition: (Element) throws-> Bool
|
||||
) rethrows -> Index {
|
||||
if n == 0 { return subrange.lowerBound }
|
||||
if n == 1 {
|
||||
@@ -138,22 +138,22 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
// * predicate(self[i]) == true, for i in hi ..< endIndex
|
||||
|
||||
Loop: while true {
|
||||
FindLo: do {
|
||||
FindLo: repeat {
|
||||
while lo < hi {
|
||||
if try belongsInSecondPartition(self[lo]) { break FindLo }
|
||||
formIndex(after: &lo)
|
||||
}
|
||||
break Loop
|
||||
}
|
||||
} while false
|
||||
|
||||
FindHi: do {
|
||||
FindHi: repeat {
|
||||
formIndex(before: &hi)
|
||||
while lo < hi {
|
||||
if try !belongsInSecondPartition(self[hi]) { break FindHi }
|
||||
formIndex(before: &hi)
|
||||
}
|
||||
break Loop
|
||||
}
|
||||
} while false
|
||||
|
||||
swapAt(lo, hi)
|
||||
formIndex(after: &lo)
|
||||
@@ -168,19 +168,18 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns the start index of the partition of a collection that matches
|
||||
/// the given predicate.
|
||||
/// Returns the index of the first element in the collection that matches
|
||||
/// the predicate.
|
||||
///
|
||||
/// The collection must already be partitioned according to the predicate.
|
||||
/// That is, there should be an index `i` where for every element in
|
||||
/// `collection[..<i]` the predicate is `false`, and for every element in
|
||||
/// `collection[i...]` the predicate is `true`.
|
||||
/// `collection[..<i]` the predicate is `false`, and for every element
|
||||
/// in `collection[i...]` the predicate is `true`.
|
||||
///
|
||||
/// - Parameter belongsInSecondPartition: A predicate that partitions the
|
||||
/// collection.
|
||||
/// - Returns: The index of the first element in the collection for which
|
||||
/// `predicate` returns `true`, or `endIndex` if there are no elements
|
||||
/// for which `predicate` returns `true`.
|
||||
/// `predicate` returns `true`.
|
||||
///
|
||||
/// - Complexity: O(log *n*), where *n* is the length of this collection if
|
||||
/// the collection conforms to `RandomAccessCollection`, otherwise O(*n*).
|
||||
@@ -205,137 +204,3 @@ extension Collection {
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// partitioned(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Returns two arrays containing, in order, the elements of the sequence that
|
||||
/// do and don’t satisfy the given predicate.
|
||||
///
|
||||
/// In this example, `partitioned(by:)` is used to separate the input based on
|
||||
/// whether a name is shorter than five characters:
|
||||
///
|
||||
/// let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
/// let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
/// print(longNames)
|
||||
/// // Prints "["Vivien", "Marlon"]"
|
||||
/// print(shortNames)
|
||||
/// // Prints "["Kim", "Karl"]"
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the sequence as
|
||||
/// its argument and returns a Boolean value indicating whether the element
|
||||
/// should be included in the second returned array. Otherwise, the element
|
||||
/// will appear in the first returned array.
|
||||
///
|
||||
/// - Returns: Two arrays with all of the elements of the receiver. The
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func partitioned(
|
||||
by predicate: (Element) throws -> Bool
|
||||
) rethrows -> (falseElements: [Element], trueElements: [Element]) {
|
||||
var lhs = [Element]()
|
||||
var rhs = [Element]()
|
||||
|
||||
for element in self {
|
||||
if try predicate(element) {
|
||||
rhs.append(element)
|
||||
} else {
|
||||
lhs.append(element)
|
||||
}
|
||||
}
|
||||
|
||||
return (lhs, rhs)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns two arrays containing, in order, the elements of the collection
|
||||
/// that do and don’t satisfy the given predicate.
|
||||
///
|
||||
/// In this example, `partitioned(by:)` is used to separate the input based on
|
||||
/// whether a name is shorter than five characters.
|
||||
///
|
||||
/// let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
/// let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
/// print(longNames)
|
||||
/// // Prints "["Vivien", "Marlon"]"
|
||||
/// print(shortNames)
|
||||
/// // Prints "["Kim", "Karl"]"
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the collection
|
||||
/// as its argument and returns a Boolean value indicating whether the element
|
||||
/// should be included in the second returned array. Otherwise, the element
|
||||
/// will appear in the first returned array.
|
||||
///
|
||||
/// - Returns: Two arrays with all of the elements of the receiver. The
|
||||
/// first array contains all the elements that `predicate` didn’t allow, and
|
||||
/// the second array contains all the elements that `predicate` allowed.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func partitioned(
|
||||
by predicate: (Element) throws -> Bool
|
||||
) rethrows -> (falseElements: [Element], trueElements: [Element]) {
|
||||
guard !self.isEmpty else {
|
||||
return ([], [])
|
||||
}
|
||||
|
||||
// Since collections have known sizes, we can allocate one array of size
|
||||
// `self.count`, then insert items at the beginning or end of that contiguous
|
||||
// block. This way, we don’t have to do any dynamic array resizing. Since we
|
||||
// insert the right elements on the right side in reverse order, we need to
|
||||
// reverse them back to the original order at the end.
|
||||
|
||||
let count = self.count
|
||||
|
||||
// Inside of the `initializer` closure, we set what the actual mid-point is.
|
||||
// We will use this to partition the single array into two.
|
||||
var midPoint: Int = 0
|
||||
|
||||
let elements = try [Element](
|
||||
unsafeUninitializedCapacity: count,
|
||||
initializingWith: { buffer, initializedCount in
|
||||
var lhs = buffer.baseAddress!
|
||||
var rhs = lhs + buffer.count
|
||||
do {
|
||||
for element in self {
|
||||
if try predicate(element) {
|
||||
rhs -= 1
|
||||
rhs.initialize(to: element)
|
||||
} else {
|
||||
lhs.initialize(to: element)
|
||||
lhs += 1
|
||||
}
|
||||
}
|
||||
|
||||
precondition(lhs == rhs, """
|
||||
Collection's `count` differed from the number of elements iterated.
|
||||
"""
|
||||
)
|
||||
|
||||
let rhsIndex = rhs - buffer.baseAddress!
|
||||
buffer[rhsIndex...].reverse()
|
||||
initializedCount = buffer.count
|
||||
|
||||
midPoint = rhsIndex
|
||||
} catch {
|
||||
let lhsCount = lhs - buffer.baseAddress!
|
||||
let rhsCount = (buffer.baseAddress! + buffer.count) - rhs
|
||||
buffer.baseAddress!.deinitialize(count: lhsCount)
|
||||
rhs.deinitialize(count: rhsCount)
|
||||
throw error
|
||||
}
|
||||
})
|
||||
|
||||
let lhs = elements[..<midPoint]
|
||||
let rhs = elements[midPoint...]
|
||||
return (
|
||||
Array(lhs),
|
||||
Array(rhs)
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -18,9 +18,9 @@ extension MutableCollection
|
||||
{
|
||||
/// Permutes this collection's elements through all the lexical orderings.
|
||||
///
|
||||
/// Call `nextPermutation()` repeatedly starting with the collection in sorted
|
||||
/// order. When the full cycle of all permutations has been completed, the
|
||||
/// collection will be back in sorted order and this method will return
|
||||
/// Call `nextPermutation()` repeatedly starting with the collection in
|
||||
/// sorted order. When the full cycle of all permutations has been completed,
|
||||
/// the collection will be back in sorted order and this method will return
|
||||
/// `false`.
|
||||
///
|
||||
/// - Returns: A Boolean value indicating whether the collection still has
|
||||
@@ -76,7 +76,7 @@ extension MutableCollection
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence of all the permutations of a collection's elements.
|
||||
public struct PermutationsSequence<Base: Collection> {
|
||||
public struct Permutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -85,15 +85,12 @@ public struct PermutationsSequence<Base: Collection> {
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The range of accepted sizes of permutations.
|
||||
///
|
||||
/// - Note: This may be empty if the attempted range entirely exceeds the
|
||||
/// bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>
|
||||
|
||||
/// Initializes a `PermutationsSequence` for all permutations of `base` of
|
||||
/// size `k`.
|
||||
///
|
||||
/// Initializes a `Permutations` for all permutations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for permutations
|
||||
/// - k: The expected size of each permutation, or `nil` (default) to
|
||||
@@ -109,9 +106,8 @@ public struct PermutationsSequence<Base: Collection> {
|
||||
self.init(base, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Initializes a `PermutationsSequence` for all combinations of `base` of
|
||||
/// sizes within a given range.
|
||||
///
|
||||
/// Initializes a `Permutations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for permutations.
|
||||
/// - kRange: The range of accepted sizes of permutations, or `nil` to
|
||||
@@ -132,14 +128,14 @@ public struct PermutationsSequence<Base: Collection> {
|
||||
/// The total number of permutations.
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
kRange.map {
|
||||
return kRange.map {
|
||||
stride(from: baseCount, to: baseCount - $0, by: -1).reduce(1, *)
|
||||
}.reduce(0, +)
|
||||
}
|
||||
}
|
||||
|
||||
extension PermutationsSequence: Sequence {
|
||||
/// The iterator for a `PermutationsSequence` instance.
|
||||
extension Permutations: Sequence {
|
||||
/// The iterator for a `Permutations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -164,7 +160,7 @@ extension PermutationsSequence: Sequence {
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@inlinable
|
||||
internal init(_ permutations: PermutationsSequence) {
|
||||
internal init(_ permutations: Permutations) {
|
||||
self.base = permutations.base
|
||||
self.baseCount = permutations.baseCount
|
||||
self.kRange = permutations.kRange
|
||||
@@ -263,8 +259,7 @@ extension PermutationsSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension PermutationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension Permutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// permutations(ofCount:)
|
||||
@@ -325,13 +320,13 @@ extension Collection {
|
||||
/// results in an empty sequence.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `PermutationsSequence` accesses the `count` of the base collection.
|
||||
/// is the number of elements in the base collection, since `Permutations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func permutations<R: RangeExpression>(
|
||||
ofCount kRange: R
|
||||
) -> PermutationsSequence<Self> where R.Bound == Int {
|
||||
PermutationsSequence(self, kRange: kRange)
|
||||
) -> Permutations<Self> where R.Bound == Int {
|
||||
return Permutations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Returns a collection of the permutations of this collection of the
|
||||
@@ -381,14 +376,14 @@ extension Collection {
|
||||
/// this collection, the resulting sequence is empty.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since
|
||||
/// `PermutationsSequence` accesses the `count` of the base collection.
|
||||
/// is the number of elements in the base collection, since `Permutations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func permutations(ofCount k: Int? = nil) -> PermutationsSequence<Self> {
|
||||
public func permutations(ofCount k: Int? = nil) -> Permutations<Self> {
|
||||
precondition(
|
||||
k ?? 0 >= 0,
|
||||
"Can't have permutations with a negative number of elements.")
|
||||
return PermutationsSequence(self, k: k)
|
||||
return Permutations(self, k: k)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -399,9 +394,9 @@ extension Collection {
|
||||
/// A sequence of the unique permutations of the elements of a sequence or
|
||||
/// collection.
|
||||
///
|
||||
/// To create a `UniquePermutationsSequence` instance, call one of the
|
||||
/// To create a `UniquePermutations` instance, call one of the
|
||||
/// `uniquePermutations` methods on your collection.
|
||||
public struct UniquePermutationsSequence<Base: Collection> {
|
||||
public struct UniquePermutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -413,7 +408,7 @@ public struct UniquePermutationsSequence<Base: Collection> {
|
||||
internal let kRange: Range<Int>
|
||||
}
|
||||
|
||||
extension UniquePermutationsSequence where Base.Element: Hashable {
|
||||
extension UniquePermutations where Base.Element: Hashable {
|
||||
@inlinable
|
||||
internal static func _indexes(_ base: Base) -> [Base.Index] {
|
||||
let firstIndexesAndCountsByElement = Dictionary(
|
||||
@@ -445,8 +440,8 @@ extension UniquePermutationsSequence where Base.Element: Hashable {
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquePermutationsSequence: Sequence {
|
||||
/// The iterator for a `UniquePermutationsSequence` instance.
|
||||
extension UniquePermutations: Sequence {
|
||||
/// The iterator for a `UniquePermutations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -501,8 +496,7 @@ extension UniquePermutationsSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquePermutationsSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension UniquePermutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
extension Collection where Element: Hashable {
|
||||
/// Returns a sequence of the unique permutations of this sequence of the
|
||||
@@ -543,14 +537,11 @@ extension Collection where Element: Hashable {
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
@inlinable
|
||||
public func uniquePermutations(ofCount k: Int? = nil)
|
||||
-> UniquePermutationsSequence<Self>
|
||||
{
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutations<Self> {
|
||||
if let k = k {
|
||||
return UniquePermutationsSequence(self, k ..< (k + 1))
|
||||
return UniquePermutations(self, k ..< (k + 1))
|
||||
} else {
|
||||
return UniquePermutationsSequence(self)
|
||||
return UniquePermutations(self)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -583,10 +574,9 @@ extension Collection where Element: Hashable {
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
@inlinable
|
||||
public func uniquePermutations<R: RangeExpression>(
|
||||
ofCount kRange: R
|
||||
) -> UniquePermutationsSequence<Self> where R.Bound == Int {
|
||||
UniquePermutationsSequence(self, kRange)
|
||||
public func uniquePermutations<R: RangeExpression>(ofCount kRange: R) -> UniquePermutations<Self>
|
||||
where R.Bound == Int
|
||||
{
|
||||
UniquePermutations(self, kRange)
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that represents the product of two sequences' elements.
|
||||
public struct Product2Sequence<Base1: Sequence, Base2: Collection> {
|
||||
public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
/// The outer sequence in the product.
|
||||
@usableFromInline
|
||||
internal let base1: Base1
|
||||
@@ -26,10 +26,10 @@ public struct Product2Sequence<Base1: Sequence, Base2: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: Sequence {
|
||||
extension Product2: Sequence {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
|
||||
/// The iterator for a `Product2Sequence` sequence.
|
||||
/// The iterator for a `Product2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var i1: Base1.Iterator
|
||||
@@ -41,7 +41,7 @@ extension Product2Sequence: Sequence {
|
||||
internal let base2: Base2
|
||||
|
||||
@inlinable
|
||||
internal init(_ c: Product2Sequence) {
|
||||
internal init(_ c: Product2) {
|
||||
self.base2 = c.base2
|
||||
self.i1 = c.base1.makeIterator()
|
||||
self.i2 = c.base2.makeIterator()
|
||||
@@ -83,14 +83,13 @@ extension Product2Sequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
return Iterator(self)
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: Collection where Base1: Collection {
|
||||
/// The index type for a `Product2Sequence` collection.
|
||||
extension Product2: Collection where Base1: Collection {
|
||||
/// The index type for a `Product2` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var i1: Base1.Index
|
||||
@@ -420,7 +419,7 @@ extension Product2Sequence: Collection where Base1: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: BidirectionalCollection
|
||||
extension Product2: BidirectionalCollection
|
||||
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
@@ -437,11 +436,10 @@ extension Product2Sequence: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension Product2Sequence: RandomAccessCollection
|
||||
extension Product2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
extension Product2Sequence.Index: Hashable
|
||||
where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
extension Product2.Index: Hashable where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// product(_:_:)
|
||||
@@ -483,6 +481,6 @@ extension Product2Sequence.Index: Hashable
|
||||
@inlinable
|
||||
public func product<Base1: Sequence, Base2: Collection>(
|
||||
_ s1: Base1, _ s2: Base2
|
||||
) -> Product2Sequence<Base1, Base2> {
|
||||
Product2Sequence(s1, s2)
|
||||
) -> Product2<Base1, Base2> {
|
||||
return Product2(s1, s2)
|
||||
}
|
||||
@@ -62,7 +62,8 @@ extension Collection {
|
||||
/// This method is equivalent to calling `randomStableSample(k:using:)`,
|
||||
/// passing in the system's default random generator.
|
||||
///
|
||||
/// - Parameter k: The number of elements to randomly select.
|
||||
/// - Parameters:
|
||||
/// - k: The number of elements to randomly select.
|
||||
/// - Returns: An array of `k` random elements. If `k` is greater than this
|
||||
/// collection's count, then this method returns the full collection.
|
||||
///
|
||||
@@ -122,12 +123,12 @@ extension Collection {
|
||||
|
||||
// Fill the reservoir with the first `k` elements.
|
||||
var i = startIndex
|
||||
while i != endIndex, result.count < k {
|
||||
while i < endIndex, result.count < k {
|
||||
result.append(self[i])
|
||||
formIndex(after: &i)
|
||||
}
|
||||
|
||||
while i != endIndex {
|
||||
while i < endIndex {
|
||||
// Calculate the next value of w.
|
||||
w *= nextW(k: k, using: &rng)
|
||||
|
||||
@@ -135,7 +136,7 @@ extension Collection {
|
||||
let offset = nextOffset(w: w, using: &rng)
|
||||
i = index(i, offsetBy: offset, limitedBy: endIndex) ?? endIndex
|
||||
|
||||
if i != endIndex {
|
||||
if i < endIndex {
|
||||
// Swap selected element with a randomly chosen one in the reservoir.
|
||||
let j = Int.random(in: 0..<result.count, using: &rng)
|
||||
result[j] = self[i]
|
||||
@@ -153,7 +154,8 @@ extension Collection {
|
||||
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
|
||||
/// the system's default random generator.
|
||||
///
|
||||
/// - Parameter k: The number of elements to randomly select.
|
||||
/// - Parameters:
|
||||
/// - k: The number of elements to randomly select.
|
||||
/// - Returns: An array of `k` random elements. The returned elements may be
|
||||
/// in any order. If `k` is greater than this collection's count, then this
|
||||
/// method returns the full collection.
|
||||
@@ -223,7 +225,8 @@ extension Sequence {
|
||||
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
|
||||
/// the system's default random generator.
|
||||
///
|
||||
/// - Parameter k: The number of elements to randomly select.
|
||||
/// - Parameters:
|
||||
/// - k: The number of elements to randomly select.
|
||||
/// - Returns: An array of `k` random elements. The returned elements may be
|
||||
/// in any order. If `k` is greater than this sequence's count, then this
|
||||
/// method returns the full sequence.
|
||||
|
||||
+162
-139
@@ -12,6 +12,7 @@
|
||||
// MARK: - Exclusive Reductions
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
/// Returns a sequence containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
@@ -28,17 +29,17 @@ extension LazySequenceProtocol {
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductionsSequence<Elements, Result> {
|
||||
reductions(into: initial) { result, element in
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
return reductions(into: initial) { result, element in
|
||||
result = transform(result, element)
|
||||
}
|
||||
}
|
||||
@@ -59,7 +60,7 @@ extension LazySequenceProtocol {
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
///
|
||||
@@ -68,15 +69,13 @@ extension LazySequenceProtocol {
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductionsSequence<Elements, Result> {
|
||||
ExclusiveReductionsSequence(
|
||||
base: elements,
|
||||
initial: initial,
|
||||
transform: transform)
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
ExclusiveReductions(base: self, initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns an array containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
@@ -107,7 +106,7 @@ extension Sequence {
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the initial value followed by the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@@ -116,7 +115,7 @@ extension Sequence {
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result] {
|
||||
try reductions(into: initial) { result, element in
|
||||
return try reductions(into: initial) { result, element in
|
||||
result = try transform(result, element)
|
||||
}
|
||||
}
|
||||
@@ -151,7 +150,7 @@ extension Sequence {
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the initial value followed by the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@@ -177,7 +176,7 @@ extension Sequence {
|
||||
|
||||
/// A sequence of applying a transform to the element of a sequence and the
|
||||
/// previously transformed result.
|
||||
public struct ExclusiveReductionsSequence<Base: Sequence, Result> {
|
||||
public struct ExclusiveReductions<Result, Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -199,7 +198,7 @@ public struct ExclusiveReductionsSequence<Base: Sequence, Result> {
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductionsSequence: Sequence {
|
||||
extension ExclusiveReductions: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
@@ -235,82 +234,58 @@ extension ExclusiveReductionsSequence: Sequence {
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(
|
||||
iterator: base.makeIterator(),
|
||||
current: initial,
|
||||
transform: transform)
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
current: initial,
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
extension ExclusiveReductions: Collection where Base: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal enum Representation {
|
||||
case base(Base.Index, Result)
|
||||
case end
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
internal let representation: ReductionsIndexRepresentation<Base.Index, Result>
|
||||
|
||||
@inlinable
|
||||
internal init(_ representation: Representation) {
|
||||
internal init(
|
||||
_ representation: ReductionsIndexRepresentation<Base.Index, Result>
|
||||
) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case (.base(let lhs, _), .base(let rhs, _)):
|
||||
return lhs == rhs
|
||||
case (.end, .end):
|
||||
return true
|
||||
case (.base, .end), (.end, .base):
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case (.end, _):
|
||||
return false
|
||||
case (_, .end):
|
||||
return true
|
||||
case (.base(let lhs, _), .base(let rhs, _)):
|
||||
return lhs < rhs
|
||||
}
|
||||
lhs.representation < rhs.representation
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(.base(base.startIndex, initial))
|
||||
}
|
||||
public var startIndex: Index { Index(.start) }
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(.end)
|
||||
}
|
||||
public var endIndex: Index { Index(.end) }
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Result {
|
||||
switch position.representation {
|
||||
case .base(_, let result):
|
||||
return result
|
||||
case .end:
|
||||
fatalError("Cannot get element of end index.")
|
||||
case .start: return initial
|
||||
case .base(_, let result): return result
|
||||
case .end: fatalError("Cannot get element of end index.")
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
switch index.representation {
|
||||
case .base(base.endIndex, _):
|
||||
return Index(.end)
|
||||
case .base(let index, var result):
|
||||
transform(&result, base[index])
|
||||
return Index(.base(base.index(after: index), result))
|
||||
public func index(after i: Index) -> Index {
|
||||
func index(base index: Base.Index, previous: Result) -> Index {
|
||||
guard index != base.endIndex else { return endIndex }
|
||||
var previous = previous
|
||||
transform(&previous, base[index])
|
||||
return Index(.base(index: index, result: previous))
|
||||
}
|
||||
switch i.representation {
|
||||
case .start:
|
||||
return index(base: base.startIndex, previous: initial)
|
||||
case let .base(i, result):
|
||||
return index(base: base.index(after: i), previous: result)
|
||||
case .end:
|
||||
fatalError("Cannot get index after end index.")
|
||||
}
|
||||
@@ -319,40 +294,38 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case (.start, .start):
|
||||
return 0
|
||||
case let (.start, .base(index, _)):
|
||||
return base.distance(from: base.startIndex, to: index) + 1
|
||||
case (.start, .end):
|
||||
return base.distance(from: base.startIndex, to: base.endIndex) + 1
|
||||
case let (.base(index, _), .start):
|
||||
return base.distance(from: index, to: base.startIndex) - 1
|
||||
case let (.base(start, _), .base(end, _)):
|
||||
return base.distance(from: start, to: end)
|
||||
case let (.base(index, _), .end):
|
||||
return base.distance(from: index, to: base.endIndex) + 1
|
||||
return base.distance(from: index, to: base.endIndex)
|
||||
case (.end, .start):
|
||||
return base.distance(from: base.endIndex, to: base.startIndex) - 1
|
||||
case let (.end, .base(index, _)):
|
||||
return base.distance(from: base.endIndex, to: index) - 1
|
||||
return base.distance(from: base.endIndex, to: index)
|
||||
case (.end, .end):
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductionsSequence: LazySequenceProtocol {}
|
||||
extension ExclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension ExclusiveReductionsSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
|
||||
extension ExclusiveReductionsSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
@inlinable
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
switch representation {
|
||||
case .base(let base, _):
|
||||
hasher.combine(base)
|
||||
case .end:
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
extension ExclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
/// Returns a sequence containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
@@ -366,20 +339,22 @@ extension LazySequenceProtocol {
|
||||
/// // prints [1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// - Parameter transform: A closure that combines the previously reduced
|
||||
/// result and the next element in the receiving sequence.
|
||||
/// - Parameters:
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func reductions(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductionsSequence<Elements> {
|
||||
InclusiveReductionsSequence(base: elements, transform: transform)
|
||||
) -> InclusiveReductions<Self> {
|
||||
InclusiveReductions(base: self, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns an array containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
@@ -409,8 +384,9 @@ extension Sequence {
|
||||
/// If the sequence has one element, `transform` is never executed and
|
||||
/// an array containing only that first element is returned.
|
||||
///
|
||||
/// - Parameter transform: A closure that combines the previously reduced
|
||||
/// result and the next element in the receiving sequence.
|
||||
/// - Parameters:
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@@ -424,7 +400,7 @@ extension Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
public struct InclusiveReductionsSequence<Base: Sequence> {
|
||||
public struct InclusiveReductions<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -441,7 +417,7 @@ public struct InclusiveReductionsSequence<Base: Sequence> {
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductionsSequence: Sequence {
|
||||
extension InclusiveReductions: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
@@ -455,9 +431,11 @@ extension InclusiveReductionsSequence: Sequence {
|
||||
@inlinable
|
||||
internal init(
|
||||
iterator: Base.Iterator,
|
||||
element: Base.Element? = nil,
|
||||
transform: @escaping (Base.Element, Base.Element) -> Base.Element
|
||||
) {
|
||||
self.iterator = iterator
|
||||
self.element = element
|
||||
self.transform = transform
|
||||
}
|
||||
|
||||
@@ -475,97 +453,139 @@ extension InclusiveReductionsSequence: Sequence {
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(), transform: transform)
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductionsSequence: Collection where Base: Collection {
|
||||
extension InclusiveReductions: Collection where Base: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let base: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
internal let result: Element?
|
||||
internal let representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base.Index, result: Element?) {
|
||||
self.base = base
|
||||
self.result = result
|
||||
internal init(
|
||||
_ representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
|
||||
) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.base == rhs.base
|
||||
lhs.representation < rhs.representation
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base: base.startIndex, result: base.first)
|
||||
guard base.startIndex != base.endIndex else { return endIndex }
|
||||
return Index(.start)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base: base.endIndex, result: nil)
|
||||
}
|
||||
public var endIndex: Index { Index(.end) }
|
||||
|
||||
@inlinable
|
||||
public subscript(index: Index) -> Base.Element {
|
||||
guard let result = index.result else {
|
||||
fatalError("Can't subscript using endIndex")
|
||||
public subscript(position: Index) -> Base.Element {
|
||||
switch position.representation {
|
||||
case .start: return base[base.startIndex]
|
||||
case .base(_, let result): return result
|
||||
case .end: fatalError("Cannot get element of end index.")
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
guard let result = index.result else {
|
||||
fatalError("Can't advance past endIndex")
|
||||
public func index(after i: Index) -> Index {
|
||||
func index(after i: Base.Index, previous: Base.Element) -> Index {
|
||||
let index = base.index(after: i)
|
||||
guard index != base.endIndex else { return endIndex }
|
||||
return Index(.base(index: index, result: transform(previous, base[index])))
|
||||
}
|
||||
switch i.representation {
|
||||
case .start:
|
||||
return index(after: base.startIndex, previous: base[base.startIndex])
|
||||
case let .base(i, element):
|
||||
return index(after: i, previous: element)
|
||||
case .end:
|
||||
fatalError("Cannot get index after end index.")
|
||||
}
|
||||
|
||||
let index = base.index(after: index.base)
|
||||
let nextResult = index == base.endIndex
|
||||
? nil
|
||||
: transform(result, base[index])
|
||||
|
||||
return Index(base: index, result: nextResult)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
base.distance(from: start.base, to: end.base)
|
||||
switch (start.representation, end.representation) {
|
||||
case (.start, .start):
|
||||
return 0
|
||||
case let (.start, .base(index, _)):
|
||||
return base.distance(from: base.startIndex, to: index)
|
||||
case (.start, .end):
|
||||
return base.distance(from: base.startIndex, to: base.endIndex)
|
||||
case let (.base(index, _), .start):
|
||||
return base.distance(from: index, to: base.startIndex)
|
||||
case let (.base(start, _), .base(end, _)):
|
||||
return base.distance(from: start, to: end)
|
||||
case let (.base(index, _), .end):
|
||||
return base.distance(from: index, to: base.endIndex)
|
||||
case (.end, .start):
|
||||
return base.distance(from: base.endIndex, to: base.startIndex)
|
||||
case let (.end, .base(index, _)):
|
||||
return base.distance(from: base.endIndex, to: index)
|
||||
case (.end, .end):
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductionsSequence: LazySequenceProtocol {}
|
||||
extension InclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension InclusiveReductionsSequence: LazyCollectionProtocol
|
||||
where Base: Collection {}
|
||||
extension InclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension InclusiveReductionsSequence.Index: Hashable
|
||||
where Base.Index: Hashable
|
||||
{
|
||||
// MARK: - ReductionsIndexRepresentation
|
||||
|
||||
@usableFromInline
|
||||
enum ReductionsIndexRepresentation<BaseIndex: Comparable, Result> {
|
||||
case start
|
||||
case base(index: BaseIndex, result: Result)
|
||||
case end
|
||||
}
|
||||
|
||||
extension ReductionsIndexRepresentation: Equatable {
|
||||
@inlinable
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(base)
|
||||
static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (.start, .start): return true
|
||||
case (.end, .end): return true
|
||||
case let (.base(lhs, _), .base(rhs, _)): return lhs == rhs
|
||||
default: return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ReductionsIndexRepresentation: Comparable {
|
||||
@inlinable
|
||||
static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (_, .start): return false
|
||||
case (.start, _): return true
|
||||
case (.end, _): return false
|
||||
case (_, .end): return true
|
||||
case let (.base(lhs, _), .base(rhs, _)): return lhs < rhs
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Scan
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductionsSequence<Elements, Result> {
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
reductions(initial, transform)
|
||||
}
|
||||
|
||||
@@ -574,12 +594,13 @@ extension LazySequenceProtocol {
|
||||
public func scan<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductionsSequence<Elements, Result> {
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
reductions(into: initial, transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
@@ -600,16 +621,18 @@ extension Sequence {
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:) instead.")
|
||||
@inlinable
|
||||
public func scan(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductionsSequence<Elements> {
|
||||
) -> InclusiveReductions<Self> {
|
||||
reductions(transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:) instead.")
|
||||
@inlinable
|
||||
public func scan(
|
||||
|
||||
@@ -75,8 +75,8 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
|
||||
extension MutableCollection {
|
||||
/// Swaps the elements of the two given subranges, up to the upper bound of
|
||||
/// the smaller subrange. The returned indices are the ends of the two ranges
|
||||
/// that were actually swapped.
|
||||
/// the smaller subrange. The returned indices are the ends of the two
|
||||
/// ranges that were actually swapped.
|
||||
///
|
||||
/// Input:
|
||||
/// [a b c d e f g h i j k l m n o p]
|
||||
@@ -112,8 +112,8 @@ extension MutableCollection {
|
||||
return (p, q)
|
||||
}
|
||||
|
||||
/// Rotates the elements within the given subrange so that the element at the
|
||||
/// specified index becomes the start of the subrange.
|
||||
/// Rotates the elements within the given subrange so that the element
|
||||
/// at the specified index becomes the start of the subrange.
|
||||
///
|
||||
/// Rotating a collection is equivalent to breaking the collection into two
|
||||
/// sections at the index `newStart`, and then swapping those two sections.
|
||||
@@ -146,9 +146,10 @@ extension MutableCollection {
|
||||
if s == m { return e }
|
||||
if m == e { return s }
|
||||
|
||||
// We have two regions of possibly-unequal length that need to be exchanged.
|
||||
// The return value of this method is going to be the position following
|
||||
// that of the element that is currently last (element j).
|
||||
// We have two regions of possibly-unequal length that need to be
|
||||
// exchanged. The return value of this method is going to be the
|
||||
// position following that of the element that is currently last
|
||||
// (element j).
|
||||
//
|
||||
// [a b c d e f g|h i j] or [a b c|d e f g h i j]
|
||||
// ^ ^ ^ ^ ^ ^
|
||||
@@ -156,8 +157,8 @@ extension MutableCollection {
|
||||
//
|
||||
var ret = e // start with a known incorrect result.
|
||||
while true {
|
||||
// Exchange the leading elements of each region (up to the length of the
|
||||
// shorter region).
|
||||
// Exchange the leading elements of each region (up to the
|
||||
// length of the shorter region).
|
||||
//
|
||||
// [a b c d e f g|h i j] or [a b c|d e f g h i j]
|
||||
// ^^^^^ ^^^^^ ^^^^^ ^^^^^
|
||||
@@ -168,20 +169,21 @@ extension MutableCollection {
|
||||
let (s1, m1) = _swapNonemptySubrangePrefixes(s..<m, m..<e)
|
||||
|
||||
if m1 == e {
|
||||
// Left-hand case: we have moved element j into position. If we haven't
|
||||
// already, we can capture the return value which is in s1.
|
||||
// Left-hand case: we have moved element j into position. if
|
||||
// we haven't already, we can capture the return value which
|
||||
// is in s1.
|
||||
//
|
||||
// Note: the STL breaks the loop into two just to avoid this comparison
|
||||
// once the return value is known. I'm not sure it's a worthwhile
|
||||
// optimization, though.
|
||||
// Note: the STL breaks the loop into two just to avoid this
|
||||
// comparison once the return value is known. I'm not sure
|
||||
// it's a worthwhile optimization, though.
|
||||
if ret == e { ret = s1 }
|
||||
|
||||
// If both regions were the same size, we're done.
|
||||
if s1 == m { break }
|
||||
}
|
||||
|
||||
// Now we have a smaller problem that is also a rotation, so we can adjust
|
||||
// our bounds and repeat.
|
||||
// Now we have a smaller problem that is also a rotation, so we
|
||||
// can adjust our bounds and repeat.
|
||||
//
|
||||
// h i j[d e f g|a b c] or d e f[a b c|g h i j]
|
||||
// ^ ^ ^ ^ ^ ^
|
||||
@@ -193,8 +195,8 @@ extension MutableCollection {
|
||||
return ret
|
||||
}
|
||||
|
||||
/// Rotates the elements of this collection so that the element at the
|
||||
/// specified index becomes the start of the collection.
|
||||
/// Rotates the elements of this collection so that the element
|
||||
/// at the specified index becomes the start of the collection.
|
||||
///
|
||||
/// Rotating a collection is equivalent to breaking the collection into two
|
||||
/// sections at the index `newStart`, and then swapping those two sections.
|
||||
@@ -219,8 +221,8 @@ extension MutableCollection {
|
||||
}
|
||||
|
||||
extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// Rotates the elements within the given subrange so that the element at the
|
||||
/// specified index becomes the start of the subrange.
|
||||
/// Rotates the elements within the given subrange so that the element
|
||||
/// at the specified index becomes the start of the subrange.
|
||||
///
|
||||
/// Rotating a collection is equivalent to breaking the collection into two
|
||||
/// sections at the index `newStart`, and then swapping those two sections.
|
||||
@@ -253,13 +255,13 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
return newStart == p ? q : p
|
||||
}
|
||||
|
||||
/// Rotates the elements of this collection so that the element at the
|
||||
/// specified index becomes the start of the collection.
|
||||
/// Rotates the elements of this collection so that the element
|
||||
/// at the specified index becomes the start of the collection.
|
||||
///
|
||||
/// Rotating a collection is equivalent to breaking the collection into two
|
||||
/// sections at the index `newStart`, and then swapping those two sections. In
|
||||
/// this example, the `numbers` array is rotated so that the element at index
|
||||
/// `3` (`40`) is first:
|
||||
/// sections at the index `newStart`, and then swapping those two sections.
|
||||
/// In this example, the `numbers` array is rotated so that the element at
|
||||
/// index `3` (`40`) is first:
|
||||
///
|
||||
/// var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
/// let oldStart = numbers.rotate(toStartAt: 3)
|
||||
@@ -277,3 +279,22 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
rotate(subrange: startIndex..<endIndex, toStartAt: newStart)
|
||||
}
|
||||
}
|
||||
|
||||
// Deprecations
|
||||
|
||||
extension MutableCollection {
|
||||
@available(*, deprecated, renamed: "rotate(subrange:toStartAt:)")
|
||||
@discardableResult
|
||||
public mutating func rotate(
|
||||
subrange: Range<Index>,
|
||||
at newStart: Index) -> Index
|
||||
{
|
||||
rotate(subrange: subrange, toStartAt: newStart)
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "rotate(toStartAt:)")
|
||||
@discardableResult
|
||||
public mutating func rotate(at newStart: Index) -> Index {
|
||||
rotate(toStartAt: newStart)
|
||||
}
|
||||
}
|
||||
@@ -14,46 +14,47 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a sequence stepping through the elements every `step` starting at
|
||||
/// the first value. Any remainders of the stride will be trimmed.
|
||||
/// Returns a sequence stepping through the elements every `step` starting
|
||||
/// at the first value. Any remainders of the stride will be trimmed.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
///
|
||||
/// - Complexity: O(1). Access to successive values is O(k) where _k_ is the
|
||||
/// striding `step`.
|
||||
/// - Complexity: O(1). Access to successive values is O(k) where
|
||||
/// _k_ is the striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a sequence for stepping through the elements by the
|
||||
/// specified amount.
|
||||
/// - Returns: Returns a sequence for stepping through the
|
||||
/// elements by the specified amount.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StridingSequence<Self> {
|
||||
StridingSequence(base: self, stride: step)
|
||||
public func striding(by step: Int) -> StrideSequence<Self> {
|
||||
StrideSequence(base: self, stride: step)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a sequence stepping through the elements every `step` starting at
|
||||
/// the first value. Any remainders of the stride will be trimmed.
|
||||
/// Returns a sequence stepping through the elements every `step` starting
|
||||
/// at the first value. Any remainders of the stride will be trimmed.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
///
|
||||
/// - Complexity: O(1). Access to successive values is O(1) if the collection
|
||||
/// conforms to `RandomAccessCollection`; otherwise, O(_k_), where _k_ is
|
||||
/// the striding `step`.
|
||||
/// - Complexity: O(1). Access to successive values is O(1) if the
|
||||
/// collection conforms to `RandomAccessCollection`; otherwise,
|
||||
/// O(_k_), where _k_ is the striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a collection for stepping through the elements by the
|
||||
/// specified amount.
|
||||
/// - Returns: Returns a collection for stepping through the
|
||||
/// elements by the specified amount.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StridingCollection<Self> {
|
||||
StridingCollection(base: self, stride: step)
|
||||
public func striding(by step: Int) -> StrideCollection<Self> {
|
||||
StrideCollection(base: self, stride: step)
|
||||
}
|
||||
}
|
||||
|
||||
/// A wrapper that strides over a base sequence.
|
||||
public struct StridingSequence<Base: Sequence> {
|
||||
public struct StrideSequence<Base: Sequence>: Sequence {
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -62,21 +63,15 @@ public struct StridingSequence<Base: Sequence> {
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "Stride must be greater than zero")
|
||||
precondition(stride > 0, "striding must be greater than zero")
|
||||
self.base = base
|
||||
self.stride = stride
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingSequence {
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> Self {
|
||||
Self(base: base, stride: stride * step)
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingSequence: Sequence {
|
||||
/// An iterator over a `StridingSequence` instance.
|
||||
extension StrideSequence {
|
||||
|
||||
/// An iterator over a `Stride` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
@@ -112,11 +107,15 @@ extension StridingSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension StrideSequence {
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> Self {
|
||||
Self(base: base, stride: stride * step)
|
||||
}
|
||||
}
|
||||
|
||||
/// A wrapper that strides over a base collection.
|
||||
public struct StridingCollection<Base: Collection> {
|
||||
public struct StrideCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@@ -131,15 +130,16 @@ public struct StridingCollection<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingCollection {
|
||||
extension StrideCollection {
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> Self {
|
||||
Self(base: base, stride: stride * step)
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingCollection: Collection {
|
||||
/// A position in a `StridingCollection` instance.
|
||||
extension StrideCollection: Collection {
|
||||
|
||||
/// A position in a `Stride` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let base: Base.Index
|
||||
@@ -172,7 +172,7 @@ extension StridingCollection: Collection {
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.base != base.endIndex, "Advancing past end index")
|
||||
precondition(i.base < base.endIndex, "Advancing past end index")
|
||||
return index(i, offsetBy: 1)
|
||||
}
|
||||
|
||||
@@ -226,15 +226,9 @@ extension StridingCollection: Collection {
|
||||
offsetBy n: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
// We typically use the ternary operator but this significantly increases
|
||||
// compile times when using Swift 5.3.2
|
||||
// https://github.com/apple/swift-algorithms/issues/146
|
||||
let distance: Int
|
||||
if i == endIndex {
|
||||
distance = -((base.count - 1) % stride + 1) + (n - 1) * -stride
|
||||
} else {
|
||||
distance = n * -stride
|
||||
}
|
||||
let distance = i == endIndex
|
||||
? -((base.count - 1) % stride + 1) + (n - 1) * -stride
|
||||
: n * -stride
|
||||
return base.index(
|
||||
i.base,
|
||||
offsetBy: distance,
|
||||
@@ -255,8 +249,8 @@ extension StridingCollection: Collection {
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
precondition(distance <= 0 || i.base != base.endIndex, "Advancing past end index")
|
||||
precondition(distance >= 0 || i.base != base.startIndex, "Incrementing past start index")
|
||||
precondition(distance <= 0 || i.base < base.endIndex, "Advancing past end index")
|
||||
precondition(distance >= 0 || i.base > base.startIndex, "Incrementing past start index")
|
||||
let limit = distance > 0 ? endIndex : startIndex
|
||||
let idx = index(i, offsetBy: distance, limitedBy: limit)
|
||||
precondition(idx != nil, "The distance \(distance) is not valid for this collection")
|
||||
@@ -264,20 +258,15 @@ extension StridingCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingCollection: BidirectionalCollection
|
||||
extension StrideCollection: BidirectionalCollection
|
||||
where Base: RandomAccessCollection {
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i.base != base.startIndex, "Incrementing past start index")
|
||||
precondition(i.base > base.startIndex, "Incrementing past start index")
|
||||
return index(i, offsetBy: -1)
|
||||
}
|
||||
}
|
||||
|
||||
extension StridingCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension StridingCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension StridingCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
extension StrideCollection: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension StrideCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -17,10 +17,10 @@ extension BidirectionalCollection {
|
||||
/// Returns a subsequence containing the elements from the end until
|
||||
/// `predicate` returns `false` and skipping the remaining elements.
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the sequence as
|
||||
/// its argument and returns `true` if the element should be included or
|
||||
/// `false` if it should be excluded. Once the predicate returns `false` it
|
||||
/// will not be called again.
|
||||
/// - Parameter predicate: A closure that takes an element of the
|
||||
/// sequence as its argument and returns `true` if the element should
|
||||
/// be included or `false` if it should be excluded. Once the predicate
|
||||
/// returns `false` it will not be called again.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
|
||||
@@ -13,17 +13,18 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the start of
|
||||
/// the collection which satisfy the given predicate.
|
||||
/// 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:
|
||||
/// 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 "
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -32,7 +33,7 @@ extension Collection {
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let start = try endOfPrefix(while: predicate)
|
||||
return self[start...]
|
||||
return self[start..<endIndex]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -41,18 +42,19 @@ extension Collection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection where Self: RangeReplaceableCollection {
|
||||
/// Mutates a `Collection` by discarding all elements at the start of it which
|
||||
/// satisfy the given predicate.
|
||||
/// 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:
|
||||
/// 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 "
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -67,18 +69,19 @@ extension Collection where Self: RangeReplaceableCollection {
|
||||
}
|
||||
|
||||
extension Collection where Self == Self.SubSequence {
|
||||
/// Mutates a `Collection` by discarding all elements at the start of it which
|
||||
/// satisfy the given predicate.
|
||||
/// 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:
|
||||
/// 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.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -104,8 +107,9 @@ extension BidirectionalCollection {
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimming(while: \.isWhitespace)) // "hello, world"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -113,20 +117,21 @@ extension BidirectionalCollection {
|
||||
public func trimming(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
try trimmingPrefix(while: predicate).trimmingSuffix(while: predicate)
|
||||
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.
|
||||
/// 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:
|
||||
/// 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"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -135,7 +140,7 @@ extension BidirectionalCollection {
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let end = try startOfSuffix(while: predicate)
|
||||
return self[..<end]
|
||||
return self[startIndex..<end]
|
||||
}
|
||||
}
|
||||
|
||||
@@ -144,18 +149,19 @@ extension BidirectionalCollection {
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
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.
|
||||
/// 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:
|
||||
/// 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"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -164,22 +170,22 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
public mutating func trim(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows {
|
||||
try trimSuffix(while: predicate)
|
||||
try trimPrefix(while: predicate)
|
||||
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:
|
||||
/// 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"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -194,18 +200,19 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
|
||||
}
|
||||
|
||||
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.
|
||||
/// 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:
|
||||
/// 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"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - 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.
|
||||
///
|
||||
@@ -219,15 +226,16 @@ extension BidirectionalCollection where Self == Self.SubSequence {
|
||||
/// 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:
|
||||
/// 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"
|
||||
///
|
||||
/// - Parameter predicate: A closure which determines if the element should be
|
||||
/// removed from the string.
|
||||
/// - 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.
|
||||
///
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence wrapper that leaves out duplicate elements of a base sequence.
|
||||
public struct UniquedSequence<Base: Sequence, Subject: Hashable> {
|
||||
public struct Uniqued<Base: Sequence, Subject: Hashable> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
@@ -26,8 +26,8 @@ public struct UniquedSequence<Base: Sequence, Subject: Hashable> {
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquedSequence: Sequence {
|
||||
/// The iterator for a `UniquedSequence` instance.
|
||||
extension Uniqued: Sequence {
|
||||
/// The iterator for a `Uniqued` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
@@ -64,8 +64,7 @@ extension UniquedSequence: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension Uniqued: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// uniqued()
|
||||
@@ -84,8 +83,8 @@ extension Sequence where Element: Hashable {
|
||||
/// .
|
||||
/// - Complexity: O(1).
|
||||
@inlinable
|
||||
public func uniqued() -> UniquedSequence<Self, Element> {
|
||||
UniquedSequence(base: self, projection: { $0 })
|
||||
public func uniqued() -> Uniqued<Self, Element> {
|
||||
Uniqued(base: self, projection: { $0 })
|
||||
}
|
||||
}
|
||||
|
||||
@@ -103,9 +102,9 @@ extension Sequence {
|
||||
/// // Prints '["dog", "pig", "cat", "ox"]'
|
||||
///
|
||||
/// - Parameter projection: A closure that transforms an element into the
|
||||
/// value to use for uniqueness. If `projection` returns the same value for
|
||||
/// two different elements, the second element will be excluded from the
|
||||
/// resulting array.
|
||||
/// value to use for uniqueness. If `projection` returns the same value
|
||||
/// for two different elements, the second element will be excluded
|
||||
/// from the resulting array.
|
||||
///
|
||||
/// - Returns: An array with only the unique elements of this sequence, as
|
||||
/// determined by the result of `projection` for each element.
|
||||
@@ -139,7 +138,7 @@ extension LazySequenceProtocol {
|
||||
@inlinable
|
||||
public func uniqued<Subject: Hashable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> UniquedSequence<Self, Subject> {
|
||||
UniquedSequence(base: self, projection: projection)
|
||||
) -> Uniqued<Self, Subject> {
|
||||
Uniqued(base: self, projection: projection)
|
||||
}
|
||||
}
|
||||
@@ -39,35 +39,35 @@ extension Collection {
|
||||
/// `RandomAccessCollection`, otherwise O(*k*) where `k` is `count`.
|
||||
/// Access to successive windows is O(1).
|
||||
@inlinable
|
||||
public func windows(ofCount count: Int) -> WindowsOfCountCollection<Self> {
|
||||
WindowsOfCountCollection(base: self, windowSize: count)
|
||||
public func windows(ofCount count: Int) -> Windows<Self> {
|
||||
Windows(base: self, size: count)
|
||||
}
|
||||
}
|
||||
|
||||
/// A collection wrapper that presents a sliding window over the elements of
|
||||
/// a collection.
|
||||
public struct WindowsOfCountCollection<Base: Collection> {
|
||||
public struct Windows<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let windowSize: Int
|
||||
internal let size: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var endOfFirstWindow: Base.Index?
|
||||
internal var firstUpperBound: Base.Index?
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, windowSize: Int) {
|
||||
precondition(windowSize > 0, "Windows size must be greater than zero")
|
||||
internal init(base: Base, size: Int) {
|
||||
precondition(size > 0, "Windows size must be greater than zero")
|
||||
self.base = base
|
||||
self.windowSize = windowSize
|
||||
self.endOfFirstWindow =
|
||||
base.index(base.startIndex, offsetBy: windowSize, limitedBy: base.endIndex)
|
||||
self.size = size
|
||||
self.firstUpperBound =
|
||||
base.index(base.startIndex, offsetBy: size, limitedBy: base.endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
extension WindowsOfCountCollection: Collection {
|
||||
/// A position in a `WindowsOfCountCollection` instance.
|
||||
extension Windows: Collection {
|
||||
/// A position in a `Windows` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var lowerBound: Base.Index
|
||||
@@ -94,7 +94,7 @@ extension WindowsOfCountCollection: Collection {
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
if let upperBound = endOfFirstWindow {
|
||||
if let upperBound = firstUpperBound {
|
||||
return Index(lowerBound: base.startIndex, upperBound: upperBound)
|
||||
} else {
|
||||
return endIndex
|
||||
@@ -116,14 +116,12 @@ extension WindowsOfCountCollection: Collection {
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
precondition(index != endIndex, "Advancing past end index")
|
||||
precondition(index < endIndex, "Advancing past end index")
|
||||
guard index.upperBound < base.endIndex else { return endIndex }
|
||||
|
||||
let lowerBound = windowSize == 1
|
||||
? index.upperBound
|
||||
: base.index(after: index.lowerBound)
|
||||
let upperBound = base.index(after: index.upperBound)
|
||||
return Index(lowerBound: lowerBound, upperBound: upperBound)
|
||||
return Index(
|
||||
lowerBound: base.index(after: index.lowerBound),
|
||||
upperBound: base.index(after: index.upperBound)
|
||||
)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
@@ -187,7 +185,7 @@ extension WindowsOfCountCollection: Collection {
|
||||
// |> > >|>| or |> > >|
|
||||
// output: [x x x x x|x x x x x] [x x x x x x x x x x] (`endIndex`)
|
||||
|
||||
if distance >= windowSize {
|
||||
if distance >= size {
|
||||
// Avoid traversing `self[i.lowerBound..<i.upperBound]` when the lower
|
||||
// bound of the output is greater than or equal to the upper bound of the
|
||||
// input.
|
||||
@@ -199,11 +197,11 @@ extension WindowsOfCountCollection: Collection {
|
||||
guard limit.lowerBound >= i.upperBound,
|
||||
let lowerBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - windowSize,
|
||||
offsetBy: distance - size,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: windowSize - 1,
|
||||
offsetBy: size - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
@@ -264,9 +262,9 @@ extension WindowsOfCountCollection: Collection {
|
||||
else { return nil }
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -windowSize),
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
} else if distance >= windowSize {
|
||||
} else if distance >= size {
|
||||
// Avoid traversing `self[i.lowerBound..<i.upperBound]` when the upper
|
||||
// bound of the output is less than or equal to the lower bound of the
|
||||
// input.
|
||||
@@ -278,12 +276,12 @@ extension WindowsOfCountCollection: Collection {
|
||||
guard limit.upperBound <= i.lowerBound,
|
||||
let upperBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -(distance - windowSize),
|
||||
offsetBy: -(distance - size),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -windowSize),
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
} else {
|
||||
// input: [x x x x x|x x x x x x|x]
|
||||
@@ -306,7 +304,7 @@ extension WindowsOfCountCollection: Collection {
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start <= end else { return -distance(from: end, to: start) }
|
||||
guard start != end else { return 0 }
|
||||
guard end != endIndex else {
|
||||
guard end < endIndex else {
|
||||
// We add 1 here because the index before `endIndex` also has
|
||||
// `base.endIndex` as its upper bound.
|
||||
return base[start.upperBound...].count + 1
|
||||
@@ -320,7 +318,7 @@ extension WindowsOfCountCollection: Collection {
|
||||
// |- - - -|> >|
|
||||
// end: [x x x x x x x|x x x x|x]
|
||||
|
||||
return windowSize + base[start.upperBound..<end.lowerBound].count
|
||||
return size + base[start.upperBound..<end.lowerBound].count
|
||||
} else {
|
||||
// start: [x|x x x x x x|x x x x x]
|
||||
// |> > > >|
|
||||
@@ -331,15 +329,13 @@ extension WindowsOfCountCollection: Collection {
|
||||
}
|
||||
}
|
||||
|
||||
extension WindowsOfCountCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
extension Windows: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
precondition(index != startIndex, "Incrementing past start index")
|
||||
precondition(index > startIndex, "Incrementing past start index")
|
||||
if index == endIndex {
|
||||
return Index(
|
||||
lowerBound: base.index(index.lowerBound, offsetBy: -windowSize),
|
||||
lowerBound: base.index(index.lowerBound, offsetBy: -size),
|
||||
upperBound: index.upperBound
|
||||
)
|
||||
} else {
|
||||
@@ -351,10 +347,7 @@ extension WindowsOfCountCollection: BidirectionalCollection
|
||||
}
|
||||
}
|
||||
|
||||
extension WindowsOfCountCollection: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension WindowsOfCountCollection: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension WindowsOfCountCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
extension Windows: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
extension Windows: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
|
||||
extension Windows: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension Windows.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -0,0 +1,19 @@
|
||||
//===----------------------------------------------------------*- swift -*-===//
|
||||
//
|
||||
// This source file is part of the Swift Argument Parser 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
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#error("""
|
||||
|
||||
-----------------------------------------------------
|
||||
|
||||
Please test with `swift test --enable-test-discovery`
|
||||
|
||||
-----------------------------------------------------
|
||||
""")
|
||||
@@ -70,11 +70,11 @@ final class AdjacentPairsTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testIndexTraversals() {
|
||||
let validator = IndexValidator<AdjacentPairsCollection<Range<Int>>>()
|
||||
validator.validate((0..<0).adjacentPairs(), expectedCount: 0)
|
||||
validator.validate((0..<1).adjacentPairs(), expectedCount: 0)
|
||||
validator.validate((0..<2).adjacentPairs(), expectedCount: 1)
|
||||
validator.validate((0..<5).adjacentPairs(), expectedCount: 4)
|
||||
validateIndexTraversals(
|
||||
(0..<0).adjacentPairs(),
|
||||
(0..<1).adjacentPairs(),
|
||||
(0..<2).adjacentPairs(),
|
||||
(0..<5).adjacentPairs())
|
||||
}
|
||||
|
||||
func testLaziness() {
|
||||
|
||||
@@ -36,17 +36,16 @@ final class ChainTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testChainIndexTraversals() {
|
||||
let validator = IndexValidator<Chain2Sequence<String, String>>(
|
||||
indicesIncludingEnd: { chain in
|
||||
validateIndexTraversals(
|
||||
chain("abcd", "XYZ"),
|
||||
chain("abcd", ""),
|
||||
chain("", "XYZ"),
|
||||
chain("", ""),
|
||||
indices: { chain in
|
||||
chain.base1.indices.map { .init(first: $0) }
|
||||
+ chain.base2.indices.map { .init(second: $0) }
|
||||
+ [.init(second: chain.base2.endIndex)]
|
||||
})
|
||||
|
||||
validator.validate(chain("abcd", "XYZ"), expectedCount: 4 + 3)
|
||||
validator.validate(chain("abcd", ""), expectedCount: 4 + 0)
|
||||
validator.validate(chain("", "XYZ"), expectedCount: 0 + 3)
|
||||
validator.validate(chain("", ""), expectedCount: 0 + 0)
|
||||
}
|
||||
|
||||
func testChainIndexOffsetAcrossBoundary() {
|
||||
|
||||
@@ -67,7 +67,7 @@ final class ChunkedTests: XCTestCase {
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(on: { $0.first })
|
||||
validateFruitChunks(lazyChunks.map { $1 })
|
||||
IndexValidator().validate(lazyChunks)
|
||||
validateIndexTraversals(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedBy() {
|
||||
@@ -75,23 +75,7 @@ final class ChunkedTests: XCTestCase {
|
||||
|
||||
let lazyChunks = fruits.lazy.chunked(by: { $0.first == $1.first })
|
||||
validateFruitChunks(lazyChunks)
|
||||
IndexValidator().validate(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedByComparesConsecutiveElements() {
|
||||
XCTAssertEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].chunked(by: { $1 - $0 == 1 }),
|
||||
[[1, 2, 3, 4], [6, 7, 8, 9]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }),
|
||||
[[1, 2, 3, 4], [6, 7, 8, 9]])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }).reversed(),
|
||||
[[6, 7, 8, 9], [1, 2, 3, 4]])
|
||||
|
||||
IndexValidator().validate([1, 2, 3].lazy.chunked(by: { $1 - $0 == 1 }))
|
||||
validateIndexTraversals(lazyChunks)
|
||||
}
|
||||
|
||||
func testChunkedLazy() {
|
||||
@@ -156,51 +140,15 @@ final class ChunkedTests: XCTestCase {
|
||||
func testEmptyChunksOfCountTraversal() {
|
||||
let emptyChunks = [Int]().chunks(ofCount: 1)
|
||||
|
||||
IndexValidator().validate(emptyChunks, expectedCount: 0)
|
||||
validateIndexTraversals(emptyChunks)
|
||||
}
|
||||
|
||||
func testChunksOfCountTraversal() {
|
||||
let validator = IndexValidator<ChunksOfCountCollection<ClosedRange<Int>>>()
|
||||
|
||||
for i in 1...10 {
|
||||
let range = 1...50
|
||||
let chunks = range.chunks(ofCount: i)
|
||||
validator.validate(
|
||||
chunks,
|
||||
expectedCount: range.count / i + (range.count % i).signum())
|
||||
for i in 1..<10 {
|
||||
let collection = (1...50).map { $0 }
|
||||
let chunks = collection.chunks(ofCount: i)
|
||||
|
||||
validateIndexTraversals(chunks)
|
||||
}
|
||||
}
|
||||
|
||||
func testEvenChunks() {
|
||||
XCTAssertEqualSequences(
|
||||
(0..<10).evenlyChunked(in: 4),
|
||||
[0..<3, 3..<6, 6..<8, 8..<10])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
(0..<3).evenlyChunked(in: 5),
|
||||
[0..<1, 1..<2, 2..<3, 3..<3, 3..<3])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
"".evenlyChunked(in: 0),
|
||||
[])
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
"".evenlyChunked(in: 1),
|
||||
[""])
|
||||
}
|
||||
|
||||
func testEvenChunksIndexTraversals() {
|
||||
let validator = IndexValidator<EvenlyChunkedCollection<Range<Int>>>()
|
||||
|
||||
[
|
||||
(0..<10).evenlyChunked(in: 1),
|
||||
(0..<10).evenlyChunked(in: 2),
|
||||
(0..<10).evenlyChunked(in: 3),
|
||||
(0..<10).evenlyChunked(in: 10),
|
||||
(0..<10).evenlyChunked(in: 20),
|
||||
(0..<0).evenlyChunked(in: 0),
|
||||
(0..<0).evenlyChunked(in: 1),
|
||||
(0..<0).evenlyChunked(in: 10),
|
||||
].forEach { validator.validate($0) }
|
||||
}
|
||||
}
|
||||
@@ -37,9 +37,8 @@ final class CompactedTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testCollectionTraversals() {
|
||||
let validator = IndexValidator<CompactedCollection<[Int?], Int>>()
|
||||
for array in self.tests {
|
||||
validator.validate(array.compacted())
|
||||
validateIndexTraversals(array.compacted())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
@available(macOS 12.0, *)
|
||||
final class ConcurrentTests: XCTestCase {
|
||||
func testParallelMap() async throws {
|
||||
let source = 1...10
|
||||
let expected = source.map { $0 }
|
||||
let actual = try await source.parallelMap { $0 }
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
|
||||
func testParallelFirstIndex() async throws {
|
||||
let source = 0..<10
|
||||
let expected = 6
|
||||
let actual = try await source.parallelFirstIndex(parallelism: 2, where: { $0 > 5 })
|
||||
XCTAssertEqual(expected, actual)
|
||||
}
|
||||
}
|
||||
@@ -26,21 +26,25 @@ final class IntersperseTests: XCTestCase {
|
||||
func testString() {
|
||||
let interspersed = "ABCDE".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "A-B-C-D-E")
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testStringEmpty() {
|
||||
let interspersed = "".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "")
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testArray() {
|
||||
let interspersed = [1,2,3,4].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4])
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testArrayEmpty() {
|
||||
let interspersed = [].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [])
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testCollection() {
|
||||
@@ -51,14 +55,7 @@ final class IntersperseTests: XCTestCase {
|
||||
func testBidirectionalCollection() {
|
||||
let reversed = "ABCDE".interspersed(with: "-").reversed()
|
||||
XCTAssertEqualSequences(reversed, "E-D-C-B-A")
|
||||
}
|
||||
|
||||
func testIndexTraversals() {
|
||||
let validator = IndexValidator<InterspersedSequence<String>>()
|
||||
validator.validate("".interspersed(with: "-"), expectedCount: 0)
|
||||
validator.validate("A".interspersed(with: "-"), expectedCount: 1)
|
||||
validator.validate("AB".interspersed(with: "-"), expectedCount: 3)
|
||||
validator.validate("ABCDE".interspersed(with: "-"), expectedCount: 9)
|
||||
validateIndexTraversals(reversed)
|
||||
}
|
||||
|
||||
func testIntersperseLazy() {
|
||||
@@ -86,18 +83,10 @@ final class IntersperseTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testInterspersedMapIndexTraversals() {
|
||||
let validator = IndexValidator<InterspersedMapSequence<Range<Int>, Int>>()
|
||||
validator.validate(
|
||||
(0..<0).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
expectedCount: 0)
|
||||
validator.validate(
|
||||
(0..<1).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
expectedCount: 1)
|
||||
validator.validate(
|
||||
(0..<2).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
expectedCount: 3)
|
||||
validator.validate(
|
||||
(0..<5).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
|
||||
expectedCount: 9)
|
||||
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 }))
|
||||
}
|
||||
}
|
||||
@@ -111,22 +111,15 @@ final class JoinedTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testJoinedIndexTraversals() {
|
||||
let validator = IndexValidator<FlattenCollection<[String]>>()
|
||||
|
||||
// the last test case takes too long to run
|
||||
for strings in stringArrays.dropLast() {
|
||||
validator.validate(strings.joined() as FlattenCollection)
|
||||
validateIndexTraversals(strings.joined() as FlattenCollection)
|
||||
validateIndexTraversals(strings.joined(by: ", "))
|
||||
}
|
||||
}
|
||||
|
||||
func testJoinedByIndexTraversals() {
|
||||
let validator1 = IndexValidator<JoinedByCollection<[String], String>>()
|
||||
let validator2 = IndexValidator<JoinedByClosureCollection<[String], String>>()
|
||||
|
||||
// the last test case takes too long to run
|
||||
for (strings, separator) in product(stringArrays.dropLast(), ["", " ", ", "]) {
|
||||
validator1.validate(strings.joined(by: separator))
|
||||
validator2.validate(strings.lazy.joined(by: { _, _ in separator }))
|
||||
validateIndexTraversals(strings.joined(by: separator))
|
||||
validateIndexTraversals(strings.lazy.joined(by: { _, _ in separator }))
|
||||
}
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -13,10 +13,10 @@ import Algorithms
|
||||
import XCTest
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `SplitSequence` and `SplitCollection`
|
||||
// Tests for `LazySplitSequence` and `LazySplitCollection`
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
final class SplitTests: XCTestCase {
|
||||
final class LazySplitTests: XCTestCase {
|
||||
func testEmpty() {
|
||||
Validator(
|
||||
subject: [],
|
||||
@@ -92,26 +92,6 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
func testPartitioningIndexWithEmptyInput() {
|
||||
let input: [Int] = []
|
||||
|
||||
let a = input.partitioningIndex(where: { _ in return true })
|
||||
XCTAssertEqual(a, input.startIndex)
|
||||
|
||||
let b = input.partitioningIndex(where: { _ in return false })
|
||||
XCTAssertEqual(b, input.endIndex)
|
||||
}
|
||||
|
||||
func testPartitioningIndexWithOneEmptyPartition() {
|
||||
let input: Range<Int> = (0 ..< 10)
|
||||
|
||||
let a = input.partitioningIndex(where: { $0 > 10 })
|
||||
XCTAssertEqual(a, input.endIndex)
|
||||
|
||||
let b = input.partitioningIndex(where: { $0 >= 0 })
|
||||
XCTAssertEqual(b, input.startIndex)
|
||||
}
|
||||
|
||||
func testPartitionWithSubrangeBidirectionalCollection() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
@@ -153,40 +133,4 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testPartitionedWithEmptyInput() {
|
||||
let input: [Int] = []
|
||||
|
||||
let s0 = input.partitioned(by: { _ in return true })
|
||||
|
||||
XCTAssertTrue(s0.0.isEmpty)
|
||||
XCTAssertTrue(s0.1.isEmpty)
|
||||
}
|
||||
|
||||
/// Test the example given in the `partitioned(by:)` documentation
|
||||
func testPartitionedExample() throws {
|
||||
let cast = ["Vivien", "Marlon", "Kim", "Karl"]
|
||||
let (longNames, shortNames) = cast.partitioned(by: { $0.count < 5 })
|
||||
XCTAssertEqual(longNames, ["Vivien", "Marlon"])
|
||||
XCTAssertEqual(shortNames, ["Kim", "Karl"])
|
||||
}
|
||||
|
||||
func testPartitionedWithPredicate() throws {
|
||||
let s0 = ["A", "B", "C", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s1 = ["a", "B", "C", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s2 = ["a", "B", "c", "D"].partitioned(by: { $0 == $0.lowercased() })
|
||||
let s3 = ["a", "B", "c", "d"].partitioned(by: { $0 == $0.lowercased() })
|
||||
|
||||
XCTAssertEqual(s0.0, ["A", "B", "C", "D"])
|
||||
XCTAssertEqual(s0.1, [])
|
||||
|
||||
XCTAssertEqual(s1.0, ["B", "C", "D"])
|
||||
XCTAssertEqual(s1.1, ["a"])
|
||||
|
||||
XCTAssertEqual(s2.0, ["B", "D"])
|
||||
XCTAssertEqual(s2.1, ["a", "c"])
|
||||
|
||||
XCTAssertEqual(s3.0, ["B"])
|
||||
XCTAssertEqual(s3.1, ["a", "c", "d"])
|
||||
}
|
||||
}
|
||||
@@ -39,18 +39,17 @@ final class ProductTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testProductIndexTraversals() {
|
||||
let validator = IndexValidator<Product2Sequence<[Int], String>>(
|
||||
indicesIncludingEnd: { product in
|
||||
validateIndexTraversals(
|
||||
product([1, 2, 3, 4], "abc"),
|
||||
product([1, 2, 3, 4], ""),
|
||||
product([], "abc"),
|
||||
product([], ""),
|
||||
indices: { product in
|
||||
product.base1.indices.flatMap { i1 in
|
||||
product.base2.indices.map { i2 in
|
||||
.init(i1: i1, i2: i2)
|
||||
}
|
||||
} + [.init(i1: product.base1.endIndex, i2: product.base2.startIndex)]
|
||||
})
|
||||
|
||||
validator.validate(product([1, 2, 3, 4], "abc"), expectedCount: 4 * 3)
|
||||
validator.validate(product([1, 2, 3, 4], ""), expectedCount: 4 * 0)
|
||||
validator.validate(product([], "abc"), expectedCount: 0 * 3)
|
||||
validator.validate(product([], ""), expectedCount: 0 * 0)
|
||||
}
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class ReductionsTests: XCTestCase {
|
||||
|
||||
struct TestError: Error {}
|
||||
|
||||
// MARK: - Exclusive Reductions
|
||||
@@ -51,13 +52,6 @@ final class ReductionsTests: XCTestCase {
|
||||
XCTAssertNoThrow(try [].reductions(0) { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1].reductions(0) { _, _ in throw TestError() })
|
||||
}
|
||||
|
||||
func testExclusiveIndexTraversals() {
|
||||
let validator = IndexValidator<ExclusiveReductionsSequence<Range<Int>, Int>>()
|
||||
validator.validate((0..<0).lazy.reductions(0, +), expectedCount: 1)
|
||||
validator.validate((0..<1).lazy.reductions(0, +), expectedCount: 2)
|
||||
validator.validate((0..<4).lazy.reductions(0, +), expectedCount: 5)
|
||||
}
|
||||
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
@@ -84,11 +78,4 @@ final class ReductionsTests: XCTestCase {
|
||||
XCTAssertNoThrow(try [1].reductions { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1, 1].reductions { _, _ in throw TestError() })
|
||||
}
|
||||
|
||||
func testInclusiveIndexTraversals() {
|
||||
let validator = IndexValidator<InclusiveReductionsSequence<Range<Int>>>()
|
||||
validator.validate((0..<0).lazy.reductions(+), expectedCount: 0)
|
||||
validator.validate((0..<1).lazy.reductions(+), expectedCount: 1)
|
||||
validator.validate((0..<4).lazy.reductions(+), expectedCount: 4)
|
||||
}
|
||||
}
|
||||
@@ -88,37 +88,31 @@ final class StridingTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testIndexTraversals() {
|
||||
do {
|
||||
let empty = [Int]()
|
||||
let validator = IndexValidator<StridingCollection<[Int]>>()
|
||||
validator.validate(empty.striding(by: 1))
|
||||
validator.validate(empty.striding(by: 2))
|
||||
}
|
||||
|
||||
do {
|
||||
let range = 0...100
|
||||
let validator = IndexValidator<StridingCollection<ClosedRange<Int>>>()
|
||||
validator.validate(range.striding(by: 10))
|
||||
validator.validate(range.striding(by: 11))
|
||||
validator.validate(range.striding(by: 101))
|
||||
}
|
||||
|
||||
do {
|
||||
let array = Array(0...100)
|
||||
let validator = IndexValidator<StridingCollection<[Int]>>()
|
||||
validator.validate(array.striding(by: 10))
|
||||
validator.validate(array.striding(by: 11))
|
||||
validator.validate(array.striding(by: 101))
|
||||
}
|
||||
|
||||
do {
|
||||
let string = "swift rocks"
|
||||
let validator = IndexValidator<StridingCollection<String>>()
|
||||
validator.validate(string.striding(by: 1))
|
||||
validator.validate(string.striding(by: 2))
|
||||
validator.validate(string.striding(by: 10))
|
||||
}
|
||||
let empty = [Int]()
|
||||
validateIndexTraversals(
|
||||
empty.striding(by: 1),
|
||||
empty.striding(by: 2)
|
||||
)
|
||||
let zero_to_one_hundered_range = 0...100
|
||||
validateIndexTraversals(
|
||||
zero_to_one_hundered_range.striding(by: 10),
|
||||
zero_to_one_hundered_range.striding(by: 11),
|
||||
zero_to_one_hundered_range.striding(by: 101)
|
||||
)
|
||||
let zero_to_one_hundered_array = Array(zero_to_one_hundered_range)
|
||||
validateIndexTraversals(
|
||||
zero_to_one_hundered_array.striding(by: 10),
|
||||
zero_to_one_hundered_array.striding(by: 11),
|
||||
zero_to_one_hundered_array.striding(by: 101)
|
||||
)
|
||||
let string = "swift rocks".map(String.init)
|
||||
validateIndexTraversals(
|
||||
string.striding(by: 1),
|
||||
string.striding(by: 2),
|
||||
string.striding(by: 10)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
func testOffsetBy() {
|
||||
let a = (0...100).striding(by: 22)
|
||||
@@ -134,10 +128,4 @@ final class StridingTests: XCTestCase {
|
||||
let i = b.index(b.startIndex, offsetBy: 2)
|
||||
XCTAssertEqual(i, b.endIndex)
|
||||
}
|
||||
|
||||
func testLazy() {
|
||||
XCTAssertLazySequence(AnySequence(0..<100).lazy.striding(by: 3))
|
||||
XCTAssertLazySequence((0..<100).lazy.striding(by: 3))
|
||||
XCTAssertLazyCollection((0..<100).lazy.striding(by: 3))
|
||||
}
|
||||
}
|
||||
@@ -59,7 +59,7 @@ extension AnyMutableCollection: MutableCollection {
|
||||
var endIndex: Base.Index { base.endIndex }
|
||||
|
||||
func index(after i: Index) -> Index {
|
||||
base.index(after: i)
|
||||
return base.index(after: i)
|
||||
}
|
||||
|
||||
subscript(position: Base.Index) -> Base.Element {
|
||||
@@ -163,162 +163,93 @@ func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
|
||||
}
|
||||
}
|
||||
|
||||
struct IndexValidator<C: Collection> {
|
||||
let testRandomAccess = true
|
||||
let indicesIncludingEnd: (C) -> [C.Index]
|
||||
|
||||
/// Creates a new instance of an index validator that can verify that indices
|
||||
/// of a collection behave correctly and consistently.
|
||||
///
|
||||
/// Usage:
|
||||
///
|
||||
/// let validator = IndexValidator<ReversedCollection<String>>()
|
||||
/// validator.validate("abc".reversed())
|
||||
/// validator.validate("xyz".reversed(), expectedCount: 3)
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - testRandomAccess: If `true`, also tests the correctness of the methods
|
||||
/// `index(_:offsetBy:)`, `index(_:offsetBy:limitedBy:)`, and
|
||||
/// `distance(from:to:)`. Only useful if the collection overrides these
|
||||
/// methods. Defaults to `true`.
|
||||
/// - indicesIncludingEnd: A closure that returns the expected indices of
|
||||
/// the given collection, including its `endIndex`, in ascending order.
|
||||
/// Only use this parameter if you are able to compute the indices of the
|
||||
/// collection independently of the `Collection` conformance, e.g. by
|
||||
/// using the contents of the collection directly.
|
||||
init(
|
||||
testRandomAccess: Bool = true,
|
||||
indicesIncludingEnd: @escaping (C) -> [C.Index] = { $0.indices + [$0.endIndex] }
|
||||
) {
|
||||
self.indicesIncludingEnd = indicesIncludingEnd
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexValidator {
|
||||
fileprivate struct Validator {
|
||||
let collection: C
|
||||
let count: Int
|
||||
let indicesIncludingEnd: [C.Index]
|
||||
let file: StaticString
|
||||
let line: UInt
|
||||
}
|
||||
|
||||
/// Verifies that all index traversal methods behave as expected.
|
||||
///
|
||||
/// Verifies the correctness of the implementations of `startIndex`,
|
||||
/// `endIndex`, `indices`, `count`, `isEmpty`, `index(before:)`,
|
||||
/// `index(after:)`, `index(_:offsetBy:)`, `index(_:offsetBy:limitedBy:)`, and
|
||||
/// `distance(from:to:)` by calling them with just about all possible input
|
||||
/// combinations.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - collection: The collection to be validated.
|
||||
/// - expectedCount:
|
||||
///
|
||||
/// - Complexity: O(*n*^3) where *n* is the length of the collection if the
|
||||
/// collection conforms to `RandomAccesCollection`, otherwise O(*n*^4).
|
||||
func validate(
|
||||
_ collection: C,
|
||||
expectedCount: Int? = nil,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) {
|
||||
let indicesIncludingEnd = self.indicesIncludingEnd(collection)
|
||||
/// Tests that all index traversal methods behave as expected.
|
||||
///
|
||||
/// Verifies the correctness of the implementations of `startIndex`, `endIndex`,
|
||||
/// `indices`, `count`, `isEmpty`, `index(before:)`, `index(after:)`,
|
||||
/// `index(_:offsetBy:)`, `index(_:offsetBy:limitedBy:)`, and
|
||||
/// `distance(from:to:)` by calling them with just about all possible input
|
||||
/// combinations. When provided, the `indices` function is used to to test the
|
||||
/// collection methods against.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - collections: The collections to be validated.
|
||||
/// - indices: A closure that returns the expected indices of the given
|
||||
/// collection, including its `endIndex`, in ascending order. Only use this
|
||||
/// parameter if you are able to compute the indices of the collection
|
||||
/// independently of the `Collection` conformance, e.g. by using the
|
||||
/// contents of the collection directly.
|
||||
///
|
||||
/// - Complexity: O(*n*^3) for each collection, where *n* is the length of the
|
||||
/// collection.
|
||||
func validateIndexTraversals<C>(
|
||||
_ collections: C...,
|
||||
indices: ((C) -> [C.Index])? = nil,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) where C: BidirectionalCollection {
|
||||
for c in collections {
|
||||
let indicesIncludingEnd = indices?(c) ?? (c.indices + [c.endIndex])
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
let validator = Validator(
|
||||
collection: collection,
|
||||
count: count,
|
||||
indicesIncludingEnd: indicesIncludingEnd,
|
||||
file: file, line: line)
|
||||
|
||||
validator.validateForward(
|
||||
testRandomAccess: testRandomAccess,
|
||||
expectedCount: expectedCount)
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexValidator where C: BidirectionalCollection {
|
||||
func validate(
|
||||
_ collection: C, expectedCount: Int? = nil,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) {
|
||||
let indicesIncludingEnd = self.indicesIncludingEnd(collection)
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
let validator = Validator(
|
||||
collection: collection,
|
||||
count: count,
|
||||
indicesIncludingEnd: indicesIncludingEnd,
|
||||
file: file, line: line)
|
||||
|
||||
validator.validateForward(
|
||||
testRandomAccess: testRandomAccess,
|
||||
expectedCount: expectedCount)
|
||||
validator.validateBackward(testRandomAccess: testRandomAccess)
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexValidator.Validator {
|
||||
func validateForward(testRandomAccess: Bool, expectedCount: Int?) {
|
||||
if let expectedCount = expectedCount {
|
||||
XCTAssertEqual(
|
||||
expectedCount, count, "Count mismatch", file: file, line: line)
|
||||
}
|
||||
|
||||
XCTAssertEqual(
|
||||
collection.count, count,
|
||||
c.count, count,
|
||||
"Count mismatch",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
collection.isEmpty, count == 0,
|
||||
c.isEmpty, count == 0,
|
||||
"Emptiness mismatch",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
collection.startIndex, indicesIncludingEnd.first,
|
||||
c.startIndex, indicesIncludingEnd.first,
|
||||
"`startIndex` does not equal the first index",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
collection.endIndex, indicesIncludingEnd.last,
|
||||
c.endIndex, indicesIncludingEnd.last,
|
||||
"`endIndex` does not equal the last index",
|
||||
file: file, line: line)
|
||||
|
||||
validateIndexAfter()
|
||||
validateIndices()
|
||||
validateIndexComparisons()
|
||||
|
||||
if testRandomAccess {
|
||||
validateDistanceFromTo()
|
||||
validateIndexOffsetBy()
|
||||
validateIndexOffsetByLimitedBy()
|
||||
// `index(after:)`
|
||||
do {
|
||||
var index = c.startIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
|
||||
c.formIndex(after: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`startIndex` incremented \(offset) times does not equal index at \
|
||||
offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexAfter() {
|
||||
var index = collection.startIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
|
||||
collection.formIndex(after: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`startIndex` incremented \(offset) times does not equal index at \
|
||||
offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
// `index(before:)`
|
||||
do {
|
||||
var index = c.endIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast().reversed() {
|
||||
c.formIndex(before: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`endIndex` decremented \(count - offset) times does not equal index \
|
||||
at offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndices() {
|
||||
XCTAssertEqual(collection.indices.count, count)
|
||||
for (offset, index) in collection.indices.enumerated() {
|
||||
|
||||
// `indices`
|
||||
XCTAssertEqual(c.indices.count, count)
|
||||
for (offset, index) in c.indices.enumerated() {
|
||||
XCTAssertEqual(
|
||||
index, indicesIncludingEnd[offset],
|
||||
"Index mismatch at offset \(offset) in `indices`",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexComparisons() {
|
||||
|
||||
// index comparison
|
||||
for (offsetA, a) in indicesIncludingEnd.enumerated() {
|
||||
XCTAssertEqual(
|
||||
a, a,
|
||||
@@ -342,14 +273,21 @@ extension IndexValidator.Validator {
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateDistanceFromTo() {
|
||||
|
||||
// `index(_:offsetBy:)` and `distance(from:to:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated() {
|
||||
let distance = endOffset - startOffset
|
||||
|
||||
XCTAssertEqual(
|
||||
collection.distance(from: start, to: end), distance,
|
||||
c.index(start, offsetBy: distance), end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) does not equal \
|
||||
index at offset \(endOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c.distance(from: start, to: end), distance,
|
||||
"""
|
||||
Distance from index at offset \(startOffset) to index at offset \
|
||||
\(endOffset) does not equal \(distance)
|
||||
@@ -357,34 +295,18 @@ extension IndexValidator.Validator {
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexOffsetBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.index(start, offsetBy: distance), end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) does not \
|
||||
equal index at offset \(endOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexOffsetByLimitedBy() {
|
||||
|
||||
// `index(_:offsetBy:limitedBy:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
// verifies that the target index corresponding to each offset in
|
||||
// `range` can or cannot be reached from `start` using
|
||||
// `chain.index(start, offsetBy: _, limitedBy: limit)`, depending on
|
||||
// the value of `pastLimit`
|
||||
// `chain.index(start, offsetBy: _, limitedBy: limit)`, depending on the
|
||||
// value of `pastLimit`
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, pastLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = collection.index(start, offsetBy: distance, limitedBy: limit)
|
||||
let end = c.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
@@ -407,6 +329,7 @@ extension IndexValidator.Validator {
|
||||
}
|
||||
}
|
||||
|
||||
// forward offsets
|
||||
if limit >= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(startOffset...limitOffset, pastLimit: false)
|
||||
@@ -415,100 +338,8 @@ extension IndexValidator.Validator {
|
||||
// the limit has no effect
|
||||
checkTargetRange(startOffset...count, pastLimit: false)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension IndexValidator.Validator where C: BidirectionalCollection {
|
||||
func validateBackward(testRandomAccess: Bool) {
|
||||
validateIndexBefore()
|
||||
|
||||
if testRandomAccess {
|
||||
validateDistanceFromTo()
|
||||
validateIndexOffsetBy()
|
||||
validateIndexOffsetByLimitedBy()
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexBefore() {
|
||||
var index = collection.endIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast().reversed() {
|
||||
collection.formIndex(before: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`endIndex` decremented \(count - offset) times does not equal index \
|
||||
at offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
func validateDistanceFromTo() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.distance(from: start, to: end), distance,
|
||||
"""
|
||||
Distance from index at offset \(startOffset) to index at offset \
|
||||
\(endOffset) does not equal \(distance)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexOffsetBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(
|
||||
collection.index(start, offsetBy: distance), end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) does not \
|
||||
equal index at offset \(endOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func validateIndexOffsetByLimitedBy() {
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
// verifies that the target index corresponding to each offset in
|
||||
// `range` can or cannot be reached from `start` using
|
||||
// `chain.index(start, offsetBy: _, limitedBy: limit)`, depending on
|
||||
// the value of `pastLimit`
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, pastLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = collection.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) limited \
|
||||
by index at offset \(limitOffset) does not equal `nil`
|
||||
""",
|
||||
file: file, line: line)
|
||||
} else {
|
||||
XCTAssertEqual(
|
||||
end, indicesIncludingEnd[targetOffset],
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) limited \
|
||||
by index at offset \(limitOffset) does not equal index at \
|
||||
offset \(targetOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// backward offsets
|
||||
if limit <= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(limitOffset...startOffset, pastLimit: false)
|
||||
|
||||
@@ -12,7 +12,8 @@
|
||||
import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
final class WindowsTests: XCTestCase {
|
||||
final class windowsTests: XCTestCase {
|
||||
|
||||
func testWindowsOfString() {
|
||||
let s = "swift"
|
||||
let w = s.windows(ofCount: 2)
|
||||
@@ -86,23 +87,22 @@ final class WindowsTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testWindowsIndexTraversals() {
|
||||
let validator = IndexValidator<WindowsOfCountCollection<String>>(
|
||||
indicesIncludingEnd: { windows in
|
||||
validateIndexTraversals(
|
||||
"".windows(ofCount: 1),
|
||||
"a".windows(ofCount: 1),
|
||||
"ab".windows(ofCount: 1),
|
||||
"abc".windows(ofCount: 1),
|
||||
"".windows(ofCount: 3),
|
||||
"a".windows(ofCount: 3),
|
||||
"abc".windows(ofCount: 3),
|
||||
"abcdefgh".windows(ofCount: 3),
|
||||
indices: { windows in
|
||||
let endIndex = windows.base.endIndex
|
||||
let indices = windows.base.indices + [endIndex]
|
||||
return zip(indices, indices.dropFirst(windows.windowSize))
|
||||
return zip(indices, indices.dropFirst(windows.size))
|
||||
.map { .init(lowerBound: $0, upperBound: $1) }
|
||||
+ [.init(lowerBound: endIndex, upperBound: endIndex)]
|
||||
+ [.init(lowerBound: endIndex, upperBound: endIndex)]
|
||||
})
|
||||
|
||||
validator.validate("".windows(ofCount: 1), expectedCount: 0)
|
||||
validator.validate("a".windows(ofCount: 1), expectedCount: 1)
|
||||
validator.validate("ab".windows(ofCount: 1), expectedCount: 2)
|
||||
validator.validate("abc".windows(ofCount: 1), expectedCount: 3)
|
||||
validator.validate("".windows(ofCount: 3), expectedCount: 0)
|
||||
validator.validate("a".windows(ofCount: 3), expectedCount: 0)
|
||||
validator.validate("abc".windows(ofCount: 3), expectedCount: 1)
|
||||
validator.validate("abcdefgh".windows(ofCount: 3), expectedCount: 6)
|
||||
}
|
||||
|
||||
func testWindowsLazy() {
|
||||
|
||||
Reference in new issue
Block a user