Compare commits

..
Author SHA1 Message Date
Rick Newton-Rogers 8fdd7fe21d Revert "Bump swiftlang/github-workflows to 0.0.18 (#295)" (#296)
This reverts commit 8d14c58467.
2026-11-16 19:25:39 -05:00
Rick Newton-Rogers 8d14c58467 Bump swiftlang/github-workflows to 0.0.18 (#295)
The new workflows use macOS Golden Gate rather than macOS Tahoe by default.
2026-11-16 19:23:54 -05:00
Guillaume Lessard 5b7143f8e2 Merge pull request #272 from finagolfin/droid
[CI] Turn on Android testing
2026-07-22 16:09:31 -07:00
Finagolfin ea82f0e36e [CI] Turn on Android testing 2026-07-22 14:12:48 -07:00
Bassam (Sam) Khouri ff223da637 Merge pull request #276 from Martonveghcode/fix-documentation-typos
Fix documentation typos
2026-07-07 10:13:47 -04:00
Martonveghcode 9a7f462e2e Fix documentation typos 2026-07-06 18:38:14 +02:00
Melissa Kilby 0b4376902c chore: restrict GitHub workflow permissions - future-proof (#263) 2025-11-18 17:41:24 -06:00
Nate Cook 0aa3733a77 Fix swift-format errors throughout (#266) 2025-11-04 00:16:21 -06:00
Max Desiatov f6ce64a70a Add enable_wasm_sdk_build: true to pull_request.yml (#261) 2025-09-02 12:11:56 -05:00
Nate Cook 0e939e7bb9 Enable remaining soundness checks (#254)
Adds the documentation and license header checks.
Resolves #251.
2025-03-05 09:42:16 -06:00
Nate Cook 66ae806bbe Enable CI format check (#253)
* Incorporate swift-format formatting fixes
* Resolve linting issues
* Doc edits, mostly to fix linter-identified issues
* Early exit improvements
* Indentation fixes
* Line lengths to 80 maximum
* Implement case binding rule, plus argument line break improvements
* Implement NoForceUnwrap rule
* Format the tests, as well
* Stop masquerading as XCTest
2025-03-05 09:11:17 -06:00
Mishal Shah f970eb6c62 [CI] Add support for GitHub Actions (#250) 2025-03-05 08:40:31 -06:00
Nate Cook d019041daf Prepare for 1.2.1 release (#248) 2025-02-12 11:04:37 -06:00
Alexander Momchilov 401145b7b8 Add ends(with:) (#224) 2025-01-14 12:42:37 -06:00
b1ackturtle cdc909b93d Fix compile errors for Swift 6 language mode (#230) 2025-01-14 12:02:42 -06:00
Nate Cook acb4100b54 Add Xcode project for building framework (#246) 2025-01-13 12:56:00 -06:00
Nate Cook 34eec0dd27 Update project to depend on Swift 5.7 (#240) 2024-08-21 17:19:30 -05:00
Guillaume Lessard 09dc5e4354 Merge pull request #227 from CheATSlark/main
Update Suffix.md
2024-06-25 11:01:42 -07:00
slark 0a01f21eae Merge branch 'main' into main 2024-06-25 15:46:29 +08:00
Jed Fox 34b1705efd Clarify the docs for partitioned(by:) (#228) 2024-05-07 12:53:17 -07:00
jerry ae92f2b33f Update Suffix.md
Fix 'Suffix.md'  example code
2024-04-12 16:09:42 +08:00
Marcos Griselli 33abb69428 Remove @_implementationOnly annotations (#225)
Signed-off-by: Marcos Griselli <marcosg@lyft.com>
2024-03-09 13:35:42 -06:00
Takumi Muraishi 82ee335a48 Fix typo in TestUtilities.swift (#223) 2024-02-17 00:58:00 -06:00
Dimitris Apostolou 9e3900be49 Fix typos (#222) 2024-02-07 00:18:57 -06:00
Dave Abrahams 9dd88e5eaf CombinationsSequence: underestimatedCount == count (#220)
Not doing this makes it needlessly costly to create an Array of the
results.
2024-01-20 10:04:45 -06:00
Kenny c3b3acbca3 Fix Typo in README Xocde -> Xcode 2023-11-26 13:32:29 -06:00
Nate Cook f6919dfc30 Documentation improvements
- Restructure the project README, moving the list of guides into a
README in the `Guides` directory
- Curate the `keyed(by:)` and `grouped(by:)` methods
2023-11-14 21:50:39 -06:00
Nate Cook f2fd047eed Update changelog for 1.2.0 release 2023-11-14 21:50:39 -06:00
Nate Cook 5c54f200e7 Update guide/docs/tests. 2023-11-14 13:00:34 -06:00
Matthew Young 2e71e228c0 Update Suffix.swift
Change `endOfPrefix(while:)` and `startOfSuffix(while:)` from internal to public
2023-11-14 13:00:34 -06:00
Alexander Momchilov 328631d60c Add grouped(by:) and keyed(by:) (#197)
* Add Grouped and Keyed

* Add `Key` to `combine` closure

* Split `keyed(by:)` into two overloads

* Rename uniquingKeysWith → resolvingConflictsWith

* Keep latest instead of throwing on collision
2023-11-07 14:29:10 -06:00
Stephen Canon 0ebed148c2 Merge pull request #210 from amomchilov/tweak-docs
[Docs] Add link and remove redundant doc line
2023-11-01 11:57:28 -04:00
Alexander Momchilov c8ae549e42 [Docs] Add link and remove redundant doc line 2023-10-31 20:25:50 -04:00
Taras Tsugrii dd4e0e70ff [minmax] Do nothing for empty suffix/prefix. (#202)
It's a semantical noop but slightly more efficient for the case when max/min is requested for an empty Collection.
2023-10-31 11:03:19 -05:00
Nate Cook bcd4f369ac Update changelog for 1.1.0 release (#206) 2023-10-05 14:45:17 -05:00
Nate Cook 4f53c9cf40 Finish sub-page documentation updates (#204)
* Finish sub-page documentation updates

Some of these pages could use introductions, but the current state is
ready for publication.

* Add SPI yaml file for building docs
2023-10-05 13:10:03 -05:00
Nate Cook 0d6f943832 Increase the package version to 5.4 (#205)
The latest Swift versions appear to have a problem with the
LinuxMain.swift again, which we haven't needed for quite some time.
Linux test autodiscovery has been enabled since 5.4, so we can
update to that version and drop the file.
2023-10-05 13:03:25 -05:00
Nate Cook fc8fdfd4dc Curate documentation for Algorithms module (#201) 2023-08-24 14:17:38 -05:00
Matt Zanchelli bfcaaa8758 Correct Chunked documentation (#182)
* Clarify that the determining factor for being grouped is equality (`Equatable`), which doesn’t necessarily mean the _same_ value (identity)
* Correct algorithmic complexity documentation on the lazy Chunked functions
* Document `belongInSameGroup` and `projection`
2023-08-02 10:18:17 -05:00
Nate Cook 0f81ef4a70 Chunked type / documentation cleanup (#200)
This change improves the documentation for `evenlyChunked(in:)` and
`chunks(ofCount:)` and renames `EvenChunksCollection` to
`EvenlyChunkedCollection` to follow the pattern of wrapper type
names matching their producing functions.
2023-07-26 13:15:35 -05:00
Tim VermeulenandTim Vermeulen de3efbc567 Evenly divide a collection into chunks (#96)
Adds `evenlyChunked(in:)` as a `Collection` method that divides a
collection into a specific number of chunks as evenly as possible.

Co-authored-by: Tim Vermeulen <tvermeulen@apple.com>
2023-07-26 11:17:25 -05:00
Gwynne Raskind df51f1780b Specify dependency URL in consistent fashion (#194) 2023-07-03 15:15:33 -05:00
98 changed files with 5182 additions and 2171 deletions

No files matched your search

+34
View File
@@ -0,0 +1,34 @@
name: Pull request
permissions:
contents: read
on:
pull_request:
types: [opened, reopened, synchronize]
jobs:
validate_format_config:
name: Validate Format Config
runs-on: ubuntu-latest
steps:
- name: Checkout repo
uses: actions/checkout@v4
- name: Install apt dependencies
run: sudo apt-get -qq update && sudo apt-get -qq -y install curl
- name: Compare against swift-mmio swift-format config
run: |
curl -sL https://raw.githubusercontent.com/apple/swift-mmio/refs/heads/main/.swift-format -o .swift-format-mmio
diff .swift-format .swift-format-mmio
tests:
name: Test
uses: swiftlang/github-workflows/.github/workflows/swift_package_test.yml@main
with:
enable_wasm_sdk_build: true
enable_android_sdk_build: true
enable_android_sdk_checks: true
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
+10
View File
@@ -0,0 +1,10 @@
@@===----------------------------------------------------------------------===@@
@@
@@ This source file is part of the Swift Algorithms open source project
@@
@@ Copyright (c) YEARS 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
@@
@@===----------------------------------------------------------------------===@@
+30
View File
@@ -0,0 +1,30 @@
.gitignore
**/.gitignore
.licenseignore
.gitattributes
.git-blame-ignore-revs
.mailfilter
.mailmap
.spi.yml
.swift-format
.editorconfig
.github/*
*.md
*.mdoc
*.txt
*.yml
*.yaml
*.json
*.png
*.bash
*.cmake
*.cmake.in
Package.swift
**/Package.swift
Package@*.swift
**/Package@*.swift
Package.resolved
**/Package.resolved
.unacceptablelanguageignore
**/Snapshots/*
Xcode/*
+4
View File
@@ -0,0 +1,4 @@
version: 1
builder:
configs:
- documentation_targets: [Algorithms]
+71
View File
@@ -0,0 +1,71 @@
{
"fileScopedDeclarationPrivacy" : {
"accessLevel" : "private"
},
"indentation" : {
"spaces" : 2
},
"indentConditionalCompilationBlocks" : false,
"indentSwitchCaseLabels" : false,
"lineBreakAroundMultilineExpressionChainComponents" : false,
"lineBreakBeforeControlFlowKeywords" : false,
"lineBreakBeforeEachArgument" : false,
"lineBreakBeforeEachGenericRequirement" : false,
"lineLength" : 80,
"maximumBlankLines" : 1,
"multiElementCollectionTrailingCommas" : true,
"noAssignmentInExpressions" : {
"allowedFunctions" : [
"XCTAssertNoThrow"
]
},
"prioritizeKeepingFunctionOutputTogether" : false,
"respectsExistingLineBreaks" : true,
"rules" : {
"AllPublicDeclarationsHaveDocumentation" : false,
"AlwaysUseLiteralForEmptyCollectionInit" : true,
"AlwaysUseLowerCamelCase" : true,
"AmbiguousTrailingClosureOverload" : false,
"BeginDocumentationCommentWithOneLineSummary" : true,
"DoNotUseSemicolons" : true,
"DontRepeatTypeInStaticProperties" : true,
"FileScopedDeclarationPrivacy" : true,
"FullyIndirectEnum" : true,
"GroupNumericLiterals" : true,
"IdentifiersMustBeASCII" : true,
"NeverForceUnwrap" : true,
"NeverUseForceTry" : true,
"NeverUseImplicitlyUnwrappedOptionals" : true,
"NoAccessLevelOnExtensionDeclaration" : true,
"NoAssignmentInExpressions" : true,
"NoBlockComments" : true,
"NoCasesWithOnlyFallthrough" : true,
"NoEmptyTrailingClosureParentheses" : true,
"NoLabelsInCasePatterns" : true,
"NoLeadingUnderscores" : false,
"NoParensAroundConditions" : true,
"NoPlaygroundLiterals" : true,
"NoVoidReturnOnFunctionSignature" : true,
"OmitExplicitReturns" : true,
"OneCasePerLine" : true,
"OneVariableDeclarationPerLine" : true,
"OnlyOneTrailingClosureArgument" : true,
"OrderedImports" : true,
"ReplaceForEachWithForLoop" : true,
"ReturnVoidInsteadOfEmptyTuple" : true,
"TypeNamesShouldBeCapitalized" : true,
"UseEarlyExits" : false,
"UseExplicitNilCheckInConditions" : true,
"UseLetInEveryBoundCaseVariable" : true,
"UseShorthandTypeNames" : true,
"UseSingleLinePropertyGetter" : true,
"UseSynthesizedInitializer" : true,
"UseTripleSlashForDocumentationComments" : true,
"UseWhereClausesInForLoops" : false,
"ValidateDocumentationComments" : true
},
"spacesBeforeEndOfLineComments": 2,
"spacesAroundRangeFormationOperators" : false,
"tabWidth" : 2,
"version" : 1
}
+126 -5
View File
@@ -8,7 +8,95 @@ This project follows semantic versioning.
## [Unreleased]
*No new changes.*
### Additions
- Bidirectional collections have a new `ends(with:)` method that matches
the behavior of the standard library's `starts(with:)` method. ([#224])
<!-- *No new changes.* -->
## [1.2.1] - 2025-02-10
### Changes
- The package now has a minimum Swift version of Swift 5.7. ([#240])
- Adds a project for building with Xcode. ([#246])
### Fixes
- Fix for Swift 6 language mode errors. ([#230])
- Minor improvements to documentation and performance. ([#220], [#222], [#223], [#225], [#227], [#228])
The 1.2.1 release includes contributions from [b1ackturtle], [CheATSlark], [dabrahams], [glessard], [j-f1], [marcosgriselli], [mrs1669], [natecook1000], [rex4539], and [schlagelk]. Thank you!
## [1.2.0] - 2023-11-14
### Additions
- Sequences have new `grouped(by:)` and `keyed(by:)` methods, which simplify
building dictionaries based on sequence elements: ([#197])
```swift
let evensOdds = (1...10).grouped(by: { $0.isMultiple(of: 2) ? "even" : "odd" })
// ["even": [2, 4, 6, 8, 10], "odd": [1, 3, 5, 7, 9]]
let animals = ["Aardvark", "Alpaca", "Armadillo", "Barracuda", "Buffalo", ...]
let alphaAnimals = animals.keyed(by: \.first!, resolvingConflictsWith: { _, first, _ in first })
// ["A": "Aardvark", "B": "Barracuda", ...]
```
- The `endOfPrefix(while:)` and `startOfSuffix(while)` methods are now public.
These methods were previously implementation details of the `trimming` group
of methods. ([#211])
### Fixes
- Documentation and performance improvements. ([#202], [#210])
The 1.2.0 release includes contributions from [amomchilov], [mattyoung], [natecook1000], [stephentyrone], and [ttsugriy].
Thank you!
---
## [1.1.0] - 2023-10-05
### 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!
---
@@ -153,7 +241,7 @@ The 0.2.0 release includes contributions from [CTMacUser], [LemonSpike],
- The base collections of the sequence and collection wrapper types are no
longer public ([#85], [#125]), and the wrapper types no longer conform to the
`Equatable` or `Hashable` protocols ([#124]). If you need those conformances,
convert the wrapper type to an `Array` or other collection currrency type
convert the wrapper type to an `Array` or other collection currency type
before storing. Please file an issue if these changes pose a problem for your
use case.
@@ -247,7 +335,7 @@ The 0.0.3 release includes contributions from [benrimmington], [danielctull],
### Fixes
- `Algorithms` now builds under SwiftPM on Windows.
- A wide variety of errors, misspellings, and ommissions in the documentation
- A wide variety of errors, misspellings, and omissions in the documentation
and guides have been fixed.
- Index/distance calculations for the `Product2` and `Chain` types have been
corrected.
@@ -269,7 +357,10 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
<!-- Link references for releases -->
[Unreleased]: https://github.com/apple/swift-algorithms/compare/1.0.0...HEAD
[Unreleased]: https://github.com/apple/swift-algorithms/compare/1.2.1...HEAD
[1.2.0]: https://github.com/apple/swift-algorithms/compare/1.2.0...1.2.1
[1.2.0]: https://github.com/apple/swift-algorithms/compare/1.1.0...1.2.0
[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
[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
@@ -299,6 +390,7 @@ 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
@@ -307,36 +399,64 @@ 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
[#197]: https://github.com/apple/swift-algorithms/pull/197
[#202]: https://github.com/apple/swift-algorithms/pull/202
[#210]: https://github.com/apple/swift-algorithms/pull/210
[#211]: https://github.com/apple/swift-algorithms/pull/211
[#224]: https://github.com/apple/swift-algorithms/pull/224
[#220]: https://github.com/apple/swift-algorithms/pull/220
[#222]: https://github.com/apple/swift-algorithms/pull/222
[#223]: https://github.com/apple/swift-algorithms/pull/223
[#225]: https://github.com/apple/swift-algorithms/pull/225
[#227]: https://github.com/apple/swift-algorithms/pull/227
[#228]: https://github.com/apple/swift-algorithms/pull/228
[#230]: https://github.com/apple/swift-algorithms/pull/230
[#240]: https://github.com/apple/swift-algorithms/pull/240
[#246]: https://github.com/apple/swift-algorithms/pull/246
<!-- Link references for contributors -->
[amomchilov]: https://github.com/apple/swift-algorithms/commits?author=amomchilov
[AustinConlon]: https://github.com/apple/swift-algorithms/commits?author=AustinConlon
[b1ackturtle]: https://github.com/apple/swift-algorithms/commits?author=b1ackturtle
[benrimmington]: https://github.com/apple/swift-algorithms/commits?author=benrimmington
[bjhomer]: https://github.com/apple/swift-algorithms/commits?author=bjhomer
[CheATSlark]: https://github.com/apple/swift-algorithms/commits?author=CheATSlark
[CTMacUser]: https://github.com/apple/swift-algorithms/commits?author=CTMacUser
[dabrahams]: https://github.com/apple/swift-algorithms/commits?author=dabrahams
[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
[glessard]: https://github.com/apple/swift-algorithms/commits?author=glessard
[gwynne]: https://github.com/apple/swift-algorithms/commits?author=gwynne
[hashemi]: https://github.com/apple/swift-algorithms/commits?author=hashemi
[IanKeen]: https://github.com/apple/swift-algorithms/commits?author=IanKeen
[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
[j-f1]: https://github.com/apple/swift-algorithms/commits?author=j-f1
[karwa]: https://github.com/apple/swift-algorithms/commits?author=karwa
[kylemacomber]: https://github.com/apple/swift-algorithms/commits?author=kylemacomber
[LemonSpike]: https://github.com/apple/swift-algorithms/commits?author=LemonSpike
[LucianoPAlmeida]: https://github.com/apple/swift-algorithms/commits?author=LucianoPAlmeida
[marcosgriselli]: https://github.com/apple/swift-algorithms/commits?author=marcosgriselli
[markuswntr]: https://github.com/apple/swift-algorithms/commits?author=markuswntr
[mattyoung]: https://github.com/apple/swift-algorithms/commits?author=mattyoung
[mdznr]: https://github.com/apple/swift-algorithms/commits?author=mdznr
[michiboo]: https://github.com/apple/swift-algorithms/commits?author=michiboo
[mpangburn]: https://github.com/apple/swift-algorithms/commits?author=mpangburn
[mrs1669]: https://github.com/apple/swift-algorithms/commits?author=mrs1669
[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
[rakaramos]: https://github.com/apple/swift-algorithms/commits?author=rakaramos
[rex4539]: https://github.com/apple/swift-algorithms/commits?author=rex4539
[rockbruno]: https://github.com/apple/swift-algorithms/commits?author=rockbruno
[Roshankumar350]: https://github.com/apple/swift-algorithms/commits?author=Roshankumar350
[schlagelk]: https://github.com/apple/swift-algorithms/commits?author=schlagelk
@@ -344,3 +464,4 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
[stephentyrone]: https://github.com/apple/swift-algorithms/commits?author=stephentyrone
[timvermeulen]: https://github.com/apple/swift-algorithms/commits?author=timvermeulen
[toddthomas]: https://github.com/apple/swift-algorithms/commits?author=toddthomas
[ttsugriy]: https://github.com/apple/swift-algorithms/commits?author=ttsugriy
-3
View File
@@ -5,9 +5,6 @@
Lazily iterates over tuples of adjacent elements.
This operation is available for any sequence by calling the `adjacentPairs()`
method.
```swift
let numbers = (1...5)
let pairs = numbers.adjacentPairs()
+56 -39
View File
@@ -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 subsequences where consecutive elements pass a binary
predicate, or where all elements in each chunk project to the same value.
Break a collection into nonoverlapping subsequences:
Also includes a `chunks(ofCount:)` that breaks a collection into subsequences
of a given `count`.
* `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.
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:
`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]
@@ -31,11 +31,10 @@ let chunks = names.chunked(on: \.first!)
// [("D", ["David"]), ("K", ["Kyle", "Karoy"]), ("N", ["Nate"])]
```
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.
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.
```swift
let names = ["David", "Kyle", "Karoy", "Nate"]
@@ -46,11 +45,26 @@ let remaining = names.chunks(ofCount: 3)
// equivalent to [["David", "Kyle", "Karoy"], ["Nate"]]
```
The `chunks(ofCount:)` is the subject of an [existing SE proposal][proposal].
The `chunks(ofCount:)` method was previously [proposed](proposal) for inclusion
in the standard library.
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,
unlike the `split` family of methods, where separators are dropped.
Joining the result of a chunking method call recreates the original collection.
Joining the result of a chunking method call results in a collection equivalent
to the original.
```swift
c.elementsEqual(c.chunked(...).joined())
@@ -61,42 +75,45 @@ c.elementsEqual(c.chunked(...).joined())
## Detailed Design
The three methods are added as extension to `Collection`. `chunked(by:)` and
`chunked(on:)` are eager by default, both with a matching version that return a
lazy wrapper added to `LazySequenceProtocol`.
The four methods are added to `Collection`, with matching versions of
`chunked(by:)` and `chunked(on:)` that return a lazy wrapper added to
`LazyCollectionProtocol`.
```swift
extension Collection {
public func chunked(
by belongInSameGroup: (Element, Element) -> Bool
) -> [SubSequence]
public func chunked(
by belongInSameGroup: (Element, Element) -> Bool
) -> [SubSequence]
public func chunked<Subject: Equatable>(
public func chunked<Subject: Equatable>(
on projection: (Element) -> Subject
) -> [(Subject, SubSequence)]
public func chunks(ofCount count: Int) -> ChunksOfCountCollection<Self>
) -> [SubSequence]
public func chunks(ofCount count: Int) -> ChunkedByCount<Self>
public func evenlyChunked(in count: Int) -> EvenlyChunkedCollection<Self>
}
extension LazySequenceProtocol where Self: Collection, Elements: Collection {
public func chunked(
by belongInSameGroup: @escaping (Element, Element) -> Bool
) -> ChunkedByCollection<Elements, Element>
extension LazyCollectionProtocol {
public func chunked(
by belongInSameGroup: @escaping (Element, Element) -> Bool
) -> ChunkedByCollection<Elements>
public func chunked<Subject: Equatable>(
on projection: @escaping (Element) -> Subject
) -> ChunkedOnCollection<Elements, Subject>
public func chunked<Subject: Equatable>(
on projection: @escaping (Element) -> Subject
) -> ChunkedOnCollection<Elements, Subject>
}
```
The `ChunkedByCollection`, `ChunkedOnCollection`, and `ChunksOfCountCollection`
types are bidirectional when the wrapped collection is bidirectional.
`ChunksOfCountCollection` also conforms to `LazySequenceProtocol` when the base
collection conforms.
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.
### Complexity
The eager methods are O(_n_), the lazy methods are O(_1_).
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.
### Naming
@@ -120,5 +137,5 @@ into potentially overlapping subsequences.
**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, but doesn’t
include any with the functionality described here.
**Rust:** Rust defines a variety of size-based `chunks` methods, of which the
standard version corresponds to the `chunks(ofCount:)` method defined here.
+1 -1
View File
@@ -86,7 +86,7 @@ call to `CombinationsSequence.Iterator.next()` is an O(_n_) operation.
### Naming
The parameter label in `combination(ofCount:)` is the best match for the
Swift API guidelines. A few other options were considered:
[Swift's API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/). A few other options were considered:
- When the standard library uses `of` as a label, the parameter is generally
the object of the operation, as in `type(of:)` and `firstIndex(of:)`, and
+37
View File
@@ -0,0 +1,37 @@
# EndsWith
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/EndsWith.swift) |
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/EndsWithTests.swift)]
This function checks whether the final elements of the one collection are the same as the elements in another collection.
```
## Detailed Design
The `ends(with:)` and `ends(with:by:)` functions are added as methods on an extension of
`BidirectionalCollection`.
```swift
extension BidirectionalCollection {
public func ends<PossibleSuffix: BidirectionalCollection>(
with possibleSuffix: PossibleSuffix
) -> Bool where PossibleSuffix.Element == Element
public func ends<PossibleSuffix: BidirectionalCollection>(
with possibleSuffix: PossibleSuffix,
by areEquivalent: (Element, PossibleSuffix.Element) throws -> Bool
) rethrows -> Bool
}
```
This method requires `BidirectionalCollection` for being able to traverse back from the end of the collection. It also requires the `possibleSuffix` to be `BidirectionalCollection`, because it too needs to be traverse backwards, to compare its elements against `self` from back to front.
### Complexity
O(*m*), where *m* is the lesser of the length of the collection and the length of `possibleSuffix`.
### Naming
The function's name resembles that of an existing Swift function
`starts(with:)`, which performs same operation however in the forward direction
of the collection.
+68
View File
@@ -0,0 +1,68 @@
# Grouped
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Grouped.swift) |
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/GroupedTests.swift)]
Groups up elements of a sequence into a new Dictionary, whose values are Arrays of grouped elements, each keyed by the result of the given closure.
```swift
let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Avocado", "Coconut"]
let fruitsByLetter = fruits.grouped(by: { $0.first! })
// Results in:
// [
// "B": ["Banana"],
// "A": ["Apricot", "Apple", "Avocado"],
// "C": ["Cherry", "Coconut"],
// ]
```
If you wish to achieve a similar effect but for single values (instead of Arrays of grouped values), see [`keyed(by:)`](Keyed.md).
## Detailed Design
The `grouped(by:)` method is declared as a `Sequence` extension returning
`[GroupKey: [Element]]`.
```swift
extension Sequence {
public func grouped<GroupKey>(
by keyForValue: (Element) throws -> GroupKey
) rethrows -> [GroupKey: [Element]]
}
```
### Complexity
Calling `grouped(by:)` is an O(_n_) operation.
### Comparison with other languages
| Language | Grouping API |
|---------------|--------------|
| Java | [`groupingBy`](https://docs.oracle.com/en/java/javase/20/docs/api/java.base/java/util/stream/Collectors.html#groupingBy(java.util.function.Function)) |
| Kotlin | [`groupBy`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/group-by.html) |
| C# | [`GroupBy`](https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.groupby?view=net-7.0#system-linq-enumerable-groupby) |
| Rust | [`group_by`](https://doc.rust-lang.org/std/primitive.slice.html#method.group_by) |
| Ruby | [`group_by`](https://ruby-doc.org/3.2.2/Enumerable.html#method-i-group_by) |
| Python | [`groupby`](https://docs.python.org/3/library/itertools.html#itertools.groupby) |
| PHP (Laravel) | [`groupBy`](https://laravel.com/docs/10.x/collections#method-groupby) |
#### Naming
All the surveyed languages name this operation with a variant of "grouped" or "grouping". The past tense `grouped(by:)` best fits [Swift's API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/).
#### Customization points
Java and C# are interesting in that they provide multiple overloads with several points of customization:
1. Changing the type of the groups.
1. E.g. the groups can be Sets instead of Arrays.
1. Akin to calling `.transformValues { group in Set(group) }` on the resultant dictionary, but avoiding the intermediate allocation of Arrays of each group.
2. Picking which elements end up in the groupings.
1. The default is the elements of the input sequence, but can be changed.
2. Akin to calling `.transformValues { group in group.map(someTransform) }` on the resultant dictionary, but avoiding the intermediate allocation of Arrays of each group.
3. Changing the type of the outermost collection.
1. E.g using an `OrderedDictionary`, `SortedDictionary` or `TreeDictionary` instead of the default (hashed, unordered) `Dictionary`.
2. There's no great way to achieve this with the `grouped(by:)`. One could wrap the resultant dictionary in an initializer to one of the other dictionary types, but that isn't sufficient: Once the `Dictionary` loses the ordering, there's no way to get it back when constructing one of the ordered dictionary variants.
It is not clear which of these points of customization are worth supporting, or what the best way to express them might be.
+78
View File
@@ -0,0 +1,78 @@
# Keyed
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Keyed.swift) |
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/KeyedTests.swift)]
Stores the elements of a sequence as the values of a Dictionary, keyed by the result of the given closure.
```swift
let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Blackberry", "Avocado", "Coconut"]
let fruitByLetter = fruits.keyed(by: { $0.first! })
// Results in:
// [
// "A": "Avocado",
// "B": "Blackberry",
// "C": "Coconut",
// ]
```
On a key-collision, the latest element is kept by default. Alternatively, you can provide a closure which specifies which value to keep:
```swift
let fruits = ["Apricot", "Banana", "Apple", "Cherry", "Blackberry", "Avocado", "Coconut"]
let fruitsByLetter = fruits.keyed(
by: { $0.first! },
resolvingConflictsWith: { key, old, new in old } // Always pick the first fruit
)
// Results in:
// [
// "A": "Apricot",
// "B": "Banana",
// "C": "Cherry",
// ]
```
## Detailed Design
The `keyed(by:)` and `keyed(by:resolvingConflictsWith:)` methods are declared in an `Sequence` extension, both returning `[Key: Element]`.
```swift
extension Sequence {
public func keyed<Key>(
by keyForValue: (Element) throws -> Key
) rethrows -> [Key: Element]
public func keyed<Key>(
by keyForValue: (Element) throws -> Key,
resolvingConflictsWith resolve: ((Key, Element, Element) throws -> Element)? = nil
) rethrows -> [Key: Element]
}
```
### Complexity
Calling `keyed(by:)` is an O(_n_) operation.
### Comparison with other languages
| Language | "Keying" API |
|---------------|-------------|
| Java | [`toMap`](https://docs.oracle.com/en/java/javase/20/docs/api/java.base/java/util/stream/Collectors.html#toMap(java.util.function.Function,java.util.function.Function)) |
| Kotlin | [`associatedBy`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/associate-by.html) |
| C# | [`ToDictionary`](https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.todictionary?view=net-7.0#system-linq-enumerable-todictionary) |
| Ruby (ActiveSupport) | [`index_by`](https://rubydoc.info/gems/activesupport/7.0.5/Enumerable#index_by-instance_method) |
| PHP (Laravel) | [`keyBy`](https://laravel.com/docs/10.x/collections#method-keyby) |
#### Rejected alternative names
1. Java's `toMap` is referring to `Map`/`HashMap`, their naming for Dictionaries and other associative collections. It's easy to confuse with the transformation function, `Sequence.map(_:)`.
2. C#'s `toXXX()` naming doesn't suite Swift well, which tends to prefer `Foo.init` over `toFoo()` methods.
3. Ruby's `index_by` naming doesn't fit Swift well, where "index" is a specific term (e.g. the `associatedtype Index` on `Collection`). There is also a [`index(by:)`](Index.md) method in swift-algorithms, is specifically to do with matching elements up with their indices, and not any arbitrary derived value.
#### Alternative names
Kotlin's `associatedBy` naming is a good alternative, and matches the past tense of [Swift's API Design Guidelines](https://www.swift.org/documentation/api-design-guidelines/), though perhaps we'd spell it `associated(by:)`.
#### Customization points
Java and C# are interesting in that they provide overloads that let you customize the type of the outermost collection. E.g. using an `OrderedDictionary` instead of the default (hashed, unordered) `Dictionary`.
+53
View File
@@ -0,0 +1,53 @@
# Guides
These guides describe the design and intention behind the APIs included in the `Algorithms` library. For further reading, see the [announcement on swift.org](https://swift.org/blog/swift-algorithms/) and the [official documentation](https://swiftpackageindex.com/apple/swift-algorithms/documentation/algorithms).
## Contents
#### Combinations / permutations
- [`combinations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
- [`permutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a particular size of the elements in a collection, or of the full collection.
- [`uniquePermutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a collection's elements, skipping any duplicate permutations.
#### Mutating algorithms
- [`rotate(toStartAt:)`, `rotate(subrange:toStartAt:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Rotate.md): In-place rotation of elements.
- [`stablePartition(by:)`, `stablePartition(subrange:by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): A partition that preserves the relative order of the resulting prefix and suffix.
#### Combining collections
- [`chain(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chain.md): Concatenates two collections with the same element type.
- [`cycled()`, `cycled(times:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Cycle.md): Repeats the elements of a collection forever or a set number of times.
- [`joined(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Joined.md): Concatenate sequences of sequences, using an element or sequence as a separator, or using a closure to generate each separator.
- [`product(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Product.md): Iterates over all the pairs of two collections; equivalent to nested `for`-`in` loops.
#### Subsetting operations
- [`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.
- [`suffix(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Suffix.md): Returns the suffix of a collection where all element pass a given predicate.
- [`trimmingPrefix(while:)`, `trimmingSuffix(while)`, `trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start, end, or both. The mutating `trim...` methods trim a collection in place.
- [`uniqued()`, `uniqued(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md): The unique elements of a collection, preserving their order.
- [`minAndMax()`, `minAndMax(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest and largest elements of a sequence.
#### Partial sorting
- [`min(count:)`, `max(count:)`, `min(count:sortedBy:)`, `max(count:sortedBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest or largest elements of a collection, sorted by a predicate.
#### Other useful operations
- [`adjacentPairs()`](https://github.com/apple/swift-algorithms/blob/main/Guides/AdjacentPairs.md): Lazily iterates over tuples of adjacent elements.
- [`chunked(by:)`, `chunked(on:)`, `chunks(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chunked.md): Eager and lazy operations that break a collection into chunks based on either a binary predicate or when the result of a projection changes or chunks of a given count.
- [`firstNonNil(_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/FirstNonNil.md): Returns the first non-`nil` result from transforming a sequence's elements.
- [`grouped(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Grouped.md): Group up elements using the given closure, returning a Dictionary of those groups, keyed by the results of the closure.
- [`indexed()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Indexed.md): Iterate over tuples of a collection's indices and elements.
- [`interspersed(with:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Intersperse.md): Place a value between every two elements of a sequence.
- [`keyed(by:)`, `keyed(by:resolvingConflictsBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Keyed.md): Returns a Dictionary that associates elements of a sequence with the keys returned by the given closure.
- [`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.
- [`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.
+1 -1
View File
@@ -9,7 +9,7 @@ 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]
(0...10).suffix(while: { $0 > 5 }) // == [6,7,8,9,10]
```
## Detailed Design
+50 -29
View File
@@ -3,8 +3,8 @@
[[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.
A group of methods that return the `SubSequence` formed by discarding elements
at the start and/or 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.
@@ -17,24 +17,44 @@ let results = [2, 10, 11, 15, 20, 21, 100].trimming(while: { $0.isMultiple(of: 2
print(results) // [11, 15, 20, 21]
```
The `Algorithms` library also includes methods that trim from each end,
as well as mutating versions of all three methods.
## Detailed Design
A new method is added to `BidirectionalCollection`:
New methods are added to `Collection` and `BidirectionalCollection`:
```swift
extension Collection {
func trimmingPrefix(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
}
extension BidirectionalCollection {
public func trimming(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
func trimmingSuffix(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
func trimming(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
}
extension Collection where Self: RangeReplaceableCollection {
mutating func trimPrefix(while predicate: (Element) throws -> Bool) rethrows
}
extension BidirectionalCollection where Self: RangeReplaceableCollection {
mutating func trimSuffix(while predicate: (Element) throws -> Bool) rethrows
mutating func trim(while predicate: (Element) throws -> Bool) rethrows
}
```
This method requires `BidirectionalCollection` for an efficient implementation
which visits as few elements as possible.
There are also overloads of the mutating methods when `Self == Self.SubSequence`,
for non-range-replaceable self-slicing types.
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:
Though the `trimming` and `trimmingSuffix` methods are declared on
`BidirectionalCollection`, 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 {
@@ -50,28 +70,29 @@ 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
#### Supporting Methods
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.
The `endOfPrefix(while:)` and `startOfSuffix(while:)` methods are used
in the implementation of the trimming methods described above. As these
supporting methods are independently useful, they are included in the library
as well.
```swift
let myString = " hello, world "
print(myString.trimmingPrefix(while: \.isWhitespace)) // "hello, world "
extension Collection {
/// Returns the exclusive upper bound of the prefix of elements that satisfy
/// the predicate.
func endOfPrefix(
while predicate: (Element) throws -> Bool
) rethrows -> Index
}
print(myString.trimmingSuffix(while: \.isWhitespace)) // " hello, world"
```
Also mutating variants for all the methods already existing and the new ones are
added.
```swift
var myString = " hello, world "
myString.trim(while: \.isWhitespace)
print(myString) // "hello, world"
extension BidirectionalCollection {
/// Returns the inclusive lower bound of the suffix of elements that satisfy
/// the predicate.
func startOfSuffix(
while predicate: (Element) throws -> Bool
) rethrows -> Index
}
```
### Complexity
+20 -20
View File
@@ -1,4 +1,4 @@
// swift-tools-version:5.1
// swift-tools-version:5.7
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
@@ -13,23 +13,23 @@
import PackageDescription
let package = Package(
name: "swift-algorithms",
products: [
.library(
name: "Algorithms",
targets: ["Algorithms"]),
],
dependencies: [
.package(url: "https://github.com/apple/swift-numerics", from: "1.0.0"),
],
targets: [
.target(
name: "Algorithms",
dependencies: [
.product(name: "RealModule", package: "swift-numerics"),
]),
.testTarget(
name: "SwiftAlgorithmsTests",
dependencies: ["Algorithms"]),
]
name: "swift-algorithms",
products: [
.library(
name: "Algorithms",
targets: ["Algorithms"])
],
dependencies: [
.package(url: "https://github.com/apple/swift-numerics.git", from: "1.0.0")
],
targets: [
.target(
name: "Algorithms",
dependencies: [
.product(name: "RealModule", package: "swift-numerics")
]),
.testTarget(
name: "SwiftAlgorithmsTests",
dependencies: ["Algorithms"]),
]
)
+26 -42
View File
@@ -2,55 +2,35 @@
**Swift Algorithms** is an open-source package of sequence and collection algorithms, along with their related types.
Read more about the package, and the intent behind it, in the [announcement on swift.org](https://swift.org/blog/swift-algorithms/).
## Overview
## Contents
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.
#### Combinations / permutations
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:
- [`combinations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
- [`permutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a particular size of the elements in a collection, or of the full collection.
- [`uniquePermutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a collection's elements, skipping any duplicate permutations.
```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]]
```
#### Mutating algorithms
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:
- [`rotate(toStartAt:)`, `rotate(subrange:toStartAt:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Rotate.md): In-place rotation of elements.
- [`stablePartition(by:)`, `stablePartition(subrange:by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): A partition that preserves the relative order of the resulting prefix and suffix.
```swift
let names = ["Cassie", "Chloe", "Jasmine", "Jordan", "Taylor"]
let chunks = names.chunked(on: \.first)
// [["Cassie", "Chloe"], ["Jasmine", "Jordan"], ["Taylor"]]
```
#### Combining collections
Explore more chunking methods and the remainder of the `Algorithms` package in the links below.
- [`chain(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chain.md): Concatenates two collections with the same element type.
- [`cycled()`, `cycled(times:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Cycle.md): Repeats the elements of a collection forever or a set number of times.
- [`joined(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Joined.md): Concatenate sequences of sequences, using an element or sequence as a separator, or using a closure to generate each separator.
- [`product(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Product.md): Iterates over all the pairs of two collections; equivalent to nested `for`-`in` loops.
## Documentation
#### Subsetting operations
For API documentation, see the library's official documentation in Xcode or on the Web.
- [`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.
- [`suffix(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Suffix.md): Returns the suffix of a collection where all element pass a given predicate.
- [`trimmingPrefix(while:)`, `trimmingSuffix(while)`, `trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start, end, or both. The mutating `trim...` methods trim a collection in place.
- [`uniqued()`, `uniqued(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md): The unique elements of a collection, preserving their order.
- [`minAndMax()`, `minAndMax(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest and largest elements of a sequence.
#### Partial sorting
- [`min(count:)`, `max(count:)`, `min(count:sortedBy:)`, `max(count:sortedBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest or largest elements of a collection, sorted by a predicate.
#### Other useful operations
- [`adjacentPairs()`](https://github.com/apple/swift-algorithms/blob/main/Guides/AdjacentPairs.md): Lazily iterates over tuples of adjacent elements.
- [`chunked(by:)`, `chunked(on:)`, `chunks(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chunked.md): Eager and lazy operations that break a collection into chunks based on either a binary predicate or when the result of a projection changes or chunks of a given count.
- [`firstNonNil(_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/FirstNonNil.md): Returns the first non-`nil` result from transforming a sequence's elements.
- [`indexed()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Indexed.md): Iterate over tuples of a collection's indices and elements.
- [`interspersed(with:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Intersperse.md): Place a value between every two elements of a sequence.
- [`partitioningIndex(where:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Partition.md): Returns the starting index of the partition of a collection that matches a predicate.
- [`reductions(_:)`, `reductions(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Reductions.md): Returns all the intermediate states of reducing the elements of a sequence or collection.
- [`split(maxSplits:omittingEmptySubsequences:whereSeparator)`, `split(separator:maxSplits:omittingEmptySubsequences)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Split.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.
- [API documentation][docs]
- [Swift.org announcement][announcement]
- [API Proposals/Guides][guides]
## Adding Swift Algorithms as a Dependency
@@ -58,7 +38,7 @@ 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: "1.2.0"),
```
Include `"Algorithms"` as a dependency for your executable target:
@@ -75,8 +55,12 @@ Finally, add `import Algorithms` to your source code.
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.
The public API 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.
[docs]: https://swiftpackageindex.com/apple/swift-algorithms/documentation/algorithms
[announcement]: https://swift.org/blog/swift-algorithms/
[guides]: https://github.com/apple/swift-algorithms/tree/main/Guides
+20
View File
@@ -0,0 +1,20 @@
#!/bin/bash
##===----------------------------------------------------------------------===##
##
## This source file is part of the Swift Algorithms open source project
##
## Copyright (c) 2025 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
##
##===----------------------------------------------------------------------===##
# Move to the project root
cd "$(dirname "$0")" || exit
cd ..
echo "Formatting Swift sources in $(pwd)"
# Run the format / lint commands
git ls-files -z '*.swift' | xargs -0 swift format format --parallel --in-place
git ls-files -z '*.swift' | xargs -0 swift format lint --strict --parallel
+52 -27
View File
@@ -10,7 +10,8 @@
//===----------------------------------------------------------------------===//
extension Sequence {
/// Creates a sequence of adjacent pairs of elements from this sequence.
/// Returns a sequence of overlapping adjacent pairs of the elements of 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
@@ -24,6 +25,11 @@ 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)
@@ -31,7 +37,7 @@ extension Sequence {
}
extension Collection {
/// A collection of adjacent pairs of elements built from an underlying
/// Returns a collection of overlapping adjacent pairs of the elements of this
/// collection.
///
/// In an `AdjacentPairsCollection`, the elements of the *i*th pair are the
@@ -46,6 +52,11 @@ 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)
@@ -115,7 +126,7 @@ extension AdjacentPairsSequence: Sequence {
}
extension AdjacentPairsSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
/// A collection of adjacent pairs of elements built from an underlying
/// collection.
@@ -132,7 +143,8 @@ public struct AdjacentPairsCollection<Base: Collection> {
@inlinable
internal init(base: Base) {
self.base = base
self.secondBaseIndex = base.isEmpty
self.secondBaseIndex =
base.isEmpty
? base.endIndex
: base.index(after: base.startIndex)
}
@@ -143,7 +155,7 @@ extension AdjacentPairsCollection {
public struct Index: Comparable {
@usableFromInline
internal var first: Base.Index
@usableFromInline
internal var second: Base.Index
@@ -157,7 +169,7 @@ extension AdjacentPairsCollection {
public static func == (lhs: Index, rhs: Index) -> Bool {
lhs.first == rhs.first
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
lhs.first < rhs.first
@@ -172,7 +184,7 @@ extension AdjacentPairsCollection: Collection {
first: secondBaseIndex == base.endIndex ? base.endIndex : base.startIndex,
second: secondBaseIndex)
}
@inlinable
public var endIndex: Index {
Index(first: base.endIndex, second: base.endIndex)
@@ -196,20 +208,23 @@ extension AdjacentPairsCollection: Collection {
public func index(_ i: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return i }
guard let result = distance > 0
? offsetForward(i, by: distance, limitedBy: endIndex)
: offsetBackward(i, by: -distance, limitedBy: startIndex)
guard
let result = distance > 0
? offsetForward(i, by: distance, limitedBy: endIndex)
: offsetBackward(i, by: -distance, limitedBy: startIndex)
else { fatalError("Index out of bounds") }
return result
}
@inlinable
public func index(
_ i: Index, offsetBy distance: Int, limitedBy limit: Index
_ i: Index,
offsetBy distance: Int,
limitedBy limit: Index
) -> Index? {
guard distance != 0 else { return i }
guard limit != i else { return nil }
if distance > 0 {
let limit = limit > i ? limit : endIndex
return offsetForward(i, by: distance, limitedBy: limit)
@@ -218,38 +233,48 @@ extension AdjacentPairsCollection: Collection {
return offsetBackward(i, by: -distance, limitedBy: limit)
}
}
@inlinable
internal func offsetForward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit > i)
guard let newFirst = base.index(i.second, offsetBy: distance - 1, limitedBy: limit.first),
newFirst != base.endIndex
let newFirst = base.index(
i.second,
offsetBy: distance - 1,
limitedBy: limit.first)
guard let newFirst, newFirst != base.endIndex
else { return nil }
let newSecond = base.index(after: newFirst)
precondition(newSecond <= base.endIndex, "Can't advance beyond endIndex")
return newSecond == base.endIndex
? endIndex
: Index(first: newFirst, second: newSecond)
}
@inlinable
internal func offsetBackward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit < i)
let offset = i == endIndex ? 0 : 1
guard let newSecond = base.index(
let newSecond = base.index(
i.first,
offsetBy: -(distance - offset),
limitedBy: limit.second)
guard let newSecond
else { return nil }
let newFirst = base.index(newSecond, offsetBy: -1)
precondition(newFirst >= base.startIndex, "Can't move before startIndex")
return Index(first: newFirst, second: newSecond)
@@ -271,12 +296,12 @@ extension AdjacentPairsCollection: Collection {
}
extension AdjacentPairsCollection: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i != startIndex, "Can't offset before startIndex")
let second = i == endIndex
let second =
i == endIndex
? base.index(before: base.endIndex)
: i.first
let first = base.index(before: second)
@@ -285,10 +310,10 @@ extension AdjacentPairsCollection: BidirectionalCollection
}
extension AdjacentPairsCollection: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension AdjacentPairsCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension AdjacentPairsCollection.Index: Hashable where Base.Index: Hashable {
@inlinable
+66 -57
View File
@@ -11,12 +11,11 @@
/// A concatenation of two sequences with the same element type.
public struct Chain2Sequence<Base1: Sequence, Base2: Sequence>
where Base1.Element == Base2.Element
{
where Base1.Element == Base2.Element {
/// The first sequence in this chain.
@usableFromInline
internal let base1: Base1
/// The second sequence in this chain.
@usableFromInline
internal let base2: Base2
@@ -33,29 +32,30 @@ extension Chain2Sequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal var iterator1: Base1.Iterator
@usableFromInline
internal var iterator2: Base2.Iterator
@inlinable
internal init(_ concatenation: Chain2Sequence) {
iterator1 = concatenation.base1.makeIterator()
iterator2 = concatenation.base2.makeIterator()
}
@inlinable
public mutating func next() -> Base1.Element? {
return iterator1.next() ?? iterator2.next()
iterator1.next() ?? iterator2.next()
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(self)
}
}
extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection {
extension Chain2Sequence: Collection
where Base1: Collection, Base2: Collection {
/// A position in a `Chain2Sequence` instance.
public struct Index: Comparable {
// The internal index representation, which can either be an index of the
@@ -91,14 +91,14 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
return true
case (.second, .first):
return false
case let (.first(l), .first(r)):
case (.first(let l), .first(let r)):
return l < r
case let (.second(l), .second(r)):
case (.second(let l), .second(let r)):
return l < r
}
}
}
/// Converts an index of `Base1` to the corresponding `Index` by mapping
/// `base1.endIndex` to `base2.startIndex`.
@inlinable
@@ -121,9 +121,9 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
@inlinable
public subscript(i: Index) -> Base1.Element {
switch i.position {
case let .first(i):
case .first(let i):
return base1[i]
case let .second(i):
case .second(let i):
return base2[i]
}
}
@@ -131,23 +131,23 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
@inlinable
public func index(after i: Index) -> Index {
switch i.position {
case let .first(i):
case .first(let i):
assert(i != base1.endIndex)
return normalizeIndex(base1.index(after: i))
case let .second(i):
case .second(let i):
return Index(second: base2.index(after: i))
}
}
@inlinable
public func index(_ i: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return i }
return distance > 0
? offsetForward(i, by: distance)
: offsetBackward(i, by: -distance)
}
@inlinable
public func index(
_ i: Index,
@@ -168,45 +168,50 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit >= i)
switch (i.position, limit.position) {
case let (.first(i), .first(limit)):
case (.first(let i), .first(let limit)):
return base1.index(i, offsetBy: distance, limitedBy: limit)
.map(Index.init(first:))
case let (.first(i), .second(limit)):
if let j = base1.index(i, offsetBy: distance, limitedBy: base1.endIndex) {
// the offset stays within the bounds of `base1`
return normalizeIndex(j)
} else {
case (.first(let i), .second(let limit)):
guard
let j = base1.index(i, offsetBy: distance, limitedBy: base1.endIndex)
else {
// the offset overflows the bounds of `base1` by `n - d`
let d = base1.distance(from: i, to: base1.endIndex)
return base2.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
return
base2
.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
.map(Index.init(second:))
}
// the offset stays within the bounds of `base1`
return normalizeIndex(j)
case (.second, .first):
// impossible because `limit >= i`
fatalError()
case let (.second(i), .second(limit)):
case (.second(let i), .second(let limit)):
return base2.index(i, offsetBy: distance, limitedBy: limit)
.map(Index.init(second:))
}
@@ -214,49 +219,54 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
@inlinable
internal func offsetBackward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit <= i)
switch (i.position, limit.position) {
case let (.first(i), .first(limit)):
case (.first(let i), .first(let limit)):
return base1.index(i, offsetBy: -distance, limitedBy: limit)
.map(Index.init(first:))
case (.first, .second):
// impossible because `limit <= i`
fatalError()
case let (.second(i), .first(limit)):
if let j = base2.index(i, offsetBy: -distance, limitedBy: base2.startIndex) {
// the offset stays within the bounds of `base2`
return Index(second: j)
} else {
case (.second(let i), .first(let limit)):
guard
let j = base2.index(i, offsetBy: -distance, limitedBy: base2.startIndex)
else {
// the offset overflows the bounds of `base2` by `n - d`
let d = base2.distance(from: base2.startIndex, to: i)
return base1.index(base1.endIndex, offsetBy: -(distance - d), limitedBy: limit)
return
base1
.index(base1.endIndex, offsetBy: -(distance - d), limitedBy: limit)
.map(Index.init(first:))
}
// the offset stays within the bounds of `base2`
return Index(second: j)
case let (.second(i), .second(limit)):
case (.second(let i), .second(let limit)):
// `limit` is relevant, so `base1` cannot be reached
return base2.index(i, offsetBy: -distance, limitedBy: limit)
.map(Index.init(second:))
}
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
switch (start.position, end.position) {
case let (.first(i), .first(j)):
case (.first(let i), .first(let j)):
return base1.distance(from: i, to: j)
case let (.second(i), .second(j)):
case (.second(let i), .second(let j)):
return base2.distance(from: i, to: j)
case let (.first(i), .second(j)):
case (.first(let i), .second(let j)):
return base1.distance(from: i, to: base1.endIndex)
+ base2.distance(from: base2.startIndex, to: j)
case let (.second(i), .first(j)):
case (.second(let i), .first(let j)):
return base2.distance(from: i, to: base2.startIndex)
+ base1.distance(from: base1.endIndex, to: j)
}
@@ -264,15 +274,14 @@ extension Chain2Sequence: Collection where Base1: Collection, Base2: Collection
}
extension Chain2Sequence: BidirectionalCollection
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
{
where Base1: BidirectionalCollection, Base2: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
assert(i != startIndex, "Can't advance before startIndex")
switch i.position {
case let .first(i):
case .first(let i):
return Index(first: base1.index(before: i))
case let .second(i):
case .second(let i):
return i == base2.startIndex
? Index(first: base1.index(before: base1.endIndex))
: Index(second: base2.index(before: i))
@@ -281,7 +290,7 @@ extension Chain2Sequence: BidirectionalCollection
}
extension Chain2Sequence: RandomAccessCollection
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
//===----------------------------------------------------------------------===//
// chain(_:_:)
+452 -110
View File
@@ -17,19 +17,19 @@ public struct ChunkedByCollection<Base: Collection, Subject> {
/// The collection that this instance provides a view onto.
@usableFromInline
internal let base: Base
/// The projection function.
@usableFromInline
internal let projection: (Base.Element) -> Subject
/// The predicate.
@usableFromInline
internal let belongInSameGroup: (Subject, Subject) -> Bool
/// The end index of the first chunk.
@usableFromInline
internal var endOfFirstChunk: Base.Index
@inlinable
internal init(
base: Base,
@@ -40,7 +40,7 @@ public struct ChunkedByCollection<Base: Collection, Subject> {
self.projection = projection
self.belongInSameGroup = belongInSameGroup
self.endOfFirstChunk = base.startIndex
if !base.isEmpty {
endOfFirstChunk = endOfChunk(startingAt: base.startIndex)
}
@@ -53,19 +53,19 @@ extension ChunkedByCollection: Collection {
/// The range corresponding to the chunk at this position.
@usableFromInline
internal var baseRange: Range<Base.Index>
@inlinable
internal init(_ baseRange: Range<Base.Index>) {
self.baseRange = baseRange
}
@inlinable
public static func == (lhs: Index, rhs: Index) -> Bool {
// Since each index represents the range of a disparate chunk, no two
// unique indices will have the same lower bound.
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
// Only use the lower bound to test for ordering, as above.
@@ -78,24 +78,24 @@ extension ChunkedByCollection: Collection {
@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)
})
}
@inlinable
public var startIndex: Index {
Index(base.startIndex..<endOfFirstChunk)
}
@inlinable
public var endIndex: Index {
Index(base.endIndex..<base.endIndex)
}
@inlinable
public func index(after i: Index) -> Index {
precondition(i != endIndex, "Can't advance past endIndex")
@@ -104,7 +104,7 @@ extension ChunkedByCollection: Collection {
let end = endOfChunk(startingAt: upperBound)
return Index(upperBound..<end)
}
@inlinable
public subscript(position: Index) -> Base.SubSequence {
precondition(position != endIndex, "Can't subscript using endIndex")
@@ -115,15 +115,14 @@ extension ChunkedByCollection: Collection {
extension ChunkedByCollection.Index: Hashable where Base.Index: Hashable {}
extension ChunkedByCollection: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
/// 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) -> 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 }
@@ -148,7 +147,7 @@ extension ChunkedByCollection: LazyCollectionProtocol {}
public struct ChunkedOnCollection<Base: Collection, Subject: Equatable> {
@usableFromInline
internal var chunked: ChunkedByCollection<Base, Subject>
@inlinable
internal init(
base: Base,
@@ -163,24 +162,26 @@ public struct ChunkedOnCollection<Base: Collection, Subject: Equatable> {
extension ChunkedOnCollection: Collection {
public typealias Index = ChunkedByCollection<Base, Subject>.Index
@inlinable
public var startIndex: Index {
chunked.startIndex
}
@inlinable
public var endIndex: Index {
chunked.endIndex
}
@inlinable
public subscript(position: Index) -> (Subject, Base.SubSequence) {
let subsequence = chunked[position]
// swift-format-ignore: NeverForceUnwrap
// Chunks are never empty, so `.first!` is safe.
let subject = chunked.projection(subsequence.first!)
return (subject, subsequence)
}
@inlinable
public func index(after i: Index) -> Index {
chunked.index(after: i)
@@ -188,8 +189,7 @@ extension ChunkedOnCollection: Collection {
}
extension ChunkedOnCollection: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
chunked.index(before: i)
@@ -198,6 +198,219 @@ extension ChunkedOnCollection: BidirectionalCollection
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:)
//===----------------------------------------------------------------------===//
@@ -206,6 +419,12 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
/// 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.
/// - Returns: A collection of subsequences, with every pairwise group of
/// elements in each chunk returning `true` for `belongInSameGroup`.
///
/// - Complexity: O(*n*), because the start index is pre-computed.
@inlinable
public func chunked(
@@ -216,9 +435,15 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
projection: { $0 },
belongInSameGroup: belongInSameGroup)
}
/// Returns a lazy collection of subsequences of this collection, chunked by
/// grouping elements that project to the same value.
/// 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.
/// - Returns: A collection of subsequences, with every element in each chunk
/// returning the same value for `projection`.
///
/// - Complexity: O(*n*), because the start index is pre-computed.
@inlinable
@@ -227,7 +452,8 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
) -> ChunkedOnCollection<Elements, Subject> {
ChunkedOnCollection(
base: elements,
projection: projection)
projection: projection
)
}
}
@@ -239,6 +465,12 @@ 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, with every pairwise group of
/// elements in each chunk returning `true` for `belongInSameGroup`.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
@inlinable
public func chunked(
@@ -246,10 +478,10 @@ extension Collection {
) rethrows -> [SubSequence] {
guard !isEmpty else { return [] }
var result: [SubSequence] = []
var start = startIndex
var current = self[start]
for (index, element) in indexed().dropFirst() {
if try !belongInSameGroup(current, element) {
result.append(self[start..<index])
@@ -257,16 +489,22 @@ extension Collection {
}
current = element
}
if start != endIndex {
result.append(self[start...])
}
return result
}
/// Returns a collection of subsequences of this collection, chunked by
/// grouping elements that project to the same value.
/// 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.
/// - Returns: A collection of subsequences, with every element in each chunk
/// returning the same value for `projection`.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
@inlinable
@@ -275,10 +513,10 @@ extension Collection {
) rethrows -> [(Subject, SubSequence)] {
guard !isEmpty else { return [] }
var result: [(Subject, SubSequence)] = []
var start = startIndex
var subject = try projection(self[start])
for (index, element) in indexed().dropFirst() {
let nextSubject = try projection(element)
if subject != nextSubject {
@@ -287,11 +525,11 @@ extension Collection {
subject = nextSubject
}
}
if start != endIndex {
result.append((subject, self[start...]))
}
return result
}
}
@@ -313,13 +551,13 @@ extension Collection {
/// `LazyMapCollection`
public struct ChunksOfCountCollection<Base: Collection> {
public typealias Element = Base.SubSequence
@usableFromInline
internal let base: Base
@usableFromInline
internal let chunkCount: Int
@usableFromInline
internal var endOfFirstChunk: Base.Index
@@ -331,13 +569,15 @@ public struct ChunksOfCountCollection<Base: Collection> {
internal init(_base: Base, _chunkCount: Int) {
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(
_base.startIndex, offsetBy: _chunkCount,
limitedBy: _base.endIndex
) ?? _base.endIndex
self.endOfFirstChunk =
_base.index(
_base.startIndex,
offsetBy: _chunkCount,
limitedBy: _base.endIndex
) ?? _base.endIndex
}
}
@@ -345,7 +585,7 @@ extension ChunksOfCountCollection: Collection {
public struct Index {
@usableFromInline
internal let baseRange: Range<Base.Index>
@inlinable
internal init(_baseRange: Range<Base.Index>) {
self.baseRange = _baseRange
@@ -357,40 +597,46 @@ extension ChunksOfCountCollection: Collection {
public var startIndex: Index {
Index(_baseRange: base.startIndex..<endOfFirstChunk)
}
@inlinable
public var endIndex: Index {
Index(_baseRange: base.endIndex..<base.endIndex)
}
/// - Complexity: O(1)
@inlinable
public subscript(i: Index) -> Element {
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")
let baseIdx = base.index(
i.baseRange.upperBound, offsetBy: chunkCount,
limitedBy: base.endIndex
) ?? base.endIndex
let baseIdx =
base.index(
i.baseRange.upperBound,
offsetBy: chunkCount,
limitedBy: base.endIndex
) ?? base.endIndex
return Index(_baseRange: i.baseRange.upperBound..<baseIdx)
}
}
extension ChunksOfCountCollection.Index: Comparable {
@inlinable
public static func == (lhs: ChunksOfCountCollection.Index,
rhs: ChunksOfCountCollection.Index) -> Bool {
public static func == (
lhs: ChunksOfCountCollection.Index,
rhs: ChunksOfCountCollection.Index
) -> Bool {
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
}
@inlinable
public static func < (lhs: ChunksOfCountCollection.Index,
rhs: ChunksOfCountCollection.Index) -> Bool {
public static func < (
lhs: ChunksOfCountCollection.Index,
rhs: ChunksOfCountCollection.Index
) -> Bool {
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
}
}
@@ -401,7 +647,7 @@ where Base: RandomAccessCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i != startIndex, "Advancing past start index")
var offset = chunkCount
if i.baseRange.lowerBound == base.endIndex {
let remainder = base.count % chunkCount
@@ -409,11 +655,13 @@ where Base: RandomAccessCollection {
offset = remainder
}
}
let baseIdx = base.index(
i.baseRange.lowerBound, offsetBy: -offset,
limitedBy: base.startIndex
) ?? base.startIndex
let baseIdx =
base.index(
i.baseRange.lowerBound,
offsetBy: -offset,
limitedBy: base.startIndex
) ?? base.startIndex
return Index(_baseRange: baseIdx..<i.baseRange.lowerBound)
}
}
@@ -422,10 +670,11 @@ extension ChunksOfCountCollection {
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
let distance =
base.distance(from: start.baseRange.lowerBound,
to: end.baseRange.lowerBound)
base
.distance(from: start.baseRange.lowerBound, to: end.baseRange.lowerBound)
let (quotient, remainder) =
distance.quotientAndRemainder(dividingBy: chunkCount)
distance
.quotientAndRemainder(dividingBy: chunkCount)
return quotient + remainder.signum()
}
@@ -435,14 +684,16 @@ extension ChunksOfCountCollection {
base.count.quotientAndRemainder(dividingBy: chunkCount)
return quotient + remainder.signum()
}
@inlinable
public func index(
_ i: Index, offsetBy offset: Int, limitedBy limit: Index
_ i: Index,
offsetBy offset: Int,
limitedBy limit: Index
) -> Index? {
guard offset != 0 else { return i }
guard limit != i else { return nil }
if offset > 0 {
return limit > i
? offsetForward(i, offsetBy: offset, limit: limit)
@@ -457,33 +708,40 @@ extension ChunksOfCountCollection {
@inlinable
public func index(_ i: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return i }
let idx = distance > 0
? offsetForward(i, offsetBy: distance)
: offsetBackward(i, offsetBy: distance)
let idx =
distance > 0
? offsetForward(i, offsetBy: distance)
: offsetBackward(i, offsetBy: distance)
guard let index = idx else {
fatalError("Out of bounds")
}
return index
}
@inlinable
internal func offsetForward(
_ i: Index, offsetBy distance: Int, limit: Index? = nil
_ i: Index,
offsetBy distance: Int,
limit: Index? = nil
) -> Index? {
assert(distance > 0)
return makeOffsetIndex(
from: i, baseBound: base.endIndex,
distance: distance, baseDistance: distance * chunkCount,
limit: limit, by: >
from: i,
baseBound: base.endIndex,
distance: distance,
baseDistance: distance * chunkCount,
limit: limit,
by: >
)
}
// Convenience to compute offset backward base distance.
@inlinable
internal func computeOffsetBackwardBaseDistance(
_ i: Index, _ distance: Int
_ i: Index,
_ distance: Int
) -> Int {
if i == endIndex {
let remainder = base.count % chunkCount
@@ -497,32 +755,41 @@ extension ChunksOfCountCollection {
}
return distance * chunkCount
}
@inlinable
internal func offsetBackward(
_ i: Index, offsetBy distance: Int, limit: Index? = nil
_ i: Index,
offsetBy distance: Int,
limit: Index? = nil
) -> Index? {
assert(distance < 0)
let baseDistance =
computeOffsetBackwardBaseDistance(i, distance)
let baseDistance = computeOffsetBackwardBaseDistance(i, distance)
return makeOffsetIndex(
from: i, baseBound: base.startIndex,
distance: distance, baseDistance: baseDistance,
limit: limit, by: <
from: i,
baseBound: base.startIndex,
distance: distance,
baseDistance: baseDistance,
limit: limit,
by: <
)
}
// Helper to compute `index(offsetBy:)` index.
@inlinable
internal func makeOffsetIndex(
from i: Index, baseBound: Base.Index, distance: Int, baseDistance: Int,
limit: Index?, by limitFn: (Base.Index, Base.Index) -> Bool
from i: Index,
baseBound: Base.Index,
distance: Int,
baseDistance: Int,
limit: Index?,
by limitFn: (Base.Index, Base.Index) -> Bool
) -> Index? {
let baseIdx = base.index(
i.baseRange.lowerBound, offsetBy: baseDistance,
i.baseRange.lowerBound,
offsetBy: baseDistance,
limitedBy: baseBound
)
if let limit = limit {
if baseIdx == nil {
// If we passed the bounds while advancing forward, and the limit is the
@@ -547,33 +814,52 @@ extension ChunksOfCountCollection {
return nil
}
}
let baseStartIdx = baseIdx ?? baseBound
let baseEndIdx = base.index(
baseStartIdx, offsetBy: chunkCount, limitedBy: base.endIndex
) ?? base.endIndex
let baseEndIdx =
base.index(
baseStartIdx,
offsetBy: chunkCount,
limitedBy: base.endIndex
)
?? base.endIndex
return Index(_baseRange: baseStartIdx..<baseEndIdx)
}
}
extension Collection {
/// Returns a `ChunksOfCountCollection<Self>` view presenting the elements in
/// chunks with count of the given count parameter.
/// Returns a collection of subsequences, each with up to the specified
/// length.
///
/// - Parameter count: 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.
/// 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.
///
/// 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]]
/// 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]
///
/// print(c.chunks(ofCount: 3).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`.
///
/// - Complexity: O(*n*), because the start index is pre-computed.
@inlinable
public func chunks(ofCount count: Int) -> ChunksOfCountCollection<Self> {
precondition(count > 0, "Cannot chunk with count <= 0!")
@@ -583,5 +869,61 @@ extension Collection {
extension ChunksOfCountCollection.Index: Hashable where Base.Index: Hashable {}
extension ChunksOfCountCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
extension ChunksOfCountCollection: LazySequenceProtocol
where Base: LazySequenceProtocol {}
extension ChunksOfCountCollection: 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)
}
}
+42 -30
View File
@@ -14,17 +14,17 @@ public struct CombinationsSequence<Base: Collection> {
/// The collection to iterate over for combinations.
@usableFromInline
internal let base: Base
@usableFromInline
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`.
///
@@ -35,7 +35,7 @@ public struct CombinationsSequence<Base: Collection> {
internal init(_ base: Base, k: Int) {
self.init(base, kRange: k...k)
}
/// Initializes a `CombinationsSequence` for all combinations of `base` of
/// sizes within a given range.
///
@@ -44,27 +44,29 @@ public struct CombinationsSequence<Base: Collection> {
/// - kRange: The range of accepted sizes of combinations.
@inlinable
internal init<R: RangeExpression>(
_ base: Base, kRange: R
_ base: Base,
kRange: R
) where R.Bound == Int {
let range = kRange.relative(to: 0 ..< .max)
self.base = base
let baseCount = base.count
self.baseCount = baseCount
let upperBound = baseCount + 1
self.kRange = range.lowerBound < upperBound
? range.clamped(to: 0 ..< upperBound)
self.kRange =
range.lowerBound < upperBound
? range.clamped(to: 0..<upperBound)
: nil
}
/// The total number of combinations.
@inlinable
public var count: Int {
guard let k = self.kRange else { return 0 }
let n = baseCount
if k == 0 ..< (n + 1) {
if k == 0..<(n + 1) {
return 1 << n
}
func binomial(n: Int, k: Int) -> Int {
switch k {
case n, 0: return 1
@@ -73,11 +75,15 @@ public struct CombinationsSequence<Base: Collection> {
default: return n * binomial(n: n - 1, k: k - 1) / k
}
}
return k.map {
binomial(n: n, k: $0)
}.reduce(0, +)
}
/// The total number of combinations.
@inlinable
public var underestimatedCount: Int { count }
}
extension CombinationsSequence: Sequence {
@@ -85,7 +91,7 @@ extension CombinationsSequence: Sequence {
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
@@ -93,23 +99,23 @@ extension CombinationsSequence: Sequence {
/// finished.
@usableFromInline
internal var kRange: Range<Int>
/// Whether or not iteration is finished (`kRange` is empty)
/// Whether or not iteration is finished (`kRange` is empty).
@inlinable
internal var isFinished: Bool {
return kRange.isEmpty
kRange.isEmpty
}
@usableFromInline
internal var indexes: [Base.Index]
@inlinable
internal init(_ combinations: CombinationsSequence) {
self.base = combinations.base
self.kRange = combinations.kRange ?? 0..<0
self.indexes = Array(combinations.base.indices.prefix(kRange.lowerBound))
}
/// Advances the current indices to the next set of combinations. If
/// `indexes.count == 3` and `base.count == 5`, the indices advance like
/// this:
@@ -135,12 +141,12 @@ extension CombinationsSequence: Sequence {
func advanceKRange() {
if kRange.lowerBound < kRange.upperBound {
let advancedLowerBound = kRange.lowerBound + 1
kRange = advancedLowerBound ..< kRange.upperBound
kRange = advancedLowerBound..<kRange.upperBound
indexes.removeAll(keepingCapacity: true)
indexes.append(contentsOf: base.indices.prefix(kRange.lowerBound))
}
}
guard !indexes.isEmpty else {
// Initial state for combinations of 0 elements is an empty array with
// `finished == false`. Even though no indexes are involved, advancing
@@ -148,11 +154,11 @@ extension CombinationsSequence: Sequence {
advanceKRange()
return
}
let i = indexes.count - 1
base.formIndex(after: &indexes[i])
if indexes[i] != base.endIndex { return }
var j = i
while indexes[i] == base.endIndex {
j -= 1
@@ -161,7 +167,7 @@ extension CombinationsSequence: Sequence {
advanceKRange()
return
}
base.formIndex(after: &indexes[j])
for k in indexes.indices[(j + 1)...] {
indexes[k] = base.index(after: indexes[k - 1])
@@ -171,7 +177,7 @@ extension CombinationsSequence: Sequence {
}
}
}
@inlinable
public mutating func next() -> [Base.Element]? {
guard !isFinished else { return nil }
@@ -179,7 +185,7 @@ extension CombinationsSequence: Sequence {
return indexes.map { i in base[i] }
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(self)
@@ -187,7 +193,7 @@ extension CombinationsSequence: Sequence {
}
extension CombinationsSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// combinations(ofCount:)
@@ -251,6 +257,8 @@ extension Collection {
///
/// - Parameter kRange: The range of numbers of elements to include in each
/// combination.
/// - Returns: A sequence of the combinations of this collection's
/// elements, for all sizes in `kRange`, from smallest to largest.
///
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
/// is the number of elements in the base collection, since
@@ -261,7 +269,7 @@ extension Collection {
) -> CombinationsSequence<Self> where R.Bound == Int {
CombinationsSequence(self, kRange: kRange)
}
/// Returns a collection of combinations of this collection's elements, with
/// each combination having the specified number of elements.
///
@@ -287,13 +295,17 @@ extension Collection {
/// the resulting sequence has no elements.
///
/// - Parameter k: The number of elements to include in each combination.
/// - Returns: A sequence of the combinations of this collection's
/// elements.
///
/// - 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
/// `CombinationsSequence` accesses the `count` of the base collection.
@inlinable
public func combinations(ofCount k: Int) -> CombinationsSequence<Self> {
precondition(k >= 0, "Can't have combinations with a negative number of elements.")
precondition(
k >= 0,
"Can't have combinations with a negative number of elements.")
return CombinationsSequence(self, k: k)
}
}
+33 -29
View File
@@ -12,11 +12,11 @@
/// A `Sequence` that iterates over every non-nil element from the original
/// `Sequence`.
public struct CompactedSequence<Base: Sequence, Element>: Sequence
where Base.Element == Element? {
where Base.Element == Element? {
@usableFromInline
let base: Base
@inlinable
init(base: Base) {
self.base = base
@@ -25,12 +25,12 @@ public struct CompactedSequence<Base: Sequence, Element>: Sequence
public struct Iterator: IteratorProtocol {
@usableFromInline
var base: Base.Iterator
@inlinable
init(base: Base.Iterator) {
self.base = base
}
@inlinable
public mutating func next() -> Element? {
while let wrapped = base.next() {
@@ -68,7 +68,7 @@ extension Sequence {
/// Complexity: O(1)
@inlinable
public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
where Element == Unwrapped? {
where Element == Unwrapped? {
CompactedSequence(base: self)
}
}
@@ -76,74 +76,79 @@ extension Sequence {
/// A `Collection` that iterates over every non-nil element from the original
/// `Collection`.
public struct CompactedCollection<Base: Collection, Element>: Collection
where Base.Element == Element? {
where Base.Element == Element? {
@usableFromInline
let base: Base
@inlinable
init(base: Base) {
self.base = base
let idx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
self.startIndex = Index(base: idx)
}
public struct Index {
@usableFromInline
let base: Base.Index
@inlinable
init(base: Base.Index) {
self.base = base
}
}
public var startIndex: Index
@inlinable
public var endIndex: Index { Index(base: base.endIndex) }
@inlinable
public subscript(position: Index) -> Element {
// swift-format-ignore: NeverForceUnwrap
// All indices are only for non-`nil` elements.
base[position.base]!
}
@inlinable
public func index(after i: Index) -> Index {
precondition(i != endIndex, "Index out of bounds")
let baseIdx = base.index(after: i.base)
guard let idx = base[baseIdx...].firstIndex(where: { $0 != nil })
else { return endIndex }
else { return endIndex }
return Index(base: idx)
}
}
extension CompactedCollection: BidirectionalCollection
where Base: BidirectionalCollection {
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i != startIndex, "Index out of bounds")
guard let idx =
base[startIndex.base..<i.base]
.lastIndex(where: { $0 != nil })
else { fatalError("Index out of bounds") }
guard
let idx =
base[startIndex.base..<i.base]
.lastIndex(where: { $0 != nil })
else { fatalError("Index out of bounds") }
return Index(base: idx)
}
}
extension CompactedCollection.Index: Comparable {
extension CompactedCollection.Index: Comparable {
@inlinable
public static func < (lhs: CompactedCollection.Index,
rhs: CompactedCollection.Index) -> Bool {
public static func < (
lhs: CompactedCollection.Index,
rhs: CompactedCollection.Index
) -> Bool {
lhs.base < rhs.base
}
}
extension CompactedCollection.Index: Hashable
where Base.Index: Hashable {}
where Base.Index: Hashable {}
extension Collection {
/// Returns a new `Collection` that iterates over every non-nil element from
@@ -167,8 +172,7 @@ extension Collection {
/// original `Collection`.
@inlinable
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
where Element == Unwrapped?
{
where Element == Unwrapped? {
CompactedCollection(base: self)
}
}
@@ -178,7 +182,7 @@ extension Collection {
//===----------------------------------------------------------------------===//
extension CompactedSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension CompactedCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
+17 -16
View File
@@ -14,7 +14,7 @@ public struct CycledSequence<Base: Collection> {
/// The collection to repeat.
@usableFromInline
internal let base: Base
@inlinable
internal init(base: Base) {
self.base = base
@@ -26,29 +26,29 @@ extension CycledSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal let base: Base
@usableFromInline
internal var current: Base.Index
@inlinable
internal init(base: Base) {
self.base = base
self.current = base.startIndex
}
@inlinable
public mutating func next() -> Base.Element? {
guard !base.isEmpty else { return nil }
if current == base.endIndex {
current = base.startIndex
}
defer { base.formIndex(after: &current) }
return base[current]
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(base: base)
@@ -56,7 +56,7 @@ extension CycledSequence: Sequence {
}
extension CycledSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
/// A collection wrapper that repeats the elements of a base collection for a
/// finite number of times.
@@ -134,10 +134,11 @@ extension CycledTimesCollection: Collection {
offsetBy distance: Int,
limitedBy limit: Index
) -> Index? {
guard let productIndex = product.index(
i.productIndex,
offsetBy: distance,
limitedBy: limit.productIndex)
guard
let productIndex = product.index(
i.productIndex,
offsetBy: distance,
limitedBy: limit.productIndex)
else { return nil }
return Index(productIndex)
}
@@ -149,7 +150,7 @@ extension CycledTimesCollection: Collection {
}
extension CycledTimesCollection: BidirectionalCollection
where Base: BidirectionalCollection {
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
let productIndex = product.index(before: i.productIndex)
@@ -158,10 +159,10 @@ extension CycledTimesCollection: BidirectionalCollection
}
extension CycledTimesCollection: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension CycledTimesCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// cycled()
@@ -197,7 +198,7 @@ extension Collection {
public func cycled() -> CycledSequence<Self> {
CycledSequence(base: self)
}
/// Returns a sequence that repeats the elements of this collection the
/// specified number of times.
///
@@ -0,0 +1,42 @@
# ``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:Keying>
- <doc:Sampling>
- <doc:MinAndMax>
- <doc:Selecting>
- <doc:Filtering>
- <doc:Reductions>
- <doc:Partitioning>
@@ -0,0 +1,40 @@
# 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``
@@ -0,0 +1,32 @@
# 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``
@@ -0,0 +1,14 @@
# 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:_:)``
@@ -0,0 +1,42 @@
# 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``
@@ -0,0 +1,41 @@
# 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``
@@ -0,0 +1,35 @@
# 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``
@@ -0,0 +1,14 @@
# Keying and Grouping
Convert a sequence to a dictionary, providing keys to individual elements or to use as grouping values.
## Topics
### Creating a Keyed Dictionary
- ``Swift/Sequence/keyed(by:)``
- ``Swift/Sequence/keyed(by:resolvingConflictsWith:)``
### Grouping Elements by Key
- ``Swift/Sequence/grouped(by:)``
@@ -0,0 +1,23 @@
# 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 Simultaneously
- ``Swift/Sequence/minAndMax()``
- ``Swift/Sequence/minAndMax(by:)``
@@ -0,0 +1,63 @@
# 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:)``
@@ -0,0 +1,35 @@
# 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>
@@ -0,0 +1,17 @@
# 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:)``
@@ -0,0 +1,25 @@
# 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``
@@ -0,0 +1,29 @@
# 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``
@@ -0,0 +1,32 @@
# 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:)``
### Finding Boundaries within a Collection
- ``Swift/Collection/endOfPrefix(while:)``
- ``Swift/BidirectionalCollection/startOfSuffix(while:)``
+24 -27
View File
@@ -24,9 +24,9 @@ extension Either: Equatable where Left: Equatable, Right: Equatable {
@usableFromInline
internal static func == (lhs: Self, rhs: Self) -> Bool {
switch (lhs, rhs) {
case let (.left(lhs), .left(rhs)):
case (.left(let lhs), .left(let rhs)):
return lhs == rhs
case let (.right(lhs), .right(rhs)):
case (.right(let lhs), .right(let rhs)):
return lhs == rhs
case (.left, .right), (.right, .left):
return false
@@ -38,9 +38,9 @@ extension Either: Comparable where Left: Comparable, Right: Comparable {
@usableFromInline
internal static func < (lhs: Self, rhs: Self) -> Bool {
switch (lhs, rhs) {
case let (.left(lhs), .left(rhs)):
case (.left(let lhs), .left(let rhs)):
return lhs < rhs
case let (.right(lhs), .right(rhs)):
case (.right(let lhs), .right(let rhs)):
return lhs < rhs
case (.left, .right):
return true
@@ -57,8 +57,7 @@ extension Either: Comparable where Left: Comparable, Right: Comparable {
/// A sequence that has one of the two specified types.
@usableFromInline
internal enum EitherSequence<Left: Sequence, Right: Sequence>
where Left.Element == Right.Element
{
where Left.Element == Right.Element {
case left(Left)
case right(Right)
}
@@ -68,16 +67,16 @@ extension EitherSequence: Sequence {
internal struct Iterator: IteratorProtocol {
@usableFromInline
internal var left: Left.Iterator?
@usableFromInline
internal var right: Right.Iterator?
@inlinable
internal mutating func next() -> Left.Element? {
left?.next() ?? right?.next()
}
}
@usableFromInline
internal func makeIterator() -> Iterator {
switch self {
@@ -90,8 +89,7 @@ extension EitherSequence: Sequence {
}
extension EitherSequence: Collection
where Left: Collection, Right: Collection, Left.Element == Right.Element
{
where Left: Collection, Right: Collection, Left.Element == Right.Element {
@usableFromInline
internal typealias Index = Either<Left.Index, Right.Index>
@@ -118,9 +116,9 @@ extension EitherSequence: Collection
@inlinable
internal subscript(position: Index) -> Element {
switch (self, position) {
case let (.left(s), .left(i)):
case (.left(let s), .left(let i)):
return s[i]
case let (.right(s), .right(i)):
case (.right(let s), .right(let i)):
return s[i]
default:
fatalError()
@@ -129,10 +127,10 @@ extension EitherSequence: Collection
@inlinable
internal func index(after i: Index) -> Index {
switch (self,i) {
case let (.left(s), .left(i)):
switch (self, i) {
case (.left(let s), .left(let i)):
return .left(s.index(after: i))
case let (.right(s), .right(i)):
case (.right(let s), .right(let i)):
return .right(s.index(after: i))
default:
fatalError()
@@ -146,9 +144,9 @@ extension EitherSequence: Collection
limitedBy limit: Index
) -> Index? {
switch (self, i, limit) {
case let (.left(s), .left(i), .left(limit)):
case (.left(let s), .left(let i), .left(let limit)):
return s.index(i, offsetBy: distance, limitedBy: limit).map { .left($0) }
case let (.right(s), .right(i), .right(limit)):
case (.right(let s), .right(let i), .right(let limit)):
return s.index(i, offsetBy: distance, limitedBy: limit).map { .right($0) }
default:
fatalError()
@@ -158,9 +156,9 @@ extension EitherSequence: Collection
@inlinable
internal func index(_ i: Index, offsetBy distance: Int) -> Index {
switch (self, i) {
case let (.left(s), .left(i)):
case (.left(let s), .left(let i)):
return .left(s.index(i, offsetBy: distance))
case let (.right(s), .right(i)):
case (.right(let s), .right(let i)):
return .right(s.index(i, offsetBy: distance))
default:
fatalError()
@@ -170,9 +168,9 @@ extension EitherSequence: Collection
@inlinable
internal func distance(from start: Index, to end: Index) -> Int {
switch (self, start, end) {
case let (.left(s), .left(i), .left(j)):
case (.left(let s), .left(let i), .left(let j)):
return s.distance(from: i, to: j)
case let (.right(s), .right(i), .right(j)):
case (.right(let s), .right(let i), .right(let j)):
return s.distance(from: i, to: j)
default:
fatalError()
@@ -181,14 +179,13 @@ extension EitherSequence: Collection
}
extension EitherSequence: BidirectionalCollection
where Left: BidirectionalCollection, Right: BidirectionalCollection
{
where Left: BidirectionalCollection, Right: BidirectionalCollection {
@inlinable
internal func index(before i: Index) -> Index {
switch (self, i) {
case let (.left(s), .left(i)):
case (.left(let s), .left(let i)):
return .left(s.index(before: i))
case let (.right(s), .right(i)):
case (.right(let s), .right(let i)):
return .right(s.index(before: i))
default:
fatalError()
@@ -197,4 +194,4 @@ extension EitherSequence: BidirectionalCollection
}
extension EitherSequence: RandomAccessCollection
where Left: RandomAccessCollection, Right: RandomAccessCollection {}
where Left: RandomAccessCollection, Right: RandomAccessCollection {}
+83
View File
@@ -0,0 +1,83 @@
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// EndsWith
//===----------------------------------------------------------------------===//
extension BidirectionalCollection where Element: Equatable {
/// Returns a Boolean value indicating whether the final elements of the
/// collection are the same as the elements in another collection.
///
/// This example tests whether one countable range ends with the elements
/// of another countable range.
///
/// let a = 8...10
/// let b = 1...10
///
/// print(b.ends(with: a))
/// // Prints "true"
///
/// Passing a collection with no elements or an empty collection as
/// `possibleSuffix` always results in `true`.
///
/// print(b.ends(with: []))
/// // Prints "true"
///
/// - Parameter possibleSuffix: A collection to compare to this collection.
/// - Returns: `true` if the initial elements of the collection are the same as
/// the elements of `possibleSuffix`; otherwise, `false`. If
/// `possibleSuffix` has no elements, the return value is `true`.
///
/// - Complexity: O(*m*), where *m* is the lesser of the length of the
/// collection and the length of `possibleSuffix`.
@inlinable
public func ends<PossibleSuffix: BidirectionalCollection>(
with possibleSuffix: PossibleSuffix
) -> Bool where PossibleSuffix.Element == Element {
self.ends(with: possibleSuffix, by: ==)
}
}
extension BidirectionalCollection {
/// Returns a Boolean value indicating whether the final elements of the
/// collection are equivalent to the elements in another collection, using
/// the given predicate as the equivalence test.
///
/// The predicate must be an *equivalence relation* over the elements. That
/// is, for any elements `a`, `b`, and `c`, the following conditions must
/// hold:
///
/// - `areEquivalent(a, a)` is always `true`. (Reflexivity)
/// - `areEquivalent(a, b)` implies `areEquivalent(b, a)`. (Symmetry)
/// - If `areEquivalent(a, b)` and `areEquivalent(b, c)` are both `true`, then
/// `areEquivalent(a, c)` is also `true`. (Transitivity)
///
/// - Parameters:
/// - possibleSuffix: A collection to compare to this collection.
/// - areEquivalent: A predicate that returns `true` if its two arguments
/// are equivalent; otherwise, `false`.
/// - Returns: `true` if the initial elements of the collection are equivalent
/// to the elements of `possibleSuffix`; otherwise, `false`. If
/// `possibleSuffix` has no elements, the return value is `true`.
///
/// - Complexity: O(*m*), where *m* is the lesser of the length of the
/// collection and the length of `possibleSuffix`.
@inlinable
public func ends<PossibleSuffix: BidirectionalCollection>(
with possibleSuffix: PossibleSuffix,
by areEquivalent: (Element, PossibleSuffix.Element) throws -> Bool
) rethrows -> Bool {
try self
.reversed()
.starts(with: possibleSuffix.reversed(), by: areEquivalent)
}
}
+109 -88
View File
@@ -13,14 +13,13 @@
/// collections.
@usableFromInline
internal struct FlattenCollection<Base: Collection>
where Base.Element: Collection
{
where Base.Element: Collection {
@usableFromInline
internal let base: Base
@usableFromInline
internal let indexOfFirstNonEmptyElement: Base.Index
@inlinable
internal init(base: Base) {
self.base = base
@@ -33,35 +32,39 @@ extension FlattenCollection: Collection {
internal struct Index: Comparable {
@usableFromInline
internal let outer: Base.Index
@usableFromInline
internal let inner: Base.Element.Index?
@inlinable
init(outer: Base.Index, inner: Base.Element.Index?) {
self.outer = outer
self.inner = inner
}
@inlinable
internal static func < (lhs: Self, rhs: Self) -> Bool {
guard lhs.outer == rhs.outer else { return lhs.outer < rhs.outer }
// swift-format-ignore: NeverForceUnwrap
// `inner` is nil iff `outer` is `base.endIndex`, and the
// previous line established that the two outer indices are equal.
// Thus, either both inner indices are nil or neither are.
return lhs.inner == nil ? false : lhs.inner! < rhs.inner!
}
}
@inlinable
internal var startIndex: Index {
let outer = indexOfFirstNonEmptyElement
let inner = outer == base.endIndex ? nil : base[outer].startIndex
return Index(outer: outer, inner: inner)
}
@inlinable
internal var endIndex: Index {
Index(outer: base.endIndex, inner: nil)
}
/// Forms an index from a pair of base indices, normalizing
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
/// necessary.
@@ -70,56 +73,64 @@ extension FlattenCollection: Collection {
outer: Base.Index,
inner: Base.Element.Index
) -> Index {
if inner == base[outer].endIndex {
let outer = base[base.index(after: outer)...]
.endOfPrefix(while: { $0.isEmpty })
let inner = outer == base.endIndex ? nil : base[outer].startIndex
return Index(outer: outer, inner: inner)
} else {
guard inner == base[outer].endIndex else {
return Index(outer: outer, inner: inner)
}
let outer = base[base.index(after: outer)...]
.endOfPrefix(while: { $0.isEmpty })
let inner = outer == base.endIndex ? nil : base[outer].startIndex
return Index(outer: outer, inner: inner)
}
@inlinable
internal func index(after index: Index) -> Index {
let element = base[index.outer]
// swift-format-ignore: NeverForceUnwrap
// This unwrap, like the unchecked subscript above, enforces the
// precondition that you can't advance past `endIndex`.
let nextInner = element.index(after: index.inner!)
return normalizeIndex(outer: index.outer, inner: nextInner)
}
@inlinable
internal subscript(position: Index) -> Base.Element.Element {
// swift-format-ignore: NeverForceUnwrap
// This unwrap, along with the unchecked subscript, enforces the
// precondition that you can't subscript at `endIndex`.
base[position.outer][position.inner!]
}
@inlinable
internal func distance(from start: Index, to end: Index) -> Int {
guard start.outer <= end.outer
else { return -distance(from: end, to: start) }
else { return -distance(from: end, to: start) }
guard let startInner = start.inner
else { return 0 }
else { return 0 }
guard start.outer != end.outer
else {
return base[start.outer].distance(from: startInner, to: end.inner!)
}
else {
// swift-format-ignore: NeverForceUnwrap
// Established via guards that outer indices are equal and `start.inner`
// is non-nil, so `end.inner` must also be non-`nil`.
return base[start.outer].distance(from: startInner, to: end.inner!)
}
let firstPart = base[start.outer][startInner...].count
let middlePart = base[start.outer..<end.outer].dropFirst()
.reduce(0, { $0 + $1.count })
let lastPart = end.inner.map { base[end.outer][..<$0].count } ?? 0
return firstPart + middlePart + lastPart
}
@inlinable
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return index }
return distance > 0
? offsetForward(index, by: distance)
: offsetBackward(index, by: -distance)
}
@inlinable
internal func index(
_ index: Index,
@@ -127,7 +138,7 @@ extension FlattenCollection: Collection {
limitedBy limit: Index
) -> Index? {
guard distance != 0 else { return index }
if distance > 0 {
return limit >= index
? offsetForward(index, by: distance, limitedBy: limit)
@@ -138,133 +149,139 @@ extension FlattenCollection: Collection {
: offsetBackward(index, by: -distance)
}
}
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit >= index)
if index.outer == limit.outer {
if let indexInner = index.inner, let limitInner = limit.inner {
return base[index.outer]
.index(indexInner, offsetBy: distance, limitedBy: limitInner)
.map { inner in Index(outer: index.outer, inner: inner) }
} else {
guard let indexInner = index.inner, let limitInner = limit.inner else {
// `index` and `limit` are both `endIndex`
return nil
}
return base[index.outer]
.index(indexInner, offsetBy: distance, limitedBy: limitInner)
.map { inner in Index(outer: index.outer, inner: inner) }
}
// swift-format-ignore: NeverForceUnwrap
// `index <= limit` and `index.outer != limit.outer`, so `index != endIndex`
let indexInner = index.inner!
let element = base[index.outer]
if let inner = element.index(
indexInner,
offsetBy: distance,
limitedBy: element.endIndex
indexInner,
offsetBy: distance,
limitedBy: element.endIndex
) {
return normalizeIndex(outer: index.outer, inner: inner)
}
var remainder = distance - element[indexInner...].count
var outer = base.index(after: index.outer)
while outer != limit.outer {
let element = base[outer]
if let inner = element.index(
element.startIndex,
offsetBy: remainder,
limitedBy: element.endIndex
element.startIndex,
offsetBy: remainder,
limitedBy: element.endIndex
) {
return normalizeIndex(outer: outer, inner: inner)
}
remainder -= element.count
base.formIndex(after: &outer)
}
if let limitInner = limit.inner {
let element = base[outer]
return element.index(
element.startIndex,
offsetBy: remainder,
limitedBy: limitInner)
.map { inner in Index(outer: outer, inner: inner) }
} else {
return nil
limitedBy: limitInner
)
.map { inner in Index(outer: outer, inner: inner) }
}
return nil
}
@inlinable
internal func offsetBackward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit <= index)
if index.outer == limit.outer {
if let indexInner = index.inner, let limitInner = limit.inner {
return base[index.outer]
.index(indexInner, offsetBy: -distance, limitedBy: limitInner)
.map { inner in Index(outer: index.outer, inner: inner) }
} else {
guard let indexInner = index.inner, let limitInner = limit.inner else {
// `index` and `limit` are both `endIndex`
return nil
}
return base[index.outer]
.index(indexInner, offsetBy: -distance, limitedBy: limitInner)
.map { inner in Index(outer: index.outer, inner: inner) }
}
var remainder = distance
if let indexInner = index.inner {
let element = base[index.outer]
if let inner = element.index(
indexInner,
offsetBy: -remainder,
limitedBy: element.startIndex
indexInner,
offsetBy: -remainder,
limitedBy: element.startIndex
) {
return Index(outer: index.outer, inner: inner)
}
remainder -= element[..<indexInner].count
}
var outer = base.index(index.outer, offsetBy: -1)
while outer != limit.outer {
let element = base[outer]
if let inner = element.index(
element.endIndex,
offsetBy: -remainder,
limitedBy: element.startIndex
element.endIndex,
offsetBy: -remainder,
limitedBy: element.startIndex
) {
return Index(outer: outer, inner: inner)
}
remainder -= element.count
base.formIndex(&outer, offsetBy: -1)
}
let element = base[outer]
// swift-format-ignore: NeverForceUnwrap
// At start of function, `limit <= index`, and checked for
// `limit == endIndex`.
return element.index(
element.endIndex,
offsetBy: -remainder,
@@ -274,20 +291,24 @@ extension FlattenCollection: Collection {
}
extension FlattenCollection: BidirectionalCollection
where Base: BidirectionalCollection, Base.Element: BidirectionalCollection
{
where Base: BidirectionalCollection, Base.Element: BidirectionalCollection {
@inlinable
internal func index(before index: Index) -> Index {
if let inner = index.inner {
let element = base[index.outer]
if inner != element.startIndex {
let previousInner = element.index(before: inner)
return Index(outer: index.outer, inner: previousInner)
}
}
let previousOuter = base[..<index.outer].lastIndex(where: { !$0.isEmpty })!
guard
let previousOuter = base[..<index.outer]
.lastIndex(where: { !$0.isEmpty })
else {
fatalError("Can't move before startIndex.")
}
let element = base[previousOuter]
let previousInner = element.index(before: element.endIndex)
return Index(outer: previousOuter, inner: previousInner)
@@ -295,7 +316,7 @@ extension FlattenCollection: BidirectionalCollection
}
extension FlattenCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
where Base: LazySequenceProtocol, Base.Element: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// joined()
+27
View File
@@ -0,0 +1,27 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2021 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
extension Sequence {
/// Groups elements of this sequence into a new dictionary,
/// whose values are arrays of grouped elements,
/// each keyed by the key returned by the given closure.
///
/// - Parameter keyForValue: A closure that returns a key for each element
/// in the sequence.
/// - Returns: A dictionary containing grouped elements of self, keyed by
/// the keys derived by the `keyForValue` closure.
@inlinable
public func grouped<GroupKey>(
by keyForValue: (Element) throws -> GroupKey
) rethrows -> [GroupKey: [Element]] {
try Dictionary(grouping: self, by: keyForValue)
}
}
+17 -14
View File
@@ -15,7 +15,7 @@ public struct IndexedCollection<Base: Collection> {
/// The base collection.
@usableFromInline
internal let base: Base
@inlinable
internal init(base: Base) {
self.base = base
@@ -25,32 +25,32 @@ public struct IndexedCollection<Base: Collection> {
extension IndexedCollection: Collection {
/// The element type for an `IndexedCollection` collection.
public typealias Element = (index: Base.Index, element: Base.Element)
@inlinable
public var startIndex: Base.Index {
base.startIndex
}
@inlinable
public var endIndex: Base.Index {
base.endIndex
}
@inlinable
public subscript(position: Base.Index) -> Element {
(index: position, element: base[position])
}
@inlinable
public func index(after i: Base.Index) -> Base.Index {
base.index(after: i)
}
@inlinable
public func index(_ i: Base.Index, offsetBy distance: Int) -> Base.Index {
base.index(i, offsetBy: distance)
}
@inlinable
public func index(
_ i: Base.Index,
@@ -59,12 +59,12 @@ extension IndexedCollection: Collection {
) -> Base.Index? {
base.index(i, offsetBy: distance, limitedBy: limit)
}
@inlinable
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
@@ -72,8 +72,7 @@ extension IndexedCollection: Collection {
}
extension IndexedCollection: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Base.Index) -> Base.Index {
base.index(before: i)
@@ -81,10 +80,10 @@ extension IndexedCollection: BidirectionalCollection
}
extension IndexedCollection: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension IndexedCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// indexed()
@@ -94,6 +93,10 @@ 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.
///
@@ -105,7 +108,7 @@ 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)
+169 -154
View File
@@ -18,10 +18,10 @@
public struct InterspersedSequence<Base: Sequence> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let separator: Base.Element
@inlinable
internal init(base: Base, separator: Base.Element) {
self.base = base
@@ -38,16 +38,16 @@ extension InterspersedSequence: Sequence {
case element(Base.Element)
case separator
}
@usableFromInline
internal var iterator: Base.Iterator
@usableFromInline
internal let separator: Base.Element
@usableFromInline
internal var state = State.start
@inlinable
internal init(iterator: Base.Iterator, separator: Base.Element) {
self.iterator = iterator
@@ -89,7 +89,7 @@ extension InterspersedSequence: Collection where Base: Collection {
case element(Base.Index)
case separator(next: Base.Index)
}
@usableFromInline
internal let representation: Representation
@@ -101,15 +101,15 @@ extension InterspersedSequence: Collection where Base: Collection {
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
switch (lhs.representation, rhs.representation) {
case let (.element(li), .element(ri)),
let (.separator(next: li), .separator(next: ri)),
let (.element(li), .separator(next: ri)):
case (.element(let li), .element(let ri)),
(.separator(next: let li), .separator(next: let ri)),
(.element(let li), .separator(next: let ri)):
return li < ri
case let (.separator(next: li), .element(ri)):
case (.separator(next: let li), .element(let ri)):
return li <= ri
}
}
@inlinable
internal static func element(_ index: Base.Index) -> Self {
Self(representation: .element(index))
@@ -135,9 +135,9 @@ extension InterspersedSequence: Collection where Base: Collection {
public func index(after i: Index) -> Index {
precondition(i != endIndex, "Can't advance past endIndex")
switch i.representation {
case let .element(index):
case .element(let index):
return .separator(next: base.index(after: index))
case let .separator(next):
case .separator(let next):
return .element(next)
}
}
@@ -149,20 +149,20 @@ extension InterspersedSequence: Collection where Base: Collection {
case .separator: return separator
}
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
switch (start.representation, end.representation) {
case let (.element(element), .separator(next: separator)):
case (.element(let element), .separator(next: let separator)):
return 2 * base.distance(from: element, to: separator) - 1
case let (.separator(next: separator), .element(element)):
case (.separator(next: let separator), .element(let element)):
return 2 * base.distance(from: separator, to: element) + 1
case let (.element(start), .element(end)),
let (.separator(start), .separator(end)):
case (.element(let start), .element(let end)),
(.separator(let start), .separator(let end)):
return 2 * base.distance(from: start, to: end)
}
}
@inlinable
public func index(_ index: Index, offsetBy distance: Int) -> Index {
distance >= 0
@@ -172,84 +172,94 @@ extension InterspersedSequence: Collection where Base: Collection {
@inlinable
public func index(
_ index: Index,
offsetBy distance: Int,
limitedBy limit: Index
) -> Index? {
if distance >= 0 {
return limit >= index
? offsetForward(index, by: distance, limitedBy: limit)
: offsetForward(index, by: distance)
} else {
return limit <= index
? offsetBackward(index, by: -distance, limitedBy: limit)
: offsetBackward(index, by: -distance)
}
_ index: Index,
offsetBy distance: Int,
limitedBy limit: Index
) -> Index? {
if distance >= 0 {
return limit >= index
? offsetForward(index, by: distance, limitedBy: limit)
: offsetForward(index, by: distance)
} else {
return limit <= index
? offsetBackward(index, by: -distance, limitedBy: limit)
: offsetBackward(index, by: -distance)
}
}
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit >= index)
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
case let (.element(index), .element(limit), true),
let (.separator(next: index), .element(limit), false):
switch (
index.representation, limit.representation, distance.isMultiple(of: 2)
) {
case (.element(let index), .element(let limit), true),
(.separator(next: let index), .element(let limit), false):
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
.map { .element($0) }
case let (.element(index), .element(limit), false),
let (.element(index), .separator(next: limit), false),
let (.separator(next: index), .element(limit), true),
let (.separator(next: index), .separator(next: limit), true):
case (.element(let index), .element(let limit), false),
(.element(let index), .separator(next: let limit), false),
(.separator(next: let index), .element(let limit), true),
(.separator(next: let index), .separator(next: let limit), true):
return base.index(index, offsetBy: (distance + 1) / 2, limitedBy: limit)
.map { .separator(next: $0) }
case let (.element(index), .separator(next: limit), true),
let (.separator(next: index), .separator(next: limit), false):
case (.element(let index), .separator(next: let limit), true),
(.separator(next: let index), .separator(next: let limit), false):
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
.flatMap { $0 == limit ? nil : .element($0) }
}
}
@inlinable
internal func offsetBackward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit <= index)
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
case let (.element(index), .element(limit), true),
let (.element(index), .separator(next: limit), true),
let (.separator(next: index), .element(limit), false),
let (.separator(next: index), .separator(next: limit), false):
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
.map { .element($0) }
case let (.element(index), .separator(next: limit), false),
let (.separator(next: index), .separator(next: limit), true):
switch (
index.representation, limit.representation, distance.isMultiple(of: 2)
) {
case (.element(let index), .element(let limit), true),
(.element(let index), .separator(next: let limit), true),
(.separator(next: let index), .element(let limit), false),
(.separator(next: let index), .separator(next: let limit), false):
return base.index(
index, offsetBy: -((distance + 1) / 2), limitedBy: limit
)
.map { .element($0) }
case (.element(let index), .separator(next: let limit), false),
(.separator(next: let index), .separator(next: let limit), true):
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
.map { .separator(next: $0) }
case let (.element(index), .element(limit), false),
let (.separator(next: index), .element(limit), true):
case (.element(let index), .element(let limit), false),
(.separator(next: let index), .element(let limit), true):
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
.flatMap { $0 == limit ? nil : .separator(next: $0) }
}
@@ -257,34 +267,32 @@ extension InterspersedSequence: Collection where Base: Collection {
}
extension InterspersedSequence: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i != startIndex, "Can't move before startIndex")
switch i.representation {
case let .element(index):
case .element(let index):
return .separator(next: index)
case let .separator(next):
case .separator(let next):
return .element(base.index(before: next))
}
}
}
extension InterspersedSequence: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension InterspersedSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension InterspersedSequence: LazyCollectionProtocol
where Base: LazySequenceProtocol & Collection {}
where Base: LazySequenceProtocol & Collection {}
//===----------------------------------------------------------------------===//
// InterspersedMap
//===----------------------------------------------------------------------===//
/// A sequence over the results of applying a closure to the sequence's
/// elements, with a separator that separates each pair of adjacent transformed
/// values.
@@ -292,10 +300,10 @@ extension InterspersedSequence: LazyCollectionProtocol
internal struct InterspersedMapSequence<Base: Sequence, Result> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let transform: (Base.Element) -> Result
@usableFromInline
internal let separator: (Base.Element, Base.Element) -> Result
}
@@ -309,19 +317,19 @@ extension InterspersedMapSequence: Sequence {
case element(Base.Element)
case separator(previous: Base.Element)
}
@usableFromInline
internal var base: Base.Iterator
@usableFromInline
internal let transform: (Base.Element) -> Result
@usableFromInline
internal let separator: (Base.Element, Base.Element) -> Result
@usableFromInline
internal var state = State.start
@inlinable
internal init(
base: Base.Iterator,
@@ -368,61 +376,64 @@ extension InterspersedMapSequence: Collection where Base: Collection {
case element(Base.Index)
case separator(previous: Base.Index, next: Base.Index)
}
@usableFromInline
internal let representation: Representation
internal let base: Representation
@inlinable
internal init(representation: Representation) {
self.representation = representation
self.base = representation
}
@inlinable
internal static func element(_ index: Base.Index) -> Self {
Self(representation: .element(index))
}
@inlinable
internal static func separator(previous: Base.Index, next: Base.Index) -> Self {
internal static func separator(
previous: Base.Index,
next: Base.Index
) -> Self {
Self(representation: .separator(previous: previous, next: next))
}
@inlinable
internal static func == (lhs: Self, rhs: Self) -> Bool {
switch (lhs.representation, rhs.representation) {
case let (.element(lhs), .element(rhs)),
let (.separator(_, next: lhs), .separator(_, next: rhs)):
switch (lhs.base, rhs.base) {
case (.element(let lhs), .element(let rhs)),
(.separator(_, next: let lhs), .separator(_, next: let rhs)):
return lhs == rhs
case (.element, .separator), (.separator, .element):
return false
}
}
@inlinable
internal static func < (lhs: Self, rhs: Self) -> Bool {
switch (lhs.representation, rhs.representation) {
case let (.element(lhs), .element(rhs)),
let (.separator(_, next: lhs), .separator(_, next: rhs)),
let (.element(lhs), .separator(_, next: rhs)),
let (.separator(previous: lhs, _), .element(rhs)):
switch (lhs.base, rhs.base) {
case (.element(let lhs), .element(let rhs)),
(.separator(_, next: let lhs), .separator(_, next: let rhs)),
(.element(let lhs), .separator(_, next: let rhs)),
(.separator(previous: let lhs, _), .element(let rhs)):
return lhs < rhs
}
}
}
@inlinable
internal var startIndex: Index {
base.isEmpty ? endIndex : .element(base.startIndex)
}
@inlinable
internal var endIndex: Index {
.separator(previous: base.endIndex, next: base.endIndex)
}
@inlinable
internal func index(after index: Index) -> Index {
switch index.representation {
switch index.base {
case .element(let index):
let next = base.index(after: index)
return .separator(previous: index, next: next)
@@ -430,39 +441,39 @@ extension InterspersedMapSequence: Collection where Base: Collection {
return .element(next)
}
}
@inlinable
internal subscript(position: Index) -> Result {
switch position.representation {
switch position.base {
case .element(let index):
return transform(base[index])
case let .separator(previous, next):
case .separator(let previous, let next):
return separator(base[previous], base[next])
}
}
@inlinable
internal func distance(from start: Index, to end: Index) -> Int {
switch (start.representation, end.representation) {
case let (.element(lhs), .element(rhs)),
let (.separator(_, next: lhs), .separator(_, next: rhs)):
switch (start.base, end.base) {
case (.element(let lhs), .element(let rhs)),
(.separator(_, next: let lhs), .separator(_, next: let rhs)):
return 2 * base.distance(from: lhs, to: rhs)
case let (.element(lhs), .separator(_, next: rhs)):
case (.element(let lhs), .separator(_, next: let rhs)):
return 2 * base.distance(from: lhs, to: rhs) - 1
case let (.separator(_, next: lhs), .element(rhs)):
case (.separator(_, next: let lhs), .element(let rhs)):
return 2 * base.distance(from: lhs, to: rhs) + 1
}
}
@inlinable
internal func index(_ index: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return index }
return distance > 0
? offsetForward(index, by: distance)
: offsetBackward(index, by: -distance)
}
@inlinable
internal func index(
_ index: Index,
@@ -470,7 +481,7 @@ extension InterspersedMapSequence: Collection where Base: Collection {
limitedBy limit: Index
) -> Index? {
guard distance != 0 else { return index }
if distance > 0 {
return limit >= index
? offsetForward(index, by: distance, limitedBy: limit)
@@ -481,38 +492,40 @@ extension InterspersedMapSequence: Collection where Base: Collection {
: offsetBackward(index, by: -distance)
}
}
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit >= index)
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
case let (.element(index), .element(limit), true),
let (.separator(_, next: index), .element(limit), false):
switch (index.base, limit.base, distance.isMultiple(of: 2)) {
case (.element(let index), .element(let limit), true),
(.separator(_, next: let index), .element(let limit), false):
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
.map { .element($0) }
case let (.element(index), .element(limit), false),
let (.element(index), .separator(_, next: limit), false),
let (.separator(_, next: index), .element(limit), true),
let (.separator(_, next: index), .separator(_, next: limit), true):
case (.element(let index), .element(let limit), false),
(.element(let index), .separator(_, next: let limit), false),
(.separator(_, next: let index), .element(let limit), true),
(.separator(_, next: let index), .separator(_, next: let limit), true):
return base.index(index, offsetBy: (distance - 1) / 2, limitedBy: limit)
.flatMap {
guard $0 != limit else { return nil }
@@ -521,36 +534,40 @@ extension InterspersedMapSequence: Collection where Base: Collection {
? endIndex
: .separator(previous: $0, next: next)
}
case let (.element(index), .separator(_, next: limit), true),
let (.separator(_, next: index), .separator(_, next: limit), false):
case (.element(let index), .separator(_, next: let limit), true),
(.separator(_, next: let index), .separator(_, next: let limit), false):
return base.index(index, offsetBy: distance / 2, limitedBy: limit)
.flatMap { $0 == limit ? nil : .element($0) }
}
}
@inlinable
internal func offsetBackward(
_ index: Index, by distance: Int, limitedBy limit: Index
_ index: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit <= index)
switch (index.representation, limit.representation, distance.isMultiple(of: 2)) {
case let (.element(index), .element(limit), true),
let (.element(index), .separator(_, next: limit), true),
let (.separator(_, next: index), .element(limit), false),
let (.separator(_, next: index), .separator(_, next: limit), false):
return base.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
switch (index.base, limit.base, distance.isMultiple(of: 2)) {
case (.element(let index), .element(let limit), true),
(.element(let index), .separator(_, next: let limit), true),
(.separator(_, next: let index), .element(let limit), false),
(.separator(_, next: let index), .separator(_, next: let limit), false):
return
base
.index(index, offsetBy: -((distance + 1) / 2), limitedBy: limit)
.map { .element($0) }
case let (.element(index), .separator(_, next: limit), false),
let (.separator(_, next: index), .separator(_, next: limit), true):
case (.element(let index), .separator(_, next: let limit), false),
(.separator(_, next: let index), .separator(_, next: let limit), true):
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
.map { .separator(previous: base.index($0, offsetBy: -1), next: $0) }
case let (.element(index), .element(limit), false),
let (.separator(_, next: index), .element(limit), true):
case (.element(let index), .element(let limit), false),
(.separator(_, next: let index), .element(let limit), true):
return base.index(index, offsetBy: -(distance / 2), limitedBy: limit)
.flatMap {
$0 == limit
@@ -562,15 +579,14 @@ extension InterspersedMapSequence: Collection where Base: Collection {
}
extension InterspersedMapSequence: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
internal func index(before index: Index) -> Index {
switch index.representation {
switch index.base {
case .element(let index):
let previous = base.index(before: index)
return .separator(previous: previous, next: index)
case let .separator(previous, next):
case .separator(let previous, let next):
let index = next == base.endIndex ? base.index(before: next) : previous
return .element(index)
}
@@ -578,11 +594,10 @@ extension InterspersedMapSequence: BidirectionalCollection
}
extension InterspersedMapSequence.Index: Hashable
where Base.Index: Hashable
{
where Base.Index: Hashable {
@inlinable
internal func hash(into hasher: inout Hasher) {
switch representation {
switch base {
case .element(let base):
hasher.combine(false)
hasher.combine(base)
@@ -595,7 +610,7 @@ extension InterspersedMapSequence.Index: Hashable
extension InterspersedMapSequence: LazySequenceProtocol {}
extension InterspersedMapSequence: LazyCollectionProtocol
where Base: Collection {}
where Base: Collection {}
//===----------------------------------------------------------------------===//
// interspersed(with:)
+84 -84
View File
@@ -16,15 +16,17 @@
/// A sequence that presents the elements of a base sequence of sequences
/// concatenated using a given separator.
public struct JoinedBySequence<Base: Sequence, Separator: Sequence>
where Base.Element: Sequence, Base.Element.Element == Separator.Element
{
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<
InterspersedSequence<
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>
>
>
@usableFromInline
internal let inner: Inner
@inlinable
internal init(base: Base, separator: Separator) {
self.inner = base.lazy
@@ -38,18 +40,18 @@ extension JoinedBySequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal var inner: Inner.Iterator
@inlinable
internal init(inner: Inner.Iterator) {
self.inner = inner
}
@inlinable
public mutating func next() -> Base.Element.Element? {
inner.next()
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(inner: inner.makeIterator())
@@ -57,7 +59,7 @@ extension JoinedBySequence: Sequence {
}
extension JoinedBySequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// JoinedByClosureSequence
@@ -67,15 +69,17 @@ extension JoinedBySequence: LazySequenceProtocol
/// concatenated using a given separator that depends on the sequences right
/// before and after it.
public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
where Base.Element: Sequence, Base.Element.Element == Separator.Element
{
where Base.Element: Sequence, Base.Element.Element == Separator.Element {
@usableFromInline
internal typealias Inner = FlattenSequence<InterspersedMapSequence<
Base, EitherSequence<Base.Element, Separator>>>
internal typealias Inner = FlattenSequence<
InterspersedMapSequence<
Base, EitherSequence<Base.Element, Separator>
>
>
@usableFromInline
internal let inner: Inner
@inlinable
internal init(
base: Base,
@@ -84,7 +88,8 @@ public struct JoinedByClosureSequence<Base: Sequence, Separator: Sequence>
self.inner = base.lazy
.interspersedMap(
EitherSequence.left,
with: { EitherSequence.right(separator($0, $1)) })
with: { EitherSequence.right(separator($0, $1)) }
)
.joined()
}
}
@@ -93,18 +98,18 @@ extension JoinedByClosureSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal var inner: Inner.Iterator
@inlinable
internal init(inner: Inner.Iterator) {
self.inner = inner
}
@inlinable
public mutating func next() -> Base.Element.Element? {
inner.next()
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(inner: inner.makeIterator())
@@ -120,15 +125,17 @@ extension JoinedByClosureSequence: LazySequenceProtocol {}
/// A collection that presents the elements of a base collection of collections
/// concatenated using a given separator.
public struct JoinedByCollection<Base: Collection, Separator: Collection>
where Base.Element: Collection, Base.Element.Element == Separator.Element
{
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<
InterspersedSequence<
LazyMapSequence<Base, EitherSequence<Base.Element, Separator>>
>
>
@usableFromInline
internal let inner: Inner
@inlinable
internal init(base: Base, separator: Separator) {
self.inner = base.lazy
@@ -142,48 +149,48 @@ extension JoinedByCollection: Collection {
public struct Index: Comparable {
@usableFromInline
internal let inner: Inner.Index
@inlinable
internal init(_ inner: Inner.Index) {
self.inner = inner
}
@inlinable
public static func == (lhs: Self, rhs: Self) -> Bool {
lhs.inner == rhs.inner
}
@inlinable
public static func < (lhs: Self, rhs: Self) -> Bool {
lhs.inner < rhs.inner
}
}
@inlinable
public var startIndex: Index {
Index(inner.startIndex)
}
@inlinable
public var endIndex: Index {
Index(inner.endIndex)
}
@inlinable
public func index(after index: Index) -> Index {
Index(inner.index(after: index.inner))
}
@inlinable
public subscript(position: Index) -> Base.Element.Element {
inner[position.inner]
}
@inlinable
public func index(_ index: Index, offsetBy distance: Int) -> Index {
Index(inner.index(index.inner, offsetBy: distance))
}
@inlinable
public func index(
_ index: Index,
@@ -193,7 +200,7 @@ extension JoinedByCollection: Collection {
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
.map(Index.init)
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
inner.distance(from: start.inner, to: end.inner)
@@ -201,9 +208,10 @@ extension JoinedByCollection: Collection {
}
extension JoinedByCollection: BidirectionalCollection
where Base: BidirectionalCollection,
Base.Element: BidirectionalCollection,
Separator: BidirectionalCollection
where
Base: BidirectionalCollection,
Base.Element: BidirectionalCollection,
Separator: BidirectionalCollection
{
@inlinable
public func index(before index: Index) -> Index {
@@ -212,7 +220,7 @@ extension JoinedByCollection: BidirectionalCollection
}
extension JoinedByCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// JoinedByClosureCollection
@@ -222,15 +230,17 @@ extension JoinedByCollection: LazySequenceProtocol, LazyCollectionProtocol
/// concatenated using a given separator that depends on the collections right
/// before and after it.
public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
where Base.Element: Collection, Base.Element.Element == Separator.Element
{
where Base.Element: Collection, Base.Element.Element == Separator.Element {
@usableFromInline
internal typealias Inner = FlattenCollection<InterspersedMapSequence<
Base, EitherSequence<Base.Element, Separator>>>
internal typealias Inner = FlattenCollection<
InterspersedMapSequence<
Base, EitherSequence<Base.Element, Separator>
>
>
@usableFromInline
internal let inner: Inner
@inlinable
internal init(
base: Base,
@@ -239,7 +249,8 @@ public struct JoinedByClosureCollection<Base: Collection, Separator: Collection>
self.inner = base.lazy
.interspersedMap(
EitherSequence.left,
with: { EitherSequence.right(separator($0, $1)) })
with: { EitherSequence.right(separator($0, $1)) }
)
.joined()
}
}
@@ -248,48 +259,48 @@ extension JoinedByClosureCollection: Collection {
public struct Index: Comparable {
@usableFromInline
internal let inner: Inner.Index
@inlinable
internal init(_ inner: Inner.Index) {
self.inner = inner
}
@inlinable
public static func == (lhs: Self, rhs: Self) -> Bool {
lhs.inner == rhs.inner
}
@inlinable
public static func < (lhs: Self, rhs: Self) -> Bool {
lhs.inner < rhs.inner
}
}
@inlinable
public var startIndex: Index {
Index(inner.startIndex)
}
@inlinable
public var endIndex: Index {
Index(inner.endIndex)
}
@inlinable
public func index(after index: Index) -> Index {
Index(inner.index(after: index.inner))
}
@inlinable
public subscript(position: Index) -> Base.Element.Element {
inner[position.inner]
}
@inlinable
public func index(_ index: Index, offsetBy distance: Int) -> Index {
Index(inner.index(index.inner, offsetBy: distance))
}
@inlinable
public func index(
_ index: Index,
@@ -299,7 +310,7 @@ extension JoinedByClosureCollection: Collection {
inner.index(index.inner, offsetBy: distance, limitedBy: limit.inner)
.map(Index.init)
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
inner.distance(from: start.inner, to: end.inner)
@@ -307,9 +318,10 @@ extension JoinedByClosureCollection: Collection {
}
extension JoinedByClosureCollection: BidirectionalCollection
where Base: BidirectionalCollection,
Base.Element: BidirectionalCollection,
Separator: BidirectionalCollection
where
Base: BidirectionalCollection,
Base.Element: BidirectionalCollection,
Separator: BidirectionalCollection
{
@inlinable
public func index(before index: Index) -> Index {
@@ -337,7 +349,7 @@ extension Sequence where Element: Sequence {
{
joined(by: CollectionOfOne(separator))
}
/// Returns the concatenation of the elements in this sequence of sequences,
/// inserting the given separator between each sequence.
///
@@ -349,30 +361,29 @@ extension Sequence where Element: Sequence {
public func joined<Separator>(
by separator: Separator
) -> JoinedBySequence<Self, Separator>
where Separator: Collection, Separator.Element == Element.Element
{
where Separator: Collection, Separator.Element == Element.Element {
JoinedBySequence(base: self, separator: separator)
}
@inlinable
internal func _joined(
by update: (inout [Element.Element], Element, Element) throws -> Void
) rethrows -> [Element.Element] {
var iterator = makeIterator()
guard let first = iterator.next() else { return [] }
var result = Array(first)
var previous = first
while let next = iterator.next() {
try update(&result, previous, next)
result.append(contentsOf: next)
previous = next
}
return result
}
/// Returns the concatenation of the elements in this sequence of sequences,
/// inserting the separator produced by the closure between each sequence.
///
@@ -386,7 +397,7 @@ extension Sequence where Element: Sequence {
) rethrows -> [Element.Element] {
try _joined(by: { $0.append(try separator($1, $2)) })
}
/// Returns the concatenation of the elements in this sequence of sequences,
/// inserting the separator produced by the closure between each sequence.
///
@@ -398,8 +409,7 @@ extension Sequence where Element: Sequence {
public func joined<Separator>(
by separator: (Element, Element) throws -> Separator
) rethrows -> [Element.Element]
where Separator: Sequence, Separator.Element == Element.Element
{
where Separator: Sequence, Separator.Element == Element.Element {
try _joined(by: { $0.append(contentsOf: try separator($1, $2)) })
}
}
@@ -417,7 +427,7 @@ extension LazySequenceProtocol where Element: Sequence {
) -> JoinedByClosureSequence<Elements, CollectionOfOne<Element.Element>> {
joined(by: { CollectionOfOne(separator($0, $1)) })
}
/// Returns the concatenation of the elements in this sequence of sequences,
/// inserting the separator produced by the closure between each sequence.
@inlinable
@@ -446,7 +456,7 @@ extension Collection where Element: Collection {
{
joined(by: CollectionOfOne(separator))
}
/// Returns the concatenation of the elements in this collection of
/// collections, inserting the given separator between each collection.
///
@@ -476,7 +486,7 @@ extension LazySequenceProtocol where Elements: Collection, Element: Collection {
) -> JoinedByClosureCollection<Elements, CollectionOfOne<Element.Element>> {
joined(by: { CollectionOfOne(separator($0, $1)) })
}
/// Returns the concatenation of the elements in this collection of
/// collections, inserting the separator produced by the closure between each
/// sequence.
@@ -487,13 +497,3 @@ extension LazySequenceProtocol where Elements: Collection, Element: Collection {
JoinedByClosureCollection(base: elements, separator: separator)
}
}
extension Sequence where Element: Collection, Element.SubSequence == Substring {
public func joined(separator: Element, prefix: Element, suffix: Element) -> String {
var result = ""
result.append(contentsOf: prefix[...])
result.append(contentsOf: self.joined(separator: separator[...]))
result.append(contentsOf: suffix[...])
return result
}
}
+76
View File
@@ -0,0 +1,76 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
extension Sequence {
/// Creates a new dictionary keyed by the result of the given closure, using
/// the latest element for any duplicate keys.
///
/// If the key derived for a new element collides with an existing key from a
/// previous element, the latest value will be kept.
///
/// - Parameter keyForValue: A closure that returns a key for each element in
/// `self`.
/// - Returns: A dictionary with key-value pairs generated by calling
/// `keyForValue` for each element in this sequence. If `keyForValue`
/// returns the same key for two or more elements, the returned dictionary
/// uses the last value for that key.
@inlinable
public func keyed<Key>(
by keyForValue: (Element) throws -> Key
) rethrows -> [Key: Element] {
try self.reduce(into: [:]) { result, element in
try result[keyForValue(element)] = element
}
}
/// Creates a new dictionary keyed by the result of the first closure, using
/// the second closure to resolve the ambiguity for any duplicate keys.
///
/// As the dictionary is built, the initializer calls the `resolve` closure
/// with the current and new values for any duplicate keys. Pass a closure as
/// `resolve` that returns the value to use for that key in the resulting
/// dictionary. The closure can choose between the two values, combine them to
/// produce a new value, or even throw an error.
///
/// - Parameters:
/// - keyForValue: A closure that returns a key for each element in `self`.
/// - resolve: A closure that is called with the values for any duplicate
/// keys that are encountered. The closure returns the desired value for
/// the final dictionary.
/// - Returns: A dictionary with key-value pairs generated by calling
/// `keyForValue` for each element in this sequence. If `keyForValue`
/// returns the same key for two or more elements, the result of the
/// `resolve` closure is used as the value for that key.
@inlinable
public func keyed<Key>(
by keyForValue: (Element) throws -> Key,
resolvingConflictsWith resolve: (Key, Element, Element) throws -> Element
) rethrows -> [Key: Element] {
var result: [Key: Element] = [:]
for element in self {
let key = try keyForValue(element)
if let oldValue = result.updateValue(element, forKey: key) {
let valueToKeep = try resolve(key, oldValue, element)
// This causes a second look-up for the same key. The standard library can avoid that
// by calling `mutatingFind` to get access to the bucket where the value will end up,
// and updating in place.
// Swift Algorithms doesn't have access to that API, so we make do.
// When this gets merged into the standard library, we should optimize this.
result[key] = valueToKeep
}
}
return result
}
}
+36 -28
View File
@@ -10,24 +10,24 @@
//===----------------------------------------------------------------------===//
extension Sequence {
/// Implementation for min(count:areInIncreasingOrder:)
// Implementation for min(count:areInIncreasingOrder:)
@inlinable
internal func _minImplementation(
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
var iterator = makeIterator()
var result: [Element] = []
result.reserveCapacity(count)
while result.count < count, let e = iterator.next() {
result.append(e)
}
try result.sort(by: areInIncreasingOrder)
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 }
// To be part of `result`, `e` must be strictly less than `result[count - 1]`.
guard try areInIncreasingOrder(e, result[count - 1]) else { continue }
result.removeLast()
let insertionIndex =
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
@@ -36,25 +36,25 @@ extension Sequence {
return result
}
/// Implementation for max(count:areInIncreasingOrder:)
// Implementation for max(count:areInIncreasingOrder:)
@inlinable
internal func _maxImplementation(
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
var iterator = makeIterator()
var result: [Element] = []
result.reserveCapacity(count)
while result.count < count, let e = iterator.next() {
result.append(e)
}
try result.sort(by: areInIncreasingOrder)
while let e = iterator.next() {
// To be part of `result`, `e` must be greater/equal to `result.first`.
guard try !areInIncreasingOrder(e, result.first!) else { continue }
// To be part of `result`, `e` must be greater/equal to `result[0]`.
guard try !areInIncreasingOrder(e, result[0]) else { continue }
let insertionIndex =
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
@@ -69,10 +69,10 @@ extension Sequence {
}
result[insertionIndex - 1] = e
}
return result
}
/// Returns the smallest elements of this sequence, as sorted by the given
/// predicate.
///
@@ -105,7 +105,9 @@ extension Sequence {
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
precondition(count >= 0, """
precondition(
count >= 0,
"""
Cannot find a minimum with a negative count of elements!
"""
)
@@ -150,7 +152,9 @@ extension Sequence {
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
precondition(count >= 0, """
precondition(
count >= 0,
"""
Cannot find a maximum with a negative count of elements!
"""
)
@@ -251,25 +255,27 @@ extension Collection {
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
precondition(count >= 0, """
precondition(
count >= 0,
"""
Cannot find a minimum with a negative count of elements!
"""
)
// Do nothing if we're prefixing nothing.
guard count > 0 else {
return []
}
// Make sure we are within bounds.
let prefixCount = Swift.min(count, self.count)
// Do nothing if we're prefixing nothing.
guard prefixCount > 0 else {
return []
}
// If we're attempting to prefix more than 10% of the collection, it's
// faster to sort everything.
guard prefixCount < (self.count / 10) else {
return Array(try sorted(by: areInIncreasingOrder).prefix(prefixCount))
}
return try _minImplementation(count: count, sortedBy: areInIncreasingOrder)
}
@@ -305,19 +311,21 @@ extension Collection {
count: Int,
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
) rethrows -> [Element] {
precondition(count >= 0, """
precondition(
count >= 0,
"""
Cannot find a maximum with a negative count of elements!
"""
)
// Do nothing if we're suffixing nothing.
guard count > 0 else {
return []
}
// Make sure we are within bounds.
let suffixCount = Swift.min(count, self.count)
// Do nothing if we're suffixing nothing.
guard suffixCount > 0 else {
return []
}
// If we're attempting to prefix more than 10% of the collection, it's
// faster to sort everything.
guard suffixCount < (self.count / 10) else {
+94 -46
View File
@@ -33,8 +33,9 @@ extension MutableCollection {
? subrange.lowerBound
: subrange.upperBound
}
let h = n / 2, i = index(subrange.lowerBound, offsetBy: h)
let h = n / 2
let i = index(subrange.lowerBound, offsetBy: h)
let j = try stablePartition(
count: h,
subrange: subrange.lowerBound..<i,
@@ -45,7 +46,7 @@ extension MutableCollection {
by: belongsInSecondPartition)
return rotate(subrange: j..<k, toStartAt: i)
}
/// Moves all elements satisfying the given predicate into a suffix of the
/// given range, preserving the relative order of the elements in both
/// partitions, and returns the start of the resulting suffix.
@@ -55,19 +56,23 @@ extension MutableCollection {
/// - belongsInSecondPartition: A predicate used to partition the
/// collection. All elements satisfying this predicate are ordered after
/// all elements not satisfying it.
/// - Returns: The pivot index `p`, which is the index of the first element
/// in the reordered collection that matches `belongsInSecondPartition`.
/// If no elements in the collection match `belongsInSecondPartition`, the
/// returned index is equal to the collection's `endIndex`.
///
/// - Complexity: O(*n* log *n*), where *n* is the length of this collection.
@inlinable
public mutating func stablePartition(
subrange: Range<Index>,
by belongsInSecondPartition: (Element) throws-> Bool
by belongsInSecondPartition: (Element) throws -> Bool
) rethrows -> Index {
try stablePartition(
count: distance(from: subrange.lowerBound, to: subrange.upperBound),
subrange: subrange,
by: belongsInSecondPartition)
}
/// Moves all elements satisfying the given predicate into a suffix of this
/// collection, preserving the relative order of the elements in both
/// partitions, and returns the start of the resulting suffix.
@@ -75,11 +80,15 @@ extension MutableCollection {
/// - Parameter belongsInSecondPartition: A predicate used to partition the
/// collection. All elements satisfying this predicate are ordered after
/// all elements not satisfying it.
/// - Returns: The pivot index `p`, which is the index of the first element
/// in the reordered collection that matches `belongsInSecondPartition`.
/// If no elements in the collection match `belongsInSecondPartition`, the
/// returned index is equal to the collection's `endIndex`.
///
/// - Complexity: O(*n* log *n*), where *n* is the length of this collection.
@inlinable
public mutating func stablePartition(
by belongsInSecondPartition: (Element) throws-> Bool
by belongsInSecondPartition: (Element) throws -> Bool
) rethrows -> Index {
try stablePartition(
subrange: startIndex..<endIndex,
@@ -92,9 +101,25 @@ extension MutableCollection {
//===----------------------------------------------------------------------===//
extension MutableCollection {
/// Moves all elements satisfying `isSuffixElement` into a suffix of the
/// Moves all elements satisfying the given closure into a suffix of the
/// collection, returning the start position of the resulting suffix.
///
/// After partitioning a collection, there is a pivot index `p` where no
/// element before `p` satisfies the `belongsInSecondPartition` predicate and
/// every element at or after `p` satisfies `belongsInSecondPartition`. This
/// operation isn't guaranteed to be stable, so the relative ordering of
/// elements within the partitions might change.
///
/// - Parameters:
/// - subrange: The range of elements within this collection to partition.
/// - belongsInSecondPartition: A predicate used to partition the
/// collection. All elements satisfying this predicate are ordered after
/// all elements not satisfying it.
/// - Returns: The pivot index `p`, which is the index of the first element
/// in the reordered collection that matches `belongsInSecondPartition`.
/// If no elements in the collection match `belongsInSecondPartition`, the
/// returned index is equal to the collection's `endIndex`.
///
/// - Complexity: O(*n*) where n is the length of the collection.
@inlinable
public mutating func partition(
@@ -104,8 +129,8 @@ extension MutableCollection {
// This version of `partition(subrange:)` is half stable; the elements in
// the first partition retain their original relative order.
guard var i = try self[subrange].firstIndex(where: belongsInSecondPartition)
else { return subrange.upperBound }
else { return subrange.upperBound }
var j = index(after: i)
while j != subrange.upperBound {
if try !belongsInSecondPartition(self[j]) {
@@ -114,15 +139,31 @@ extension MutableCollection {
}
formIndex(after: &j)
}
return i
}
}
extension MutableCollection where Self: BidirectionalCollection {
/// Moves all elements satisfying `isSuffixElement` into a suffix of the
/// Moves all elements satisfying the given closure into a suffix of the
/// collection, returning the start position of the resulting suffix.
///
/// After partitioning a collection, there is a pivot index `p` where no
/// element before `p` satisfies the `belongsInSecondPartition` predicate and
/// every element at or after `p` satisfies `belongsInSecondPartition`. This
/// operation isn't guaranteed to be stable, so the relative ordering of
/// elements within the partitions might change.
///
/// - Parameters:
/// - subrange: The range of elements within this collection to partition.
/// - belongsInSecondPartition: A predicate used to partition the
/// collection. All elements satisfying this predicate are ordered after
/// all elements not satisfying it.
/// - Returns: The pivot index `p`, which is the index of the first element
/// in the reordered collection that matches `belongsInSecondPartition`.
/// If no elements in the collection match `belongsInSecondPartition`, the
/// returned index is equal to the collection's `endIndex`.
///
/// - Complexity: O(*n*) where n is the length of the collection.
@inlinable
public mutating func partition(
@@ -190,7 +231,7 @@ extension Collection {
) rethrows -> Index {
var n = count
var l = startIndex
while n > 0 {
let half = n / 2
let mid = index(l, offsetBy: half)
@@ -210,8 +251,8 @@ extension Collection {
//===----------------------------------------------------------------------===//
extension Sequence {
/// Returns two arrays containing, in order, the elements of the sequence that
/// do and don’t satisfy the given predicate.
/// Returns two arrays containing the elements of the sequence that
/// don’t and do satisfy the given predicate, respectively.
///
/// In this example, `partitioned(by:)` is used to separate the input based on
/// whether a name is shorter than five characters:
@@ -224,22 +265,23 @@ extension Sequence {
/// // 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.
///
/// 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.
/// first array contains all the elements that `predicate` didn’t allow, and
/// the second array contains all the elements that `predicate` allowed. The
/// order of the elements in the arrays matches the order of the elements in
/// the original sequence.
///
/// - 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]()
var lhs: [Element] = []
var rhs: [Element] = []
for element in self {
if try predicate(element) {
rhs.append(element)
@@ -247,14 +289,14 @@ extension Sequence {
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.
/// Returns two arrays containing the elements of the collection that
/// don’t and do satisfy the given predicate, respectively.
///
/// In this example, `partitioned(by:)` is used to separate the input based on
/// whether a name is shorter than five characters.
@@ -267,13 +309,14 @@ extension Collection {
/// // 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.
///
/// 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.
/// first array contains all the elements that `predicate` didn’t allow, and
/// the second array contains all the elements that `predicate` allowed. The
/// order of the elements in the arrays matches the order of the elements in
/// the original collection.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
@@ -283,23 +326,26 @@ extension Collection {
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!
// swift-format-ignore: NeverForceUnwrap
// Non-empty check above.
let bufferStart = buffer.baseAddress!
var lhs = bufferStart
var rhs = lhs + buffer.count
do {
for element in self {
@@ -311,26 +357,28 @@ extension Collection {
lhs += 1
}
}
precondition(lhs == rhs, """
precondition(
lhs == rhs,
"""
Collection's `count` differed from the number of elements iterated.
"""
)
let rhsIndex = rhs - buffer.baseAddress!
let rhsIndex = rhs - bufferStart
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)
let lhsCount = lhs - bufferStart
let rhsCount = (bufferStart + buffer.count) - rhs
bufferStart.deinitialize(count: lhsCount)
rhs.deinitialize(count: rhsCount)
throw error
}
})
let lhs = elements[..<midPoint]
let rhs = elements[midPoint...]
return (
+81 -65
View File
@@ -14,8 +14,7 @@
//===----------------------------------------------------------------------===//
extension MutableCollection
where Self: BidirectionalCollection, Element: Comparable
{
where Self: BidirectionalCollection, Element: Comparable {
/// Permutes this collection's elements through all the lexical orderings.
///
/// Call `nextPermutation()` repeatedly starting with the collection in sorted
@@ -34,26 +33,27 @@ extension MutableCollection
guard !isEmpty else { return false }
var i = index(before: endIndex)
if i == startIndex { return false }
let upperBound = upperBound ?? endIndex
while true {
let ip1 = i
formIndex(before: &i)
// Find the last ascending pair (ie. ..., a, b, ... where a < b)
if self[i] < self[ip1] {
// Find the last element greater than self[i]
// swift-format-ignore: NeverForceUnwrap
// This is _always_ at most `ip1` due to if statement above
let j = lastIndex(where: { self[i] < $0 })!
// At this point we have something like this:
// 0, 1, 4, 3, 2
// ^ ^
// i j
swapAt(i, j)
self.reverse(subrange: ip1 ..< endIndex)
self.reverse(subrange: ip1..<endIndex)
// Only return if we've made a change within ..<upperBound region
if i < upperBound {
return true
@@ -62,7 +62,7 @@ extension MutableCollection
continue
}
}
if i == startIndex {
self.reverse()
return false
@@ -80,17 +80,17 @@ public struct PermutationsSequence<Base: Collection> {
/// The base collection to iterate over for permutations.
@usableFromInline
internal let base: Base
@usableFromInline
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`.
///
@@ -102,13 +102,13 @@ public struct PermutationsSequence<Base: Collection> {
internal init(_ base: Base, k: Int? = nil) {
let kRange: ClosedRange<Int>?
if let countToChoose = k {
kRange = countToChoose ... countToChoose
kRange = countToChoose...countToChoose
} else {
kRange = nil
}
self.init(base, kRange: kRange)
}
/// Initializes a `PermutationsSequence` for all combinations of `base` of
/// sizes within a given range.
///
@@ -118,17 +118,18 @@ public struct PermutationsSequence<Base: Collection> {
/// iterate over all permutations of the same size as the base collection.
@inlinable
internal init<R: RangeExpression>(
_ base: Base, kRange: R?
_ base: Base,
kRange: R?
) where R.Bound == Int {
self.base = base
let baseCount = base.count
self.baseCount = baseCount
let upperBound = baseCount + 1
self.kRange = kRange?.relative(to: 0 ..< .max)
.clamped(to: 0 ..< upperBound) ??
baseCount ..< upperBound
self.kRange =
kRange?.relative(to: 0 ..< .max)
.clamped(to: 0..<upperBound) ?? baseCount..<upperBound
}
/// The total number of permutations.
@inlinable
public var count: Int {
@@ -143,26 +144,26 @@ extension PermutationsSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal let base: Base
@usableFromInline
internal let baseCount: Int
/// The current range of accepted sizes of permutations.
/// - Note: The range is contracted until empty while iterating over
/// permutations of different sizes. When the range is empty, iteration is
/// finished.
@usableFromInline
internal var kRange: Range<Int>
/// Whether or not iteration is finished (`kRange` is empty)
/// Whether or not iteration is finished (`kRange` is empty).
@inlinable
internal var isFinished: Bool {
return kRange.isEmpty
kRange.isEmpty
}
@usableFromInline
internal var indexes: [Base.Index]
@inlinable
internal init(_ permutations: PermutationsSequence) {
self.base = permutations.base
@@ -170,7 +171,7 @@ extension PermutationsSequence: Sequence {
self.kRange = permutations.kRange
self.indexes = Array(permutations.base.indices)
}
/// Advances the `indexes` array such that the first `countToChoose`
/// elements contain the next lexicographic ordering of elements.
///
@@ -186,44 +187,49 @@ extension PermutationsSequence: Sequence {
internal mutating func nextState() -> Bool {
let countToChoose = self.kRange.lowerBound
let edge = countToChoose - 1
// Find first index greater than the one at `edge`.
if let i = indexes[countToChoose...].firstIndex(where: { indexes[edge] < $0 }) {
if let i = indexes[countToChoose...]
.firstIndex(where: { indexes[edge] < $0 })
{
indexes.swapAt(edge, i)
} else {
indexes.reverse(subrange: countToChoose ..< indexes.endIndex)
indexes.reverse(subrange: countToChoose..<indexes.endIndex)
// Find last increasing pair below `edge`.
// TODO: This could be indexes[..<edge].adjacentPairs().lastIndex(where: ...)
var lastAscent = edge - 1
while (lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1]) {
while lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1]
{
lastAscent -= 1
}
if lastAscent < 0 {
return false
}
// Find rightmost index less than that at `lastAscent`.
if let i = indexes[lastAscent...].lastIndex(where: { indexes[lastAscent] < $0 }) {
if let i = indexes[lastAscent...]
.lastIndex(where: { indexes[lastAscent] < $0 })
{
indexes.swapAt(lastAscent, i)
}
indexes.reverse(subrange: (lastAscent + 1) ..< indexes.endIndex)
indexes.reverse(subrange: (lastAscent + 1)..<indexes.endIndex)
}
return true
}
@inlinable
public mutating func next() -> [Base.Element]? {
guard !isFinished else { return nil }
/// Advances `kRange` by incrementing its `lowerBound` until the range is
/// empty, when iteration is finished.
func advanceKRange() {
kRange.removeFirst()
indexes = Array(base.indices)
}
let countToChoose = self.kRange.lowerBound
if countToChoose == 0 {
defer {
@@ -231,7 +237,7 @@ extension PermutationsSequence: Sequence {
}
return []
}
let permutesFullCollection = (countToChoose == baseCount)
if permutesFullCollection {
// If we're permuting the full collection, each iteration is just a
@@ -256,7 +262,7 @@ extension PermutationsSequence: Sequence {
}
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(self)
@@ -264,7 +270,7 @@ extension PermutationsSequence: Sequence {
}
extension PermutationsSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// permutations(ofCount:)
@@ -323,6 +329,8 @@ extension Collection {
/// clamped to the number of elements in this collection. Passing a range
/// covering sizes greater than the number of elements in this collection
/// results in an empty sequence.
/// - Returns: A sequence of the permutations of this collection's elements,
/// for all sizes in `kRange`, from smallest to largest.
///
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
/// is the number of elements in the base collection, since
@@ -333,7 +341,7 @@ extension Collection {
) -> PermutationsSequence<Self> where R.Bound == Int {
PermutationsSequence(self, kRange: kRange)
}
/// Returns a collection of the permutations of this collection of the
/// specified length.
///
@@ -379,12 +387,15 @@ extension Collection {
/// If `k` is `nil`, the resulting sequence represents permutations of this
/// entire collection. If `k` is greater than the number of elements in
/// this collection, the resulting sequence is empty.
/// - Returns: A sequence of the permutations of this collection's elements.
///
/// - 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.
@inlinable
public func permutations(ofCount k: Int? = nil) -> PermutationsSequence<Self> {
public func permutations(
ofCount k: Int? = nil
) -> PermutationsSequence<Self> {
precondition(
k ?? 0 >= 0,
"Can't have permutations with a negative number of elements.")
@@ -405,10 +416,10 @@ public struct UniquePermutationsSequence<Base: Collection> {
/// The base collection to iterate over for permutations.
@usableFromInline
internal let base: Base
@usableFromInline
internal var indexes: [Base.Index]
@usableFromInline
internal let kRange: Range<Int>
}
@@ -418,30 +429,31 @@ extension UniquePermutationsSequence where Base.Element: Hashable {
internal static func _indexes(_ base: Base) -> [Base.Index] {
let firstIndexesAndCountsByElement = Dictionary(
base.indices.lazy.map { (base[$0], ($0, 1)) },
uniquingKeysWith: { indexAndCount, _ in (indexAndCount.0, indexAndCount.1 + 1) })
uniquingKeysWith: { indexAndCount, _ in
(indexAndCount.0, indexAndCount.1 + 1)
})
return firstIndexesAndCountsByElement
.values.sorted(by: { $0.0 < $1.0 })
.flatMap { index, count in repeatElement(index, count: count) }
}
@inlinable
internal init(_ elements: Base) {
self.indexes = Self._indexes(elements)
self.base = elements
self.kRange = self.indexes.count ..< (self.indexes.count + 1)
self.kRange = self.indexes.count..<(self.indexes.count + 1)
}
@inlinable
internal init<R: RangeExpression>(_ base: Base, _ range: R)
where R.Bound == Int
{
where R.Bound == Int {
self.indexes = Self._indexes(base)
self.base = base
let upperBound = self.indexes.count + 1
self.kRange = range.relative(to: 0 ..< .max)
.clamped(to: 0 ..< upperBound)
.clamped(to: 0..<upperBound)
}
}
@@ -450,10 +462,10 @@ extension UniquePermutationsSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal let base: Base
@usableFromInline
internal var indexes: [Base.Index]
@usableFromInline
internal var lengths: Range<Int>
@@ -461,19 +473,20 @@ extension UniquePermutationsSequence: Sequence {
internal var initial = true
@inlinable
internal init(_ elements: Base, indexes: [Base.Index], lengths: Range<Int>) {
internal init(_ elements: Base, indexes: [Base.Index], lengths: Range<Int>)
{
self.base = elements
self.indexes = indexes
self.lengths = lengths
}
@inlinable
public mutating func next() -> [Base.Element]? {
// In the end case, `lengths` is an empty range.
if lengths.isEmpty {
return nil
}
// The first iteration must produce the original sorted array, before any
// permutations. We skip the permutation the first time so that we can
// always mutate the array _before_ returning a slice, which avoids
@@ -490,11 +503,11 @@ extension UniquePermutationsSequence: Sequence {
return nil
}
}
return indexes[..<lengths.lowerBound].map { base[$0] }
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(base, indexes: indexes, lengths: kRange)
@@ -502,7 +515,7 @@ extension UniquePermutationsSequence: Sequence {
}
extension UniquePermutationsSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension Collection where Element: Hashable {
/// Returns a sequence of the unique permutations of this sequence of the
@@ -540,6 +553,8 @@ extension Collection where Element: Hashable {
/// If `k` is `nil`, the resulting sequence represents permutations of this
/// entire collection. If `k` is greater than the number of elements in
/// this collection, the resulting sequence is empty.
/// - Returns: A sequence of the unique permutations of this collection's
/// elements.
///
/// - Complexity: O(*n*), where *n* is the number of elements in this
/// collection.
@@ -547,11 +562,10 @@ extension Collection where Element: Hashable {
public func uniquePermutations(ofCount k: Int? = nil)
-> UniquePermutationsSequence<Self>
{
if let k = k {
return UniquePermutationsSequence(self, k ..< (k + 1))
} else {
guard let k = k else {
return UniquePermutationsSequence(self)
}
return UniquePermutationsSequence(self, k..<(k + 1))
}
/// Returns a collection of the unique permutations of this sequence with
@@ -580,6 +594,8 @@ extension Collection where Element: Hashable {
/// clamped to the number of elements in this collection. Passing a range
/// covering sizes greater than the number of elements in this collection
/// results in an empty sequence.
/// - Returns: A sequence of the unique permutations of this collection's
/// elements, for all sizes in `kRange`, from smallest to largest.
///
/// - Complexity: O(*n*), where *n* is the number of elements in this
/// collection.
+140 -102
View File
@@ -14,11 +14,11 @@ public struct Product2Sequence<Base1: Sequence, Base2: Collection> {
/// The outer sequence in the product.
@usableFromInline
internal let base1: Base1
/// The inner sequence in the product.
@usableFromInline
internal let base2: Base2
@inlinable
internal init(_ base1: Base1, _ base2: Base2) {
self.base1 = base1
@@ -28,7 +28,7 @@ public struct Product2Sequence<Base1: Sequence, Base2: Collection> {
extension Product2Sequence: Sequence {
public typealias Element = (Base1.Element, Base2.Element)
/// The iterator for a `Product2Sequence` sequence.
public struct Iterator: IteratorProtocol {
@usableFromInline
@@ -47,10 +47,12 @@ extension Product2Sequence: Sequence {
self.i2 = c.base2.makeIterator()
self.element1 = nil
}
@inlinable
public mutating func next() -> (Base1.Element,
Base2.Element)? {
public mutating func next() -> (
Base1.Element,
Base2.Element
)? {
// This is the initial state, where i1.next() has never
// been called, or the final state, where i1.next() has
// already returned nil.
@@ -59,27 +61,29 @@ extension Product2Sequence: Sequence {
// once Base1 is exhausted, return `nil` forever
if element1 == nil { return nil }
}
// Get the next element from the second sequence, if not
// at end.
if let element2 = i2.next() {
// swift-format-ignore: NeverForceUnwrap
// `element1` has a nil check above.
return (element1!, element2)
}
// We've reached the end of the second sequence, so:
// 1) Get the next element of the first sequence, if exists
// 2) Restart iteration of the second sequence
// 3) Get the first element of the second sequence, if exists
element1 = i1.next()
guard let element1 = element1
else { return nil }
i2 = base2.makeIterator()
if let element2 = i2.next() {
return (element1, element2)
} else {
guard let element1 else {
return nil
}
i2 = base2.makeIterator()
guard let element2 = i2.next() else {
return nil
}
return (element1, element2)
}
}
@@ -96,43 +100,45 @@ extension Product2Sequence: Collection where Base1: Collection {
internal var i1: Base1.Index
@usableFromInline
internal var i2: Base2.Index
@inlinable
internal init(i1: Base1.Index, i2: Base2.Index) {
self.i1 = i1
self.i2 = i2
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
(lhs.i1, lhs.i2) < (rhs.i1, rhs.i2)
}
}
@inlinable
public var count: Int {
base1.count * base2.count
}
@inlinable
public var startIndex: Index {
Index(
i1: base2.isEmpty ? base1.endIndex : base1.startIndex,
i2: base2.startIndex)
}
@inlinable
public var endIndex: Index {
// `base2.startIndex` simplifies index calculations.
Index(i1: base1.endIndex, i2: base2.startIndex)
}
@inlinable
public subscript(position: Index) -> (Base1.Element,
Base2.Element) {
public subscript(position: Index) -> (
Base1.Element,
Base2.Element
) {
(base1[position.i1], base2[position.i2])
}
/// Forms an index from a pair of base indices, normalizing
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
/// necessary.
@@ -142,24 +148,24 @@ extension Product2Sequence: Collection where Base1: Collection {
? Index(i1: base1.index(after: i1), i2: base2.startIndex)
: Index(i1: i1, i2: i2)
}
@inlinable
public func index(after i: Index) -> Index {
precondition(i.i1 != base1.endIndex, "Can't advance past endIndex")
return normalizeIndex(i.i1, base2.index(after: i.i2))
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
guard start.i1 <= end.i1
else { return -distance(from: end, to: start) }
else { return -distance(from: end, to: start) }
guard start.i1 != end.i1
else { return base2.distance(from: start.i2, to: end.i2) }
else { return base2.distance(from: start.i2, to: end.i2) }
// The number of full cycles through `base2` between `start` and `end`,
// excluding the cycles that `start` and `end` are on.
let fullBase2Cycles = base1[start.i1..<end.i1].count - 1
if start.i2 <= end.i2 {
// start.i2
// v
@@ -170,11 +176,11 @@ extension Product2Sequence: Collection where Base1: Collection {
// end.i1 > [l l l c c c c c c|r r r]
// ^
// end.i2
let left = base2[..<start.i2].count
let center = base2[start.i2..<end.i2].count
let right = base2[end.i2...].count
return center + right
+ fullBase2Cycles * (left + center + right)
+ left + center
@@ -188,30 +194,30 @@ extension Product2Sequence: Collection where Base1: Collection {
// end.i1 > [l l l|c c c c c c r r r]
// ^
// end.i2
let left = base2[..<end.i2].count
let right = base2[start.i2...].count
// We can avoid traversing `base2[end.i2..<start.i2]` if `start` and `end`
// are on consecutive cycles.
guard fullBase2Cycles > 0 else { return right + left }
let center = base2[end.i2..<start.i2].count
return right
+ fullBase2Cycles * (left + center + right)
+ left
}
}
@inlinable
public func index(_ i: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return i }
return distance > 0
? offsetForward(i, by: distance)
: offsetBackward(i, by: -distance)
}
@inlinable
public func index(
_ i: Index,
@@ -232,51 +238,55 @@ extension Product2Sequence: Collection where Base1: Collection {
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit >= i)
if limit.i1 == i.i1 {
// Delegate to `base2` if the offset is limited to `i.i1`.
//
// i.i2 limit.i2
// v v
// i.i1 > [x x x|x x x x x x|x x x]
return base2.index(i.i2, offsetBy: distance, limitedBy: limit.i2)
.map { i2 in Index(i1: i.i1, i2: i2) }
}
if let i2 = base2.index(i.i2, offsetBy: distance, limitedBy: base2.endIndex) {
if let i2 =
base2
.index(i.i2, offsetBy: distance, limitedBy: base2.endIndex)
{
// `distance` does not overflow `base2[i.i2...]`.
//
// i.i2 i2
// v v
// i.i1 > [x x x|x x x x x x|x x x]
// [ |> > > > > >| ] (`distance`)
return normalizeIndex(i.i1, i2)
}
let suffixCount = base2[i.i2...].count
let remaining = distance - suffixCount
let nextI1 = base1.index(after: i.i1)
if limit.i1 == nextI1 {
// Delegate to `base2` if the offset is limited to `nextI1`.
//
@@ -286,12 +296,17 @@ extension Product2Sequence: Collection where Base1: Collection {
// nextI1 > [x x x x x x x x x|x x x]
// ^
// limit.i2
return base2.index(base2.startIndex, offsetBy: remaining, limitedBy: limit.i2)
return
base2
.index(base2.startIndex, offsetBy: remaining, limitedBy: limit.i2)
.map { i2 in Index(i1: nextI1, i2: i2) }
}
if let i2 = base2.index(base2.startIndex, offsetBy: remaining, limitedBy: i.i2) {
if let i2 =
base2
.index(base2.startIndex, offsetBy: remaining, limitedBy: i.i2)
{
// `remaining` does not overflow `base2[..<i.i2]`.
//
// i.i2
@@ -302,58 +317,66 @@ extension Product2Sequence: Collection where Base1: Collection {
// nextI1 > [x x x|x x x x x x x x x]
// ^
// i2
return Index(i1: nextI1, i2: i2)
}
let prefixCount = base2[..<i.i2].count
let base2Count = prefixCount + suffixCount
let base1Distance = remaining / base2Count
guard let i1 = base1.index(nextI1, offsetBy: base1Distance, limitedBy: limit.i1)
else { return nil }
guard
let i1 = base1.index(nextI1, offsetBy: base1Distance, limitedBy: limit.i1)
else { return nil }
// The distance from `base2.startIndex` to the target.
let base2Distance = remaining % base2Count
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.endIndex
return base2.index(base2.startIndex, offsetBy: base2Distance, limitedBy: base2Limit)
return
base2
.index(base2.startIndex, offsetBy: base2Distance, limitedBy: base2Limit)
.map { i2 in Index(i1: i1, i2: i2) }
}
@inlinable
internal func offsetBackward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance >= 0)
assert(limit <= i)
if limit.i1 == i.i1 {
// Delegate to `base2` if the offset is limited to `i.i1`.
//
// limit.i2 i.i2
// v v
// i.i1 > [x x x|x x x x x x|x x x]
return base2.index(i.i2, offsetBy: -distance, limitedBy: limit.i2)
.map { i2 in Index(i1: i.i1, i2: i2) }
}
if let i2 = base2.index(i.i2, offsetBy: -distance, limitedBy: base2.startIndex) {
if let i2 =
base2
.index(i.i2, offsetBy: -distance, limitedBy: base2.startIndex)
{
// `distance` does not underflow `base2[..<i.i2]`.
//
// i2 i.i2
// v v
// i.i1 > [x x x|x x x x x x|x x x]
// [ |< < < < < <| ] (`distance`)
return Index(i1: i.i1, i2: i2)
}
let prefixCount = base2[..<i.i2].count
let remaining = distance - prefixCount
let previousI1 = base1.index(i.i1, offsetBy: -1)
if limit.i1 == previousI1 {
// Delegate to `base2` if the offset is limited to `previousI1`.
//
@@ -363,12 +386,17 @@ extension Product2Sequence: Collection where Base1: Collection {
// i.i1 > [x x x x x x x x x|x x x]
// ^
// i.i2
return base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: limit.i2)
return
base2
.index(base2.endIndex, offsetBy: -remaining, limitedBy: limit.i2)
.map { i2 in Index(i1: previousI1, i2: i2) }
}
if let i2 = base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: i.i2) {
if let i2 =
base2
.index(base2.endIndex, offsetBy: -remaining, limitedBy: i.i2)
{
// `remaining` does not underflow `base2[i.i2...]`.
//
// i2
@@ -379,17 +407,17 @@ extension Product2Sequence: Collection where Base1: Collection {
// i.i1 > [x x x|x x x x x x x x x]
// ^
// i.i2
return Index(i1: previousI1, i2: i2)
}
let suffixCount = base2[i.i2...].count
let base2Count = prefixCount + suffixCount
let base1Distance = remaining / base2Count
// The distance from `base2.endIndex` to the target.
let base2Distance = remaining % base2Count
if base2Distance == 0 {
// We end up exactly between two cycles, so `base1Distance` would
// overshoot the target by 1.
@@ -402,46 +430,54 @@ extension Product2Sequence: Collection where Base1: Collection {
// i.i1 > [x x x|x x x x x x x x x]
// ^
// i.i2
if let i1 = base1.index(previousI1, offsetBy: -(base1Distance - 1), limitedBy: limit.i1) {
let index = Index(i1: i1, i2: base2.startIndex)
return index < limit ? nil : index
} else {
guard
let i1 = base1.index(
previousI1,
offsetBy: -(base1Distance - 1),
limitedBy: limit.i1)
else {
return nil
}
let index = Index(i1: i1, i2: base2.startIndex)
return index < limit ? nil : index
}
guard let i1 = base1.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
else { return nil }
guard
let i1 =
base1
.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
else { return nil }
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.startIndex
return base2.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
return
base2
.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
.map { i2 in Index(i1: i1, i2: i2) }
}
}
extension Product2Sequence: BidirectionalCollection
where Base1: BidirectionalCollection, Base2: BidirectionalCollection
{
where Base1: BidirectionalCollection, Base2: BidirectionalCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i != startIndex,
"Can't move before startIndex")
if i.i2 == base2.startIndex {
return Index(
i1: base1.index(before: i.i1),
i2: base2.index(before: base2.endIndex))
} else {
precondition(
i != startIndex,
"Can't move before startIndex")
guard i.i2 == base2.startIndex else {
return Index(i1: i.i1, i2: base2.index(before: i.i2))
}
return Index(
i1: base1.index(before: i.i1),
i2: base2.index(before: base2.endIndex))
}
}
extension Product2Sequence: RandomAccessCollection
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
extension Product2Sequence.Index: Hashable
where Base1.Index: Hashable, Base2.Index: Hashable {}
where Base1.Index: Hashable, Base2.Index: Hashable {}
//===----------------------------------------------------------------------===//
// product(_:_:)
@@ -454,7 +490,6 @@ extension Product2Sequence.Index: Hashable
/// element of the tuple is from the first collection and the second element is
/// from the second collection.
///
///
/// let numbers = 1...3
/// let colors = ["cerise", "puce", "heliotrope"]
/// for (number, color) in product(numbers, colors) {
@@ -478,11 +513,14 @@ extension Product2Sequence.Index: Hashable
/// - Parameters:
/// - s1: The first sequence to iterate over.
/// - s2: The second sequence to iterate over.
/// - Returns: A sequence of tuples, with every combination of the elements
/// of `s1` and `s2`, in order.
///
/// - Complexity: O(1)
@inlinable
public func product<Base1: Sequence, Base2: Collection>(
_ s1: Base1, _ s2: Base2
_ s1: Base1,
_ s2: Base2
) -> Product2Sequence<Base1, Base2> {
Product2Sequence(s1, s2)
}
+56 -25
View File
@@ -10,8 +10,34 @@
//===----------------------------------------------------------------------===//
// For log(_:) and root(_:_:)
@_implementationOnly
#if ALGORITHMS_DARWIN_ONLY
internal import Darwin
extension Double {
@_transparent
internal static func root(_ x: Double, _ n: Int) -> Double {
guard x >= 0 || n % 2 != 0 else { return .nan }
if n == 3 { return cbrt(x) }
return Double(signOf: x, magnitudeOf: pow(x.magnitude, 1 / Double(n)))
}
@_transparent
internal static func log(_ x: Double) -> Double {
Darwin.log(x)
}
@_transparent
internal static func log(onePlus x: Double) -> Double {
Darwin.log1p(x)
}
}
#elseif swift(>=5.11)
internal import RealModule
#elseif swift(>=5.10)
import RealModule
#else
@_implementationOnly import RealModule
#endif
//===----------------------------------------------------------------------===//
// randomStableSample(count:)
@@ -30,16 +56,17 @@ extension Collection {
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
public func randomStableSample<G: RandomNumberGenerator>(
count k: Int, using rng: inout G
count k: Int,
using rng: inout G
) -> [Element] {
guard k > 0 else { return [] }
var remainingCount = count
guard k < remainingCount else { return Array(self) }
var result: [Element] = []
result.reserveCapacity(k)
var i = startIndex
var countToSelect = k
while countToSelect > 0 {
@@ -52,10 +79,10 @@ extension Collection {
formIndex(after: &i)
remainingCount -= 1
}
return result
}
/// Randomly selects the specified number of elements from this collection,
/// maintaining their relative order.
///
@@ -84,14 +111,16 @@ extension Collection {
@usableFromInline
internal func nextW<G: RandomNumberGenerator>(
k: Int, using rng: inout G
k: Int,
using rng: inout G
) -> Double {
Double.root(.random(in: 0..<1, using: &rng), k)
}
@usableFromInline
internal func nextOffset<G: RandomNumberGenerator>(
w: Double, using rng: inout G
w: Double,
using rng: inout G
) -> Int {
let offset = Double.log(.random(in: 0..<1, using: &rng)) / .log(onePlus: -w)
return offset < Double(Int.max) ? Int(offset) : Int.max
@@ -112,29 +141,30 @@ extension Collection {
/// where *n* is the length of the collection.
@inlinable
public func randomSample<G: RandomNumberGenerator>(
count k: Int, using rng: inout G
count k: Int,
using rng: inout G
) -> [Element] {
guard k > 0 else { return [] }
var w = 1.0
var result: [Element] = []
result.reserveCapacity(k)
// Fill the reservoir with the first `k` elements.
var i = startIndex
while i != endIndex, result.count < k {
result.append(self[i])
formIndex(after: &i)
}
while i != endIndex {
// Calculate the next value of w.
w *= nextW(k: k, using: &rng)
// Find index of the next element to swap into the reservoir.
let offset = nextOffset(w: w, using: &rng)
i = index(i, offsetBy: offset, limitedBy: endIndex) ?? 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)
@@ -142,12 +172,12 @@ extension Collection {
formIndex(after: &i)
}
}
// FIXME: necessary?
result.shuffle(using: &rng)
return result
}
/// Randomly selects the specified number of elements from this collection.
///
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
@@ -181,14 +211,15 @@ extension Sequence {
/// - Complexity: O(*n*), where *n* is the length of the sequence.
@inlinable
public func randomSample<G: RandomNumberGenerator>(
count k: Int, using rng: inout G
count k: Int,
using rng: inout G
) -> [Element] {
guard k > 0 else { return [] }
var w = 1.0
var result: [Element] = []
result.reserveCapacity(k)
// Fill the reservoir with the first `k` elements.
var iterator = makeIterator()
while result.count < k, let el = iterator.next() {
@@ -198,26 +229,26 @@ extension Sequence {
while true {
// Calculate the next value of w.
w *= nextW(k: k, using: &rng)
// Find the offset of the next element to swap into the reservoir.
var offset = nextOffset(w: w, using: &rng)
// Skip over `offset` elements to find the selected element.
while offset > 0, let _ = iterator.next() {
while offset > 0, iterator.next() != nil {
offset -= 1
}
guard let nextElement = iterator.next() else { break }
// Swap selected element with a randomly chosen one in the reservoir.
let j = Int.random(in: 0..<result.count, using: &rng)
result[j] = nextElement
}
// FIXME: necessary?
result.shuffle(using: &rng)
return result
}
/// Randomly selects the specified number of elements from this sequence.
///
/// This method is equivalent to calling `randomSample(k:using:)`, passing in
+18 -19
View File
@@ -161,7 +161,7 @@ extension Sequence {
_ transform: (inout Result, Element) throws -> Void
) rethrows -> [Result] {
var output = [Result]()
var output: [Result] = []
output.reserveCapacity(underestimatedCount + 1)
output.append(initial)
@@ -249,7 +249,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
case base(Base.Index, Result)
case end
}
@usableFromInline
internal let representation: Representation
@@ -257,7 +257,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
internal init(_ representation: Representation) {
self.representation = representation
}
@inlinable
public static func == (lhs: Self, rhs: Self) -> Bool {
switch (lhs.representation, rhs.representation) {
@@ -269,7 +269,7 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
return false
}
}
@inlinable
public static func < (lhs: Self, rhs: Self) -> Bool {
switch (lhs.representation, rhs.representation) {
@@ -319,11 +319,11 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
switch (start.representation, end.representation) {
case let (.base(start, _), .base(end, _)):
case (.base(let start, _), .base(let end, _)):
return base.distance(from: start, to: end)
case let (.base(index, _), .end):
case (.base(let index, _), .end):
return base.distance(from: index, to: base.endIndex) + 1
case let (.end, .base(index, _)):
case (.end, .base(let index, _)):
return base.distance(from: base.endIndex, to: index) - 1
case (.end, .end):
return 0
@@ -334,11 +334,10 @@ extension ExclusiveReductionsSequence: Collection where Base: Collection {
extension ExclusiveReductionsSequence: LazySequenceProtocol {}
extension ExclusiveReductionsSequence: LazyCollectionProtocol
where Base: Collection {}
where Base: Collection {}
extension ExclusiveReductionsSequence.Index: Hashable
where Base.Index: Hashable
{
where Base.Index: Hashable {
@inlinable
public func hash(into hasher: inout Hasher) {
switch representation {
@@ -483,7 +482,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
public struct Index: Comparable {
@usableFromInline
internal let base: Base.Index
@usableFromInline
internal let result: Element?
@@ -497,7 +496,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
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
@@ -519,7 +518,7 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
guard let result = index.result else {
fatalError("Can't subscript using endIndex")
}
return result
}
@@ -528,12 +527,13 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
guard let result = index.result else {
fatalError("Can't advance past endIndex")
}
let index = base.index(after: index.base)
let nextResult = index == base.endIndex
let nextResult =
index == base.endIndex
? nil
: transform(result, base[index])
return Index(base: index, result: nextResult)
}
@@ -546,11 +546,10 @@ extension InclusiveReductionsSequence: Collection where Base: Collection {
extension InclusiveReductionsSequence: LazySequenceProtocol {}
extension InclusiveReductionsSequence: LazyCollectionProtocol
where Base: Collection {}
where Base: Collection {}
extension InclusiveReductionsSequence.Index: Hashable
where Base.Index: Hashable
{
where Base.Index: Hashable {
@inlinable
public func hash(into hasher: inout Hasher) {
hasher.combine(base)
+26 -20
View File
@@ -15,8 +15,10 @@
extension MutableCollection where Self: BidirectionalCollection {
/// Reverses the elements of the collection, moving from each end until
/// `limit` is reached from either direction. The returned indices are the
/// start and end of the range of unreversed elements.
/// `limit` is reached from either direction.
///
/// The returned indices are the start and end of the range of unreversed
/// elements.
///
/// Input:
/// [a b c d e f g h i j k l m n o p]
@@ -28,11 +30,12 @@ extension MutableCollection where Self: BidirectionalCollection {
/// lower upper
///
/// - Postcondition: For returned indices `(lower, upper)`:
/// `lower == limit || upper == limit`
/// `lower == limit || upper == limit`.
@inlinable
@discardableResult
internal mutating func _reverse(
subrange: Range<Index>, until limit: Index
subrange: Range<Index>,
until limit: Index
) -> (Index, Index) {
var lower = subrange.lowerBound
var upper = subrange.upperBound
@@ -43,7 +46,7 @@ extension MutableCollection where Self: BidirectionalCollection {
}
return (lower, upper)
}
/// Reverses the elements within the given subrange.
///
/// This example reverses the numbers within the subrange at the start of the
@@ -75,8 +78,10 @@ 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]
@@ -96,19 +101,19 @@ extension MutableCollection {
/// - p == lhs.upperBound || q == rhs.upperBound
@inlinable
internal mutating func _swapNonemptySubrangePrefixes(
_ lhs: Range<Index>, _ rhs: Range<Index>
_ lhs: Range<Index>,
_ rhs: Range<Index>
) -> (Index, Index) {
assert(!lhs.isEmpty)
assert(!rhs.isEmpty)
var p = lhs.lowerBound
var q = rhs.lowerBound
repeat {
swapAt(p, q)
formIndex(after: &p)
formIndex(after: &q)
}
while p != lhs.upperBound && q != rhs.upperBound
} while p != lhs.upperBound && q != rhs.upperBound
return (p, q)
}
@@ -139,13 +144,14 @@ extension MutableCollection {
subrange: Range<Index>,
toStartAt newStart: Index
) -> Index {
var m = newStart, s = subrange.lowerBound
var m = newStart
var s = subrange.lowerBound
let e = subrange.upperBound
// Handle the trivial cases
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).
@@ -154,7 +160,7 @@ extension MutableCollection {
// ^ ^ ^ ^ ^ ^
// s m e s m e
//
var ret = e // start with a known incorrect result.
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).
@@ -166,7 +172,7 @@ extension MutableCollection {
// s s1 m m1/e s s1/m m1 e
//
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.
@@ -175,11 +181,11 @@ extension MutableCollection {
// 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.
//
@@ -189,10 +195,10 @@ extension MutableCollection {
s = s1
if s == m { m = m1 }
}
return ret
}
/// Rotates the elements of this collection so that the element at the
/// specified index becomes the start of the collection.
///
+12 -13
View File
@@ -86,7 +86,7 @@ extension SplitSequence: Sequence {
self.omittingEmptySubsequences = omittingEmptySubsequences
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(
@@ -101,25 +101,25 @@ extension SplitSequence: Sequence {
extension SplitSequence.Iterator: IteratorProtocol {
@inlinable
public mutating func next() -> Element? {
var currentElement = base.next()
var nextElement = base.next()
var subsequence: Element = []
// Add the next elements of the base sequence to this subsequence, until we
// reach a separator, unless we've already split the maximum number of
// times. In all cases, stop at the end of the base sequence.
while currentElement != nil {
if splitCount < maxSplits && isSeparator(currentElement!) {
while let currentElement = nextElement {
if splitCount < maxSplits && isSeparator(currentElement) {
if omittingEmptySubsequences && subsequence.isEmpty {
// Keep going if we don't want to return an empty subsequence.
currentElement = base.next()
nextElement = base.next()
continue
} else {
splitCount += 1
break
}
} else {
subsequence.append(currentElement!)
currentElement = base.next()
subsequence.append(currentElement)
nextElement = base.next()
}
}
@@ -127,7 +127,7 @@ extension SplitSequence.Iterator: IteratorProtocol {
// and we've either returned the maximum number of subsequences (one more
// than the number of separators), or the only subsequence left to return is
// empty and we're omitting those.
if currentElement == nil
if nextElement == nil
&& (sequenceLength == splitCount + 1
|| omittingEmptySubsequences && subsequence.isEmpty)
{
@@ -219,7 +219,7 @@ extension LazySequenceProtocol {
/// satisfying the `isSeparator` predicate and for each element at the
/// start or end of the sequence satisfying the `isSeparator`
/// predicate. The default value is `true`.
/// - whereSeparator: A closure that takes an element as an argument and
/// - isSeparator: A closure that takes an element as an argument and
/// returns a Boolean value indicating whether the sequence should be
/// split at that element.
/// - Returns: A lazy sequence of subsequences, split from this sequence's
@@ -512,7 +512,7 @@ extension SplitCollection: Collection {
var subsequenceStart = i.baseRange.upperBound
if subsequenceStart < base.endIndex {
// If we're not already at the end of the base collection, the previous
// susequence ended with a separator. Start searching for the next
// subsequence ended with a separator. Start searching for the next
// subsequence at the following element.
subsequenceStart = base.index(after: i.baseRange.upperBound)
}
@@ -634,7 +634,7 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
/// satisfying the `isSeparator` predicate and for each element at the
/// start or end of the collection satisfying the `isSeparator`
/// predicate. The default value is `true`.
/// - whereSeparator: A closure that takes an element as an argument and
/// - isSeparator: A closure that takes an element as an argument and
/// returns a Boolean value indicating whether the collection should be
/// split at that element.
/// - Returns: A lazy collection of subsequences, split from this collection's
@@ -659,8 +659,7 @@ extension LazySequenceProtocol where Self: Collection, Elements: Collection {
}
extension LazySequenceProtocol
where Self: Collection, Elements: Collection, Element: Equatable
{
where Self: Collection, Elements: Collection, Element: Equatable {
/// Lazily returns the longest possible subsequences of the collection, in
/// order, around elements equal to the given element.
///
+57 -51
View File
@@ -15,7 +15,7 @@
extension Sequence {
/// Returns a sequence stepping through the elements every `step` starting at
/// the first value. Any remainders of the stride will be trimmed.
/// the first value.
///
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
@@ -24,8 +24,9 @@ extension Sequence {
/// 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: A sequence for stepping through the elements by the specified
/// amount. Any remaining elements after the last multiple of the stride
/// are omitted.
@inlinable
public func striding(by step: Int) -> StridingSequence<Self> {
StridingSequence(base: self, stride: step)
@@ -34,18 +35,18 @@ extension Sequence {
extension Collection {
/// Returns a sequence stepping through the elements every `step` starting at
/// the first value. Any remainders of the stride will be trimmed.
/// the first value.
///
/// (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(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: A sequence for stepping through the elements by the specified
/// amount. Any remaining elements after the last multiple of the stride
/// are omitted.
@inlinable
public func striding(by step: Int) -> StridingCollection<Self> {
StridingCollection(base: self, stride: step)
@@ -56,10 +57,10 @@ extension Collection {
public struct StridingSequence<Base: Sequence> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let stride: Int
@inlinable
internal init(base: Base, stride: Int) {
precondition(stride > 0, "Stride must be greater than zero")
@@ -80,19 +81,19 @@ extension StridingSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal var iterator: Base.Iterator
@usableFromInline
internal let stride: Int
@usableFromInline
internal var striding: Bool = false
@inlinable
internal init(iterator: Base.Iterator, stride: Int) {
self.iterator = iterator
self.stride = stride
}
@inlinable
public mutating func next() -> Base.Element? {
guard striding else {
@@ -105,7 +106,7 @@ extension StridingSequence: Sequence {
return iterator.next()
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(iterator: base.makeIterator(), stride: stride)
@@ -113,16 +114,16 @@ extension StridingSequence: Sequence {
}
extension StridingSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
/// A wrapper that strides over a base collection.
public struct StridingCollection<Base: Collection> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let stride: Int
@inlinable
internal init(base: Base, stride: Int) {
precondition(stride > 0, "striding must be greater than zero")
@@ -143,39 +144,39 @@ extension StridingCollection: Collection {
public struct Index: Comparable {
@usableFromInline
internal let base: Base.Index
@usableFromInline
internal init(_ base: Base.Index) {
self.base = base
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
lhs.base < rhs.base
}
}
@inlinable
public var startIndex: Index {
Index(base.startIndex)
}
@inlinable
public var endIndex: Index {
Index(base.endIndex)
}
@inlinable
public subscript(i: Index) -> Base.Element {
base[i.base]
}
@inlinable
public func index(after i: Index) -> Index {
precondition(i.base != base.endIndex, "Advancing past end index")
return index(i, offsetBy: 1)
}
@inlinable
public func index(
_ i: Index,
@@ -184,12 +185,12 @@ extension StridingCollection: Collection {
) -> Index? {
guard n != 0 else { return i }
guard limit != i else { return nil }
return n > 0
? offsetForward(i, offsetBy: n, limitedBy: limit)
: offsetBackward(i, offsetBy: -n, limitedBy: limit)
}
@inlinable
internal func offsetForward(
_ i: Index,
@@ -197,16 +198,17 @@ extension StridingCollection: Collection {
limitedBy limit: Index
) -> Index? {
if limit < i {
if let idx = base.index(
i.base,
offsetBy: n * stride,
limitedBy: base.endIndex
) {
return Index(idx)
} else {
guard
let idx = base.index(
i.base,
offsetBy: n * stride,
limitedBy: base.endIndex
)
else {
assert(distance(from: i, to: endIndex) == n, "Advancing past end index")
return endIndex
}
return Index(idx)
} else if let idx = base.index(
i.base,
offsetBy: n * stride,
@@ -219,7 +221,7 @@ extension StridingCollection: Collection {
: nil
}
}
@inlinable
internal func offsetBackward(
_ i: Index,
@@ -236,37 +238,41 @@ extension StridingCollection: Collection {
distance = n * -stride
}
return base.index(
i.base,
offsetBy: distance,
limitedBy: limit.base
i.base,
offsetBy: distance,
limitedBy: limit.base
).map(Index.init)
}
@inlinable
public var count: Int {
base.isEmpty ? 0 : (base.count - 1) / stride + 1
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
let distance = base.distance(from: start.base, to: end.base)
return distance / stride + (distance % stride).signum()
}
@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")
return idx!
guard let idx = index(i, offsetBy: distance, limitedBy: limit) else {
preconditionFailure(
"The distance \(distance) is not valid for this collection")
}
return idx
}
}
extension StridingCollection: BidirectionalCollection
where Base: RandomAccessCollection {
where Base: RandomAccessCollection {
@inlinable
public func index(before i: Index) -> Index {
precondition(i.base != base.startIndex, "Incrementing past start index")
@@ -275,9 +281,9 @@ extension StridingCollection: BidirectionalCollection
}
extension StridingCollection: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension StridingCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension StridingCollection.Index: Hashable where Base.Index: Hashable {}
+11 -4
View File
@@ -14,13 +14,16 @@
//===----------------------------------------------------------------------===//
extension BidirectionalCollection {
/// Returns a subsequence containing the elements from the end until
/// `predicate` returns `false` and skipping the remaining elements.
/// Returns a subsequence containing the suffix of this collection where
/// all elements pass the given closure.
///
/// - 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.
/// - Returns: A subsequence that is a suffix of the collection, where
/// `predicate` returns `true` for all the elements of the returned
/// subsequence.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
@@ -43,10 +46,12 @@ extension Collection {
/// as its argument and returns `true` if the element is part of the prefix
/// or `false` if it is not. Once the predicate returns `false` it will not
/// be called again.
/// - Returns: The index of the first element for which `predicate` does not
/// succeed, or `endIndex` if all the collection's elements pass.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
internal func endOfPrefix(
public func endOfPrefix(
while predicate: (Element) throws -> Bool
) rethrows -> Index {
var index = startIndex
@@ -69,10 +74,12 @@ extension BidirectionalCollection {
/// as its argument and returns `true` if the element is part of the suffix
/// or `false` if it is not. Once the predicate returns `false` it will not
/// be called again.
/// - Returns: The index of the last element for which `predicate` does not
/// succeed, or `startIndex` if all the collection's elements pass.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
internal func startOfSuffix(
public func startOfSuffix(
while predicate: (Element) throws -> Bool
) rethrows -> Index {
var index = endIndex
+42 -40
View File
@@ -7,6 +7,7 @@
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// trimmingPrefix(while:)
@@ -14,25 +15,27 @@
extension Collection {
/// Returns a `SubSequence` formed by discarding all elements at the start of
/// the collection which satisfy the given predicate.
/// the collection that satisfy the given predicate.
///
/// This example uses `trimmingPrefix(while:)` to get a substring without the
/// white space at the beginning of the string:
///
/// let myString = " hello, world "
/// print(myString.trimmingPrefix(while: \.isWhitespace)) // "hello, world "
/// print(myString.trimmingPrefix(while: \.isWhitespace))
/// // Prints "hello, world "
///
/// - Parameter predicate: A closure which determines if the element should be
/// omitted from the resulting slice.
/// - Parameter predicate: A closure that determines if the element should be
/// omitted from the result.
/// - Returns: A subsequence of this collection, starting at the first element
/// for which `predicate` returns `false`.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public func trimmingPrefix(
while predicate: (Element) throws -> Bool
) rethrows -> SubSequence {
let start = try endOfPrefix(while: predicate)
return self[start...]
return self[start..<endIndex]
}
}
@@ -41,7 +44,7 @@ extension Collection {
//===----------------------------------------------------------------------===//
extension Collection where Self: RangeReplaceableCollection {
/// Mutates a `Collection` by discarding all elements at the start of it which
/// Mutates the collection by discarding all elements at the start that
/// satisfy the given predicate.
///
/// This example uses `trimPrefix(while:)` to remove the white space at the
@@ -49,25 +52,25 @@ extension Collection where Self: RangeReplaceableCollection {
///
/// let myString = " hello, world "
/// myString.trimPrefix(while: \.isWhitespace)
/// print(myString) // "hello, world "
/// print(myString)
/// // Prints "hello, world "
///
/// - Parameter predicate: A closure which determines if the element should be
/// removed from the string.
/// - Parameter predicate: A closure that determines if the element should be
/// removed from the result.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
@_disfavoredOverload
public mutating func trimPrefix(
while predicate: (Element) throws -> Bool
) rethrows {
let end = try endOfPrefix(while: predicate)
removeSubrange(startIndex..<end)
let startOfResult = try endOfPrefix(while: predicate)
removeSubrange(startIndex..<startOfResult)
}
}
extension Collection where Self == Self.SubSequence {
/// Mutates a `Collection` by discarding all elements at the start of it which
/// Mutates the collection by discarding all elements at the start that
/// satisfy the given predicate.
///
/// This example uses `trimPrefix(while:)` to remove the white space at the
@@ -77,11 +80,10 @@ extension Collection where Self == Self.SubSequence {
/// myString.trimPrefix(while: \.isWhitespace)
/// print(myString) // "hello, world "
///
/// - Parameters predicate: A closure which determines if the element should
/// - Parameters predicate: A closure that determines if the element should
/// be removed from the string.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public mutating func trimPrefix(
while predicate: (Element) throws -> Bool
@@ -96,28 +98,31 @@ extension Collection where Self == Self.SubSequence {
extension BidirectionalCollection {
/// Returns a `SubSequence` formed by discarding all elements at the start and
/// end of the collection which satisfy the given predicate.
/// end of the collection that 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:
///
/// let myString = " hello, world "
/// print(myString.trimming(while: \.isWhitespace)) // "hello, world"
/// print(myString.trimming(while: \.isWhitespace))
/// // Prints "hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// omitted from the resulting slice.
/// - Returns: A subsequence of this collection, starting at the first element
/// for which `predicate` returns `false` and ending at the last element for
/// which `predicate` returns `true`.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public func trimming(
while predicate: (Element) throws -> Bool
) rethrows -> SubSequence {
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.
/// the collection that satisfy the given predicate.
///
/// This example uses `trimmingSuffix(while:)` to get a substring without the
/// white space at the end of the string:
@@ -125,17 +130,18 @@ extension BidirectionalCollection {
/// let myString = " hello, world "
/// print(myString.trimmingSuffix(while: \.isWhitespace)) // " hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// omitted from the resulting slice.
/// - Returns: A subsequence of this collection, ending at the last element
/// for which `predicate` returns `true`.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public func trimmingSuffix(
while predicate: (Element) throws -> Bool
) rethrows -> SubSequence {
let end = try startOfSuffix(while: predicate)
return self[..<end]
return self[startIndex..<end]
}
}
@@ -145,7 +151,7 @@ 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.
/// start and at the end of it that satisfy the given predicate.
///
/// This example uses `trim(while:)` to remove the white space at the
/// beginning of the string:
@@ -154,11 +160,10 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
/// myString.trim(while: \.isWhitespace)
/// print(myString) // "hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// removed from the string.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
@_disfavoredOverload
public mutating func trim(
@@ -167,9 +172,9 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
try trimSuffix(while: predicate)
try trimPrefix(while: predicate)
}
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
/// of it which satisfy the given predicate.
/// of it that satisfy the given predicate.
///
/// This example uses `trimSuffix(while:)` to remove the white space at the
/// beginning of the string:
@@ -178,24 +183,23 @@ extension BidirectionalCollection where Self: RangeReplaceableCollection {
/// myString.trimSuffix(while: \.isWhitespace)
/// print(myString) // " hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// removed from the string.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
@_disfavoredOverload
public mutating func trimSuffix(
while predicate: (Element) throws -> Bool
) rethrows {
let start = try startOfSuffix(while: predicate)
removeSubrange(start..<endIndex)
let endOfResult = try startOfSuffix(while: predicate)
removeSubrange(endOfResult..<endIndex)
}
}
extension BidirectionalCollection where Self == Self.SubSequence {
/// Mutates a `BidirectionalCollection` by discarding all elements at the
/// start and at the end of it which satisfy the given predicate.
/// start and at the end of it that satisfy the given predicate.
///
/// This example uses `trim(while:)` to remove the white space at the
/// beginning of the string:
@@ -204,11 +208,10 @@ extension BidirectionalCollection where Self == Self.SubSequence {
/// myString.trim(while: \.isWhitespace)
/// print(myString) // "hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// removed from the string.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public mutating func trim(
while predicate: (Element) throws -> Bool
@@ -217,7 +220,7 @@ extension BidirectionalCollection where Self == Self.SubSequence {
}
/// Mutates a `BidirectionalCollection` by discarding all elements at the end
/// of it which satisfy the given predicate.
/// of it that satisfy the given predicate.
///
/// This example uses `trimSuffix(while:)` to remove the white space at the
/// beginning of the string:
@@ -226,11 +229,10 @@ extension BidirectionalCollection where Self == Self.SubSequence {
/// myString.trimSuffix(while: \.isWhitespace)
/// print(myString) // " hello, world"
///
/// - Parameter predicate: A closure which determines if the element should be
/// - Parameter predicate: A closure that determines if the element should be
/// removed from the string.
///
/// - Complexity: O(*n*), where *n* is the length of this collection.
///
@inlinable
public mutating func trimSuffix(
while predicate: (Element) throws -> Bool
+8 -8
View File
@@ -14,11 +14,11 @@ public struct UniquedSequence<Base: Sequence, Subject: Hashable> {
/// The base collection.
@usableFromInline
internal let base: Base
/// The projection function.
@usableFromInline
internal let projection: (Base.Element) -> Subject
@usableFromInline
internal init(base: Base, projection: @escaping (Base.Element) -> Subject) {
self.base = base
@@ -31,13 +31,13 @@ extension UniquedSequence: Sequence {
public struct Iterator: IteratorProtocol {
@usableFromInline
internal var base: Base.Iterator
@usableFromInline
internal let projection: (Base.Element) -> Subject
@usableFromInline
internal var seen: Set<Subject> = []
@usableFromInline
internal init(
base: Base.Iterator,
@@ -46,7 +46,7 @@ extension UniquedSequence: Sequence {
self.base = base
self.projection = projection
}
@inlinable
public mutating func next() -> Base.Element? {
while let element = base.next() {
@@ -57,7 +57,7 @@ extension UniquedSequence: Sequence {
return nil
}
}
@inlinable
public func makeIterator() -> Iterator {
Iterator(base: base.makeIterator(), projection: projection)
@@ -65,7 +65,7 @@ extension UniquedSequence: Sequence {
}
extension UniquedSequence: LazySequenceProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
//===----------------------------------------------------------------------===//
// uniqued()
+88 -83
View File
@@ -49,10 +49,10 @@ extension Collection {
public struct WindowsOfCountCollection<Base: Collection> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let windowSize: Int
@usableFromInline
internal var endOfFirstWindow: Base.Index?
@@ -62,7 +62,8 @@ public struct WindowsOfCountCollection<Base: Collection> {
self.base = base
self.windowSize = windowSize
self.endOfFirstWindow =
base.index(base.startIndex, offsetBy: windowSize, limitedBy: base.endIndex)
base
.index(base.startIndex, offsetBy: windowSize, limitedBy: base.endIndex)
}
}
@@ -71,41 +72,40 @@ extension WindowsOfCountCollection: Collection {
public struct Index: Comparable {
@usableFromInline
internal var lowerBound: Base.Index
@usableFromInline
internal var upperBound: Base.Index
@inlinable
internal init(lowerBound: Base.Index, upperBound: Base.Index) {
self.lowerBound = lowerBound
self.upperBound = upperBound
}
@inlinable
public static func == (lhs: Index, rhs: Index) -> Bool {
lhs.lowerBound == rhs.lowerBound
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
lhs.lowerBound < rhs.lowerBound
}
}
@inlinable
public var startIndex: Index {
if let upperBound = endOfFirstWindow {
return Index(lowerBound: base.startIndex, upperBound: upperBound)
} else {
guard let upperBound = endOfFirstWindow else {
return endIndex
}
return Index(lowerBound: base.startIndex, upperBound: upperBound)
}
@inlinable
public var endIndex: Index {
Index(lowerBound: base.endIndex, upperBound: base.endIndex)
}
@inlinable
public subscript(index: Index) -> Base.SubSequence {
precondition(
@@ -113,28 +113,29 @@ extension WindowsOfCountCollection: Collection {
"Windows index is out of range")
return base[index.lowerBound..<index.upperBound]
}
@inlinable
public func index(after index: Index) -> Index {
precondition(index != endIndex, "Advancing past end index")
guard index.upperBound < base.endIndex else { return endIndex }
let lowerBound = windowSize == 1
let lowerBound =
windowSize == 1
? index.upperBound
: base.index(after: index.lowerBound)
let upperBound = base.index(after: index.upperBound)
return Index(lowerBound: lowerBound, upperBound: upperBound)
}
@inlinable
public func index(_ i: Index, offsetBy distance: Int) -> Index {
guard distance != 0 else { return i }
return distance > 0
? offsetForward(i, by: distance)
: offsetBackward(i, by: -distance)
}
@inlinable
public func index(
_ i: Index,
@@ -143,7 +144,7 @@ extension WindowsOfCountCollection: Collection {
) -> Index? {
guard distance != 0 else { return i }
guard limit != i else { return nil }
if distance > 0 {
return limit > i
? offsetForward(i, by: distance, limitedBy: limit)
@@ -154,28 +155,30 @@ extension WindowsOfCountCollection: Collection {
: offsetBackward(i, by: -distance)
}
}
@inlinable
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
else { fatalError("Index is out of bounds") }
else { fatalError("Index is out of bounds") }
return index
}
@inlinable
internal func offsetForward(
_ i: Index, by distance: Int, limitedBy limit: Index
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit > i)
// `endIndex` and the index before it both have `base.endIndex` as their
// upper bound, so we first advance to the base index _before_ the upper
// bound of the output, in order to avoid advancing past the end of `base`
@@ -186,31 +189,31 @@ extension WindowsOfCountCollection: Collection {
// input: [x|x x x x x|x x x x] [x x|x x x x x|x x x]
// |> > >|>| 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 {
// 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.
// input: [x|x x x x|x x x x x x x]
// |> >|> > >|>|
// output: [x x x x x x x|x x x x|x]
guard limit.lowerBound >= i.upperBound,
let lowerBound = base.index(
i.upperBound,
offsetBy: distance - windowSize,
limitedBy: limit.lowerBound),
let indexBeforeUpperBound = base.index(
lowerBound,
offsetBy: windowSize - 1,
limitedBy: limit.upperBound)
let lowerBound = base.index(
i.upperBound,
offsetBy: distance - windowSize,
limitedBy: limit.lowerBound),
let indexBeforeUpperBound = base.index(
lowerBound,
offsetBy: windowSize - 1,
limitedBy: limit.upperBound)
else { return nil }
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
// `endIndex`.
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
return Index(
lowerBound: lowerBound,
upperBound: base.index(after: indexBeforeUpperBound))
@@ -218,35 +221,38 @@ extension WindowsOfCountCollection: Collection {
// input: [x|x x x x x x|x x x x x]
// |> > > >| |> > >|>|
// output: [x x x x x|x x x x x x|x]
guard let indexBeforeUpperBound = base.index(
i.upperBound,
offsetBy: distance - 1,
limitedBy: limit.upperBound)
guard
let indexBeforeUpperBound = base.index(
i.upperBound,
offsetBy: distance - 1,
limitedBy: limit.upperBound)
else { return nil }
// If `indexBeforeUpperBound` equals the limit, the upper bound itself
// exceeds it.
guard indexBeforeUpperBound != limit.upperBound || limit == endIndex
else { return nil }
else { return nil }
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
// `endIndex`.
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
return Index(
lowerBound: base.index(i.lowerBound, offsetBy: distance),
upperBound: base.index(after: indexBeforeUpperBound))
}
}
@inlinable
internal func offsetBackward(
_ i: Index, by distance: Int, limitedBy limit: Index
) -> Index? {
_ i: Index,
by distance: Int,
limitedBy limit: Index
) -> Index? {
assert(distance > 0)
assert(limit < i)
if i == endIndex {
// Advance `base.endIndex` by `distance - 1`, because the index before
// `endIndex` also has `base.endIndex` as its upper bound.
@@ -256,13 +262,14 @@ extension WindowsOfCountCollection: Collection {
// input: [x x x x x x x x x x] (`endIndex`)
// |< < < < <|< < <|
// output: [x x|x x x x x|x x x]
guard let upperBound = base.index(
base.endIndex,
offsetBy: -(distance - 1),
limitedBy: limit.upperBound)
guard
let upperBound = base.index(
base.endIndex,
offsetBy: -(distance - 1),
limitedBy: limit.upperBound)
else { return nil }
return Index(
lowerBound: base.index(upperBound, offsetBy: -windowSize),
upperBound: upperBound)
@@ -274,14 +281,14 @@ extension WindowsOfCountCollection: Collection {
// input: [x x x x x x x|x x x x|x]
// |< < < <|< <|
// output: [x|x x x x|x x x x x x x]
guard limit.upperBound <= i.lowerBound,
let upperBound = base.index(
i.lowerBound,
offsetBy: -(distance - windowSize),
limitedBy: limit.upperBound)
let upperBound = base.index(
i.lowerBound,
offsetBy: -(distance - windowSize),
limitedBy: limit.upperBound)
else { return nil }
return Index(
lowerBound: base.index(upperBound, offsetBy: -windowSize),
upperBound: upperBound)
@@ -289,19 +296,20 @@ extension WindowsOfCountCollection: Collection {
// input: [x x x x x|x x x x x x|x]
// |< < < <| |< < < <|
// output: [x|x x x x x x|x x x x x]
guard let lowerBound = base.index(
i.lowerBound,
offsetBy: -distance,
limitedBy: limit.lowerBound)
guard
let lowerBound = base.index(
i.lowerBound,
offsetBy: -distance,
limitedBy: limit.lowerBound)
else { return nil }
return Index(
lowerBound: lowerBound,
upperBound: base.index(i.lowerBound, offsetBy: -distance))
}
}
@inlinable
public func distance(from start: Index, to end: Index) -> Int {
guard start <= end else { return -distance(from: end, to: start) }
@@ -319,42 +327,39 @@ extension WindowsOfCountCollection: Collection {
// start: [x|x x x x|x x x x x x x]
// |- - - -|> >|
// end: [x x x x x x x|x x x x|x]
return windowSize + base[start.upperBound..<end.lowerBound].count
} else {
// start: [x|x x x x x x|x x x x x]
// |> > > >|
// end: [x x x x x|x x x x x x|x]
return base[start.lowerBound..<end.lowerBound].count
}
}
}
extension WindowsOfCountCollection: BidirectionalCollection
where Base: BidirectionalCollection
{
where Base: BidirectionalCollection {
@inlinable
public func index(before index: Index) -> Index {
precondition(index != startIndex, "Incrementing past start index")
precondition(index != startIndex, "Decrementing past start index")
if index == endIndex {
return Index(
lowerBound: base.index(index.lowerBound, offsetBy: -windowSize),
upperBound: index.upperBound
)
upperBound: index.upperBound)
} else {
return Index(
lowerBound: base.index(before: index.lowerBound),
upperBound: base.index(before: index.upperBound)
)
upperBound: base.index(before: index.upperBound))
}
}
}
extension WindowsOfCountCollection: RandomAccessCollection
where Base: RandomAccessCollection {}
where Base: RandomAccessCollection {}
extension WindowsOfCountCollection: LazySequenceProtocol, LazyCollectionProtocol
where Base: LazySequenceProtocol {}
where Base: LazySequenceProtocol {}
extension WindowsOfCountCollection.Index: Hashable where Base.Index: Hashable {}
-19
View File
@@ -1,19 +0,0 @@
//===----------------------------------------------------------*- 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`
-----------------------------------------------------
""")
@@ -9,63 +9,63 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class AdjacentPairsTests: XCTestCase {
func testEmptySequence() {
let pairs = (0...).prefix(0).adjacentPairs()
XCTAssertEqualSequences(pairs, [], by: ==)
expectEqualSequences(pairs, [], by: ==)
}
func testOneElementSequence() {
let pairs = (0...).prefix(1).adjacentPairs()
XCTAssertEqualSequences(pairs, [], by: ==)
expectEqualSequences(pairs, [], by: ==)
}
func testTwoElementSequence() {
let pairs = (0...).prefix(2).adjacentPairs()
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
expectEqualSequences(pairs, [(0, 1)], by: ==)
}
func testThreeElementSequence() {
let pairs = (0...).prefix(3).adjacentPairs()
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
}
func testManySequences() {
for n in 4...100 {
let pairs = (0...).prefix(n).adjacentPairs()
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
}
}
func testZeroElements() {
let pairs = (0..<0).adjacentPairs()
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
XCTAssertEqualSequences(pairs, [], by: ==)
expectEqualSequences(pairs, [], by: ==)
}
func testOneElement() {
let pairs = (0..<1).adjacentPairs()
XCTAssertEqual(pairs.startIndex, pairs.endIndex)
XCTAssertEqualSequences(pairs, [], by: ==)
expectEqualSequences(pairs, [], by: ==)
}
func testTwoElements() {
let pairs = (0..<2).adjacentPairs()
XCTAssertEqualSequences(pairs, [(0, 1)], by: ==)
expectEqualSequences(pairs, [(0, 1)], by: ==)
}
func testThreeElements() {
let pairs = (0..<3).adjacentPairs()
XCTAssertEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
expectEqualSequences(pairs, [(0, 1), (1, 2)], by: ==)
}
func testManyElements() {
for n in 4...100 {
let pairs = (0..<n).adjacentPairs()
XCTAssertEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
expectEqualSequences(pairs, zip(0..., 1...).prefix(n - 1), by: ==)
}
}
@@ -76,9 +76,9 @@ final class AdjacentPairsTests: XCTestCase {
validator.validate((0..<2).adjacentPairs(), expectedCount: 1)
validator.validate((0..<5).adjacentPairs(), expectedCount: 4)
}
func testLaziness() {
XCTAssertLazySequence((0...).lazy.adjacentPairs())
XCTAssertLazyCollection((0..<100).lazy.adjacentPairs())
requireLazySequence((0...).lazy.adjacentPairs())
requireLazyCollection((0..<100).lazy.adjacentPairs())
}
}
+15 -14
View File
@@ -10,31 +10,32 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class ChainTests: XCTestCase {
func testChainSequences() {
let run = chain((1...).prefix(10), 20...)
XCTAssertEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
expectEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
}
func testChainForwardCollection() {
let s1 = Set(0...10)
let s2 = Set(20...30)
let c = chain(s1, s2)
XCTAssertEqualSequences(c, Array(s1) + Array(s2))
expectEqualSequences(c, Array(s1) + Array(s2))
}
func testChainBidirectionalCollection() {
let s1 = "ABCDEFGHIJ"
let s2 = "klmnopqrstuv"
let c = chain(s1, s2)
XCTAssertEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
XCTAssertEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
XCTAssertEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
expectEqualSequences(c, "ABCDEFGHIJklmnopqrstuv")
expectEqualSequences(c.reversed(), "ABCDEFGHIJklmnopqrstuv".reversed())
expectEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
}
func testChainIndexTraversals() {
let validator = IndexValidator<Chain2Sequence<String, String>>(
indicesIncludingEnd: { chain in
@@ -42,27 +43,27 @@ final class ChainTests: XCTestCase {
+ 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() {
let c = chain("abc", "XYZ")
do {
let i = c.index(c.startIndex, offsetBy: 3, limitedBy: c.startIndex)
XCTAssertNil(i)
}
do {
let i = c.index(c.startIndex, offsetBy: 4)
let j = c.index(i, offsetBy: -2)
XCTAssertEqual(c[j], "c")
}
do {
let i = c.index(c.startIndex, offsetBy: 3)
let j = c.index(i, offsetBy: -1, limitedBy: i)
+109 -66
View File
@@ -9,23 +9,22 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class ChunkedTests: XCTestCase {
let fruits = [
"Apple", "Apricot", "Avocado", "Banana",
"Bilberry", "Blackberry", "Blackcurrant", "Blueberry",
"Currant", "Cherry", "Cherimoya", "Clementine",
"Date", "Damson", "Dragonfruit", "Durian",
"Eggplant", "Elderberry", "Feijoa",
"Grape", "Grapefruit", "Guava",
"Apple", "Apricot", "Avocado", "Banana",
"Bilberry", "Blackberry", "Blackcurrant", "Blueberry",
"Currant", "Cherry", "Cherimoya", "Clementine",
"Date", "Damson", "Dragonfruit", "Durian",
"Eggplant", "Elderberry", "Feijoa",
"Grape", "Grapefruit", "Guava",
]
func validateFruitChunks<C: BidirectionalCollection>(_ fruitChunks: C)
where C.Element == ArraySlice<String>
{
let expectedChunks: Array<ArraySlice<String>> = [
where C.Element == ArraySlice<String> {
let expectedChunks: [ArraySlice<String>] = [
fruits[0..<3],
fruits[3..<8],
fruits[8..<12],
@@ -34,16 +33,17 @@ final class ChunkedTests: XCTestCase {
fruits[18..<19],
fruits[19..<22],
]
XCTAssertEqualSequences(expectedChunks, fruitChunks, by: ==)
expectEqualSequences(expectedChunks, fruitChunks, by: ==)
XCTAssertEqual(fruits[19..<22], fruitChunks.last)
XCTAssertEqual("Currant", fruitChunks.first(where: { $0.count == 4 })?.first)
XCTAssertEqual(
"Currant", fruitChunks.first(where: { $0.count == 4 })?.first)
XCTAssertEqual("Date", fruitChunks.last(where: { $0.count == 4 })?.first)
XCTAssertNil(fruitChunks.first(where: { $0.count == 0 }))
XCTAssertNil(fruitChunks.last(where: { $0.count == 0 }))
}
func testSimple() {
// Example
let names = ["David", "Kyle", "Karoy", "Nate"]
@@ -51,9 +51,10 @@ final class ChunkedTests: XCTestCase {
let expected: [(Character, ArraySlice<String>)] = [
("D", ["David"]),
("K", ["Kyle", "Karoy"]),
("N", ["Nate"])]
XCTAssertEqualSequences(expected, chunks, by: ==)
("N", ["Nate"]),
]
expectEqualSequences(expected, chunks, by: ==)
// Empty sequence
XCTAssertEqual(0, names.prefix(0).chunked(on: { $0.first }).count)
@@ -61,10 +62,10 @@ final class ChunkedTests: XCTestCase {
let namesStartingWithD = ["David", "Don", "Darren"]
XCTAssertEqual(1, namesStartingWithD.chunked(on: { $0.first }).count)
}
func testChunkedOn() {
validateFruitChunks(fruits.chunked(on: { $0.first }).map { $1 })
let lazyChunks = fruits.lazy.chunked(on: { $0.first })
validateFruitChunks(lazyChunks.map { $1 })
IndexValidator().validate(lazyChunks)
@@ -72,76 +73,83 @@ final class ChunkedTests: XCTestCase {
func testChunkedBy() {
validateFruitChunks(fruits.chunked(by: { $0.first == $1.first }))
let lazyChunks = fruits.lazy.chunked(by: { $0.first == $1.first })
validateFruitChunks(lazyChunks)
IndexValidator().validate(lazyChunks)
}
func testChunkedByComparesConsecutiveElements() {
XCTAssertEqualSequences(
expectEqualSequences(
[1, 2, 3, 4, 6, 7, 8, 9].chunked(by: { $1 - $0 == 1 }),
[[1, 2, 3, 4], [6, 7, 8, 9]])
XCTAssertEqualSequences(
expectEqualSequences(
[1, 2, 3, 4, 6, 7, 8, 9].lazy.chunked(by: { $1 - $0 == 1 }),
[[1, 2, 3, 4], [6, 7, 8, 9]])
print(Array([1, 2, 3].lazy.chunked(by: { $1 - $0 == 1 })))
print(Array([1, 2, 3].lazy.chunked(by: { $1 - $0 == 1 }).reversed()))
XCTAssertEqualSequences(
expectEqualSequences(
[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 }))
}
func testChunkedLazy() {
XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
requireLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
requireLazySequence(fruits.lazy.chunked(on: { $0.first }))
}
//===----------------------------------------------------------------------===//
// Tests for `chunks(ofCount:)`
//===----------------------------------------------------------------------===//
func testChunksOfCount() {
XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
expectEqualSequences([Int]().chunks(ofCount: 1), [])
expectEqualSequences([Int]().chunks(ofCount: 5), [])
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
XCTAssertEqualSequences(collection1.chunks(ofCount: 1),
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 5),
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 11),
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
expectEqualSequences(
collection1.chunks(ofCount: 1),
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
expectEqualSequences(
collection1.chunks(ofCount: 3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
expectEqualSequences(
collection1.chunks(ofCount: 5),
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
expectEqualSequences(
collection1.chunks(ofCount: 11),
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
XCTAssertEqualSequences(collection2.chunks(ofCount: 3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
expectEqualSequences(
collection2.chunks(ofCount: 3),
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
}
func testChunksOfCountBidirectional() {
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
XCTAssertEqualSequences(collection1.chunks(ofCount: 1).reversed(),
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 3).reversed(),
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 5).reversed(),
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
XCTAssertEqualSequences(collection1.chunks(ofCount: 11).reversed(),
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
expectEqualSequences(
collection1.chunks(ofCount: 1).reversed(),
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
expectEqualSequences(
collection1.chunks(ofCount: 3).reversed(),
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
expectEqualSequences(
collection1.chunks(ofCount: 5).reversed(),
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
expectEqualSequences(
collection1.chunks(ofCount: 11).reversed(),
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
XCTAssertEqualSequences(collection2.chunks(ofCount: 3).reversed(),
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
expectEqualSequences(
collection2.chunks(ofCount: 3).reversed(),
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
}
func testChunksOfCountCount() {
XCTAssertEqual([Int]().chunks(ofCount: 1).count, 0)
XCTAssertEqual([Int]().chunks(ofCount: 5).count, 0)
@@ -151,20 +159,20 @@ final class ChunkedTests: XCTestCase {
XCTAssertEqual(collection1.chunks(ofCount: 3).count, 4)
XCTAssertEqual(collection1.chunks(ofCount: 5).count, 2)
XCTAssertEqual(collection1.chunks(ofCount: 11).count, 1)
let collection2 = (1...50).map { $0 }
XCTAssertEqual(collection2.chunks(ofCount: 9).count, 6)
}
func testEmptyChunksOfCountTraversal() {
let emptyChunks = [Int]().chunks(ofCount: 1)
IndexValidator().validate(emptyChunks, expectedCount: 0)
}
func testChunksOfCountTraversal() {
let validator = IndexValidator<ChunksOfCountCollection<ClosedRange<Int>>>()
for i in 1...10 {
let range = 1...50
let chunks = range.chunks(ofCount: i)
@@ -173,4 +181,39 @@ final class ChunkedTests: XCTestCase {
expectedCount: range.count / i + (range.count % i).signum())
}
}
func testEvenChunks() {
expectEqualSequences(
(0..<10).evenlyChunked(in: 4),
[0..<3, 3..<6, 6..<8, 8..<10])
expectEqualSequences(
(0..<3).evenlyChunked(in: 5),
[0..<1, 1..<2, 2..<3, 3..<3, 3..<3])
expectEqualSequences(
"".evenlyChunked(in: 0),
[])
expectEqualSequences(
"".evenlyChunked(in: 1),
[""])
}
func testEvenChunksIndexTraversals() {
let validator = IndexValidator<EvenlyChunkedCollection<Range<Int>>>()
for chunks in [
(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),
] {
validator.validate(chunks)
}
}
}
@@ -9,118 +9,146 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class CombinationsTests: XCTestCase {
func testCount() {
let c = "ABCD"
let c0 = c.combinations(ofCount: 0).count
XCTAssertEqual(c0, 1)
let c1 = c.combinations(ofCount: 1).count
XCTAssertEqual(c1, 4)
let c2 = c.combinations(ofCount: 2).count
XCTAssertEqual(c2, 6)
let c3 = c.combinations(ofCount: 3).count
XCTAssertEqual(c3, 4)
let c4 = c.combinations(ofCount: 4).count
XCTAssertEqual(c4, 1)
let c5 = c.combinations(ofCount: 0...0).count
XCTAssertEqual(c5, 1)
let c6 = c.combinations(ofCount: 1...1).count
XCTAssertEqual(c6, 4)
let c7 = c.combinations(ofCount: 1...2).count
XCTAssertEqual(c7, 10)
let c8 = c.combinations(ofCount: 1...3).count
XCTAssertEqual(c8, 14)
let c9 = c.combinations(ofCount: 2...4).count
XCTAssertEqual(c9, 11)
/// XCTAsserts that `x`'s `count` and `underestimatedCount` are both `l` at
/// the given `file` and `line`.
func check(
_ x: CombinationsSequence<String>, countsAre l: Int,
file: StaticString, line: UInt
) {
XCTAssertEqual(x.count, l, "unexpected count", file: file, line: line)
XCTAssertEqual(
x.underestimatedCount, l, "unexpected underestimatedCount",
file: file, line: line)
}
/// XCTAsserts that the `count` and `underestimatedCount` of
/// `c.combinations(ofCount: l)` are both `n` at the given `file` and
/// `line`.
func check(
cHas n: Int,
combinationsOfLength l: Int,
file: StaticString = #filePath, line: UInt = #line
) {
check(c.combinations(ofCount: l), countsAre: n, file: file, line: line)
}
/// XCTAsserts that the `count` and `underestimatedCount` of
/// `c.combinations(ofCount: l)` are both `n` at the given `file` and
/// `line`.
func check<R: RangeExpression>(
cHas n: Int,
combinationsOfLengths l: R,
file: StaticString = #filePath, line: UInt = #line
) where R.Bound == Int {
check(c.combinations(ofCount: l), countsAre: n, file: file, line: line)
}
check(cHas: 1, combinationsOfLength: 0)
check(cHas: 4, combinationsOfLength: 1)
check(cHas: 6, combinationsOfLength: 2)
check(cHas: 1, combinationsOfLength: 4)
check(cHas: 1, combinationsOfLengths: 0...0)
check(cHas: 4, combinationsOfLengths: 1...1)
check(cHas: 10, combinationsOfLengths: 1...2)
check(cHas: 14, combinationsOfLengths: 1...3)
check(cHas: 11, combinationsOfLengths: 2...4)
// `k` greater than element count results in same number of combinations
let c10 = c.combinations(ofCount: 3...10).count
XCTAssertEqual(c10, 5)
check(cHas: 5, combinationsOfLengths: 3...10)
// `k` greater than element count results in same number of combinations
let c11 = c.combinations(ofCount: 4...10).count
XCTAssertEqual(c11, 1)
check(cHas: 1, combinationsOfLengths: 4...10)
// `k` entirely greater than element count results in no combinations
let c12 = c.combinations(ofCount: 5...10).count
XCTAssertEqual(c12, 0)
let c13 = c.combinations(ofCount: 0...).count
XCTAssertEqual(c13, 16)
let c14 = c.combinations(ofCount: ...3).count
XCTAssertEqual(c14, 15)
let c15 = c.combinations(ofCount: 0...).count
XCTAssertEqual(c15, 16)
check(cHas: 0, combinationsOfLengths: 5...10)
check(cHas: 16, combinationsOfLengths: 0...)
check(cHas: 15, combinationsOfLengths: ...3)
}
func testCombinations() {
let c = "ABCD"
let c1 = c.combinations(ofCount: 1)
XCTAssertEqual(["A", "B", "C", "D"], c1.map { String($0) })
let c2 = c.combinations(ofCount: 2)
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD"], c2.map { String($0) })
let c3 = c.combinations(ofCount: 3)
XCTAssertEqual(["ABC", "ABD", "ACD", "BCD"], c3.map { String($0) })
let c4 = c.combinations(ofCount: 4)
XCTAssertEqual(["ABCD"], c4.map { String($0) })
let c5 = c.combinations(ofCount: 2...4)
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c5.map { String($0) })
XCTAssertEqual(
["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"],
c5.map { String($0) })
let c6 = c.combinations(ofCount: 0...4)
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c6.map { String($0) })
XCTAssertEqual(
[
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC",
"ABD", "ACD", "BCD", "ABCD",
], c6.map { String($0) })
let c7 = c.combinations(ofCount: 0...)
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c7.map { String($0) })
XCTAssertEqual(
[
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC",
"ABD", "ACD", "BCD", "ABCD",
], c7.map { String($0) })
let c8 = c.combinations(ofCount: ...4)
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c8.map { String($0) })
XCTAssertEqual(
[
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC",
"ABD", "ACD", "BCD", "ABCD",
], c8.map { String($0) })
let c9 = c.combinations(ofCount: ...3)
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD"], c9.map { String($0) })
XCTAssertEqual(
[
"", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC",
"ABD", "ACD", "BCD",
], c9.map { String($0) })
let c10 = c.combinations(ofCount: 1...)
XCTAssertEqual(["A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c10.map { String($0) })
XCTAssertEqual(
[
"A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD",
"ACD", "BCD", "ABCD",
], c10.map { String($0) })
}
func testEmpty() {
// `k == 0` results in one zero-length combination
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0))
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0...0))
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0))
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
expectEqualSequences([[]], "".combinations(ofCount: 0))
expectEqualSequences([[]], "".combinations(ofCount: 0...0))
expectEqualSequences([[]], "ABCD".combinations(ofCount: 0))
expectEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
// `k` greater than element count results in zero combinations
XCTAssertEqualSequences([], "".combinations(ofCount: 5))
XCTAssertEqualSequences([], "".combinations(ofCount: 5...10))
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5))
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5...10))
expectEqualSequences([], "".combinations(ofCount: 5))
expectEqualSequences([], "".combinations(ofCount: 5...10))
expectEqualSequences([], "ABCD".combinations(ofCount: 5))
expectEqualSequences([], "ABCD".combinations(ofCount: 5...10))
}
func testCombinationsLazy() {
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...))
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: ...3))
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 0...))
requireLazySequence("ABC".lazy.combinations(ofCount: 1))
requireLazySequence("ABC".lazy.combinations(ofCount: 1...3))
requireLazySequence("ABC".lazy.combinations(ofCount: 1...))
requireLazySequence("ABC".lazy.combinations(ofCount: ...3))
requireLazySequence("ABC".lazy.combinations(ofCount: 0...))
}
}
@@ -9,33 +9,34 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class CompactedTests: XCTestCase {
let tests: [[Int?]] =
[nil, nil, nil, 0, 1, 2]
.uniquePermutations(ofCount: 0...)
.map(Array.init)
.uniquePermutations(ofCount: 0...)
.map(Array.init)
func testCompactedCompacted() {
for collection in self.tests {
let seq = AnySequence(collection)
XCTAssertEqualSequences(
expectEqualSequences(
seq.compactMap({ $0 }), seq.compacted())
XCTAssertEqualSequences(
expectEqualSequences(
collection.compactMap({ $0 }), collection.compacted())
}
}
func testCompactedBidirectionalCollection() {
for array in self.tests {
XCTAssertEqualSequences(array.compactMap({ $0 }).reversed(),
array.compacted().reversed())
expectEqualSequences(
array.compactMap({ $0 }).reversed(),
array.compacted().reversed())
}
}
func testCollectionTraversals() {
let validator = IndexValidator<CompactedCollection<[Int?], Int>>()
for array in self.tests {
+8 -7
View File
@@ -9,13 +9,13 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class CycleTests: XCTestCase {
func testCycle() {
let cycle = (1...4).cycled()
XCTAssertEqualSequences(
expectEqualSequences(
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
cycle.prefix(20)
)
@@ -32,12 +32,12 @@ final class CycleTests: XCTestCase {
}
func testCycleLazy() {
XCTAssertLazySequence((1...4).lazy.cycled())
requireLazySequence((1...4).lazy.cycled())
}
func testRepeated() {
let repeats = (1...4).cycled(times: 3)
XCTAssertEqualSequences(
expectEqualSequences(
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
repeats)
}
@@ -58,7 +58,7 @@ final class CycleTests: XCTestCase {
}
func testRepeatedLazy() {
XCTAssertLazySequence((1...4).lazy.cycled(times: 3))
requireLazySequence((1...4).lazy.cycled(times: 3))
}
func testRepeatedIndexMethods() {
@@ -73,8 +73,9 @@ final class CycleTests: XCTestCase {
nextIndex = cycle.index(nextIndex, offsetBy: 2, limitedBy: cycle.endIndex)!
XCTAssertEqual(cycle.distance(from: startIndex, to: nextIndex), 8)
let outOfBounds = cycle.index(nextIndex, offsetBy: 1,
limitedBy: cycle.endIndex)
let outOfBounds = cycle.index(
nextIndex, offsetBy: 1,
limitedBy: cycle.endIndex)
XCTAssertNil(outOfBounds)
let previousIndex = cycle.index(before: nextIndex)
@@ -0,0 +1,97 @@
//===----------------------------------------------------------------------===//
//
// 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 Algorithms
import XCTest
final class EndsWithTests: XCTestCase {
func testEndsWithCorrectSuffix() {
let a = 8...10
let b = 1...10
XCTAssertTrue(b.ends(with: a))
}
func testDoesntEndWithWrongSuffix() {
let a = 8...9
let b = 1...10
XCTAssertFalse(b.ends(with: a))
}
func testDoesntEndWithTooLongSuffix() {
XCTAssertFalse((2...5).ends(with: (1...10)))
}
func testEndsWithEmpty() {
let a = 8...10
let empty: [Int] = []
XCTAssertTrue(a.ends(with: empty))
}
func testEmptyEndsWithEmpty() {
let empty: [Int] = []
XCTAssertTrue(empty.ends(with: empty))
}
func testEmptyDoesNotEndWithNonempty() {
XCTAssertFalse([].ends(with: 1...10))
}
}
final class EndsWithNonEquatableTests: XCTestCase {
func testEndsWithCorrectSuffix() {
let a = nonEq(8...10)
let b = nonEq(1...10)
XCTAssertTrue(b.ends(with: a, by: areEquivalent))
}
func testDoesntEndWithWrongSuffix() {
let a = nonEq(8...9)
let b = nonEq(1...10)
XCTAssertFalse(b.ends(with: a, by: areEquivalent))
}
func testDoesntEndWithTooLongSuffix() {
XCTAssertFalse(nonEq(2...5).ends(with: nonEq(1...10), by: areEquivalent))
}
func testEndsWithEmpty() {
let a = nonEq(8...10)
let empty: [NotEquatable<Int>] = []
XCTAssertTrue(a.ends(with: empty, by: areEquivalent))
}
func testEmptyEndsWithEmpty() {
let empty: [NotEquatable<Int>] = []
XCTAssertTrue(empty.ends(with: empty, by: areEquivalent))
}
func testEmptyDoesNotEndWithNonempty() {
XCTAssertFalse([].ends(with: nonEq(1...10), by: areEquivalent))
}
private func nonEq(_ range: ClosedRange<Int>) -> [NotEquatable<Int>] {
range.map(NotEquatable.init)
}
private func areEquivalent<T: Equatable>(
lhs: NotEquatable<T>, rhs: NotEquatable<T>
) -> Bool {
lhs.value == rhs.value
}
private struct NotEquatable<T> {
let value: T
}
}
@@ -9,8 +9,8 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class FirstNonNilTests: XCTestCase {
func testFirstNonNil() {
@@ -0,0 +1,46 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import Algorithms
import XCTest
final class GroupedTests: XCTestCase {
private final class SampleError: Error {}
// Based on https://github.com/apple/swift/blob/4d1d8a9de5ebc132a17aee9fc267461facf89bf8/validation-test/stdlib/Dictionary.swift#L1974-L1988
func testGroupedBy() {
let r = 0..<10
let d1 = r.grouped(by: { $0 % 3 })
XCTAssertEqual(3, d1.count)
XCTAssertEqual(d1[0]!, [0, 3, 6, 9])
XCTAssertEqual(d1[1]!, [1, 4, 7])
XCTAssertEqual(d1[2]!, [2, 5, 8])
let d2 = r.grouped(by: { $0 })
XCTAssertEqual(10, d2.count)
let d3 = (0..<0).grouped(by: { $0 })
XCTAssertEqual(0, d3.count)
}
func testThrowingFromKeyFunction() {
let input = ["Apple", "Banana", "Cherry"]
let error = SampleError()
XCTAssertThrowsError(
try input.grouped(by: { (_: String) -> Character in throw error })
) { thrownError in
XCTAssertIdentical(error, thrownError as? SampleError)
}
}
}
@@ -9,8 +9,8 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class IndexedTests: XCTestCase {
func testIndexed() {
@@ -27,8 +27,8 @@ final class IndexedTests: XCTestCase {
let indexOfI = si.last(where: { $0.element == "I" })!.index
XCTAssertEqual("I", s[indexOfI])
}
func testIndexedLazy() {
XCTAssertLazyCollection("ABCD".lazy.indexed())
requireLazyCollection("ABCD".lazy.indexed())
}
}
@@ -10,49 +10,50 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class IntersperseTests: XCTestCase {
func testSequence() {
let interspersed = (1...).prefix(5).interspersed(with: 0)
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4,0,5])
expectEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4, 0, 5])
}
func testSequenceEmpty() {
let interspersed = (1...).prefix(0).interspersed(with: 0)
XCTAssertEqualSequences(interspersed, [])
expectEqualSequences(interspersed, [])
}
func testString() {
let interspersed = "ABCDE".interspersed(with: "-")
XCTAssertEqualSequences(interspersed, "A-B-C-D-E")
expectEqualSequences(interspersed, "A-B-C-D-E")
}
func testStringEmpty() {
let interspersed = "".interspersed(with: "-")
XCTAssertEqualSequences(interspersed, "")
expectEqualSequences(interspersed, "")
}
func testArray() {
let interspersed = [1,2,3,4].interspersed(with: 0)
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4])
let interspersed = [1, 2, 3, 4].interspersed(with: 0)
expectEqualSequences(interspersed, [1, 0, 2, 0, 3, 0, 4])
}
func testArrayEmpty() {
let interspersed = [].interspersed(with: 0)
XCTAssertEqualSequences(interspersed, [])
expectEqualSequences(interspersed, [])
}
func testCollection() {
let interspersed = ["A","B","C","D"].interspersed(with: "-")
let interspersed = ["A", "B", "C", "D"].interspersed(with: "-")
XCTAssertEqual(interspersed.count, 7)
}
func testBidirectionalCollection() {
let reversed = "ABCDE".interspersed(with: "-").reversed()
XCTAssertEqualSequences(reversed, "E-D-C-B-A")
expectEqualSequences(reversed, "E-D-C-B-A")
}
func testIndexTraversals() {
let validator = IndexValidator<InterspersedSequence<String>>()
validator.validate("".interspersed(with: "-"), expectedCount: 0)
@@ -62,42 +63,44 @@ final class IntersperseTests: XCTestCase {
}
func testIntersperseLazy() {
XCTAssertLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
XCTAssertLazyCollection("ABCDE".lazy.interspersed(with: "-"))
requireLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
requireLazyCollection("ABCDE".lazy.interspersed(with: "-"))
}
func testInterspersedMap() {
XCTAssertEqualSequences(
expectEqualSequences(
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
[])
XCTAssertEqualSequences(
expectEqualSequences(
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
[0])
XCTAssertEqualSequences(
expectEqualSequences(
(0..<5).lazy.interspersedMap({ $0 }, with: { $0 + $1 + 100 }),
[0, 101, 1, 103, 2, 105, 3, 107, 4])
}
func testInterspersedMapLazy() {
XCTAssertLazySequence(AnySequence([]).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
XCTAssertLazyCollection((0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
requireLazySequence(
AnySequence([]).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
requireLazyCollection(
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }))
}
func testInterspersedMapIndexTraversals() {
let validator = IndexValidator<InterspersedMapSequence<Range<Int>, Int>>()
validator.validate(
(0..<0).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
(0..<0).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
expectedCount: 0)
validator.validate(
(0..<1).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
(0..<1).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
expectedCount: 1)
validator.validate(
(0..<2).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
(0..<2).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
expectedCount: 3)
validator.validate(
(0..<5).lazy.interspersedMap({ $0 }, with: {_, _ in 100 }),
(0..<5).lazy.interspersedMap({ $0 }, with: { _, _ in 100 }),
expectedCount: 9)
}
}
+64 -98
View File
@@ -10,6 +10,7 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class JoinedTests: XCTestCase {
@@ -21,161 +22,126 @@ final class JoinedTests: XCTestCase {
["foo", "bar"],
["", "", "foo", "", "bar", "baz", ""],
]
func testJoined() {
let expected = ["", "", "", "foo", "foobar", "foobarbaz"]
for (strings, expected) in zip(stringArrays, expected) {
// regular sequence
XCTAssertEqualSequences(AnySequence(strings).joined(), expected)
expectEqualSequences(AnySequence(strings).joined(), expected)
// lazy sequence
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(), expected)
expectEqualSequences(AnySequence(strings).lazy.joined(), expected)
// regular collection
XCTAssertEqualSequences(strings.joined(), expected)
expectEqualSequences(strings.joined(), expected)
// lazy collection
XCTAssertEqualSequences(strings.lazy.joined() as FlattenCollection, expected)
expectEqualSequences(
strings.lazy.joined() as FlattenCollection, expected)
}
}
func testJoinedByElement() {
let separator: Character = " "
let expected = ["", "", " ", "foo", "foo bar", " foo bar baz "]
for (strings, expected) in zip(stringArrays, expected) {
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
XCTAssertEqualSequences(strings.joined(by: separator), expected)
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).lazy.joined(by: separator), expected)
expectEqualSequences(strings.joined(by: separator), expected)
expectEqualSequences(strings.lazy.joined(by: separator), expected)
}
}
func testJoinedBySequence() {
let separator = ", "
let expected = ["", "", ", ", "foo", "foo, bar", ", , foo, , bar, baz, "]
for (strings, expected) in zip(stringArrays, expected) {
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
XCTAssertEqualSequences(strings.joined(by: separator), expected)
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).lazy.joined(by: separator), expected)
expectEqualSequences(strings.joined(by: separator), expected)
expectEqualSequences(strings.lazy.joined(by: separator), expected)
}
}
func testJoinedByElementClosure() {
let separator = { (left: String, right: String) -> Character in
left.isEmpty || right.isEmpty ? " " : "-"
}
let expected = ["", "", " ", "foo", "foo-bar", " foo bar-baz "]
for (strings, expected) in zip(stringArrays, expected) {
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
XCTAssertEqualSequences(strings.joined(by: separator), expected)
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).lazy.joined(by: separator), expected)
expectEqualSequences(strings.joined(by: separator), expected)
expectEqualSequences(strings.lazy.joined(by: separator), expected)
}
}
func testJoinedBySequenceClosure() {
let separator = { (left: String, right: String) in
"(\(left.count), \(right.count))"
}
let expected = [
"",
"",
"(0, 0)",
"foo",
"foo(3, 3)bar",
"(0, 0)(0, 3)foo(3, 0)(0, 3)bar(3, 3)baz(3, 0)"
"(0, 0)(0, 3)foo(3, 0)(0, 3)bar(3, 3)baz(3, 0)",
]
for (strings, expected) in zip(stringArrays, expected) {
XCTAssertEqualSequences(AnySequence(strings).joined(by: separator), expected)
XCTAssertEqualSequences(AnySequence(strings).lazy.joined(by: separator), expected)
XCTAssertEqualSequences(strings.joined(by: separator), expected)
XCTAssertEqualSequences(strings.lazy.joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).joined(by: separator), expected)
expectEqualSequences(
AnySequence(strings).lazy.joined(by: separator), expected)
expectEqualSequences(strings.joined(by: separator), expected)
expectEqualSequences(strings.lazy.joined(by: separator), expected)
}
}
func testJoinedLazy() {
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined())
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: 1))
XCTAssertLazySequence(AnySequence([[1], [2]]).lazy.joined(by: { _, _ in 1 }))
XCTAssertLazyCollection([[1], [2]].lazy.joined())
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: 1))
XCTAssertLazyCollection([[1], [2]].lazy.joined(by: { _, _ in 1 }))
requireLazySequence(AnySequence([[1], [2]]).lazy.joined())
requireLazySequence(AnySequence([[1], [2]]).lazy.joined(by: 1))
requireLazySequence(
AnySequence([[1], [2]]).lazy.joined(by: { _, _ in 1 }))
requireLazyCollection([[1], [2]].lazy.joined())
requireLazyCollection([[1], [2]].lazy.joined(by: 1))
requireLazyCollection([[1], [2]].lazy.joined(by: { _, _ in 1 }))
}
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)
}
}
func testJoinedByIndexTraversals() {
let validator1 = IndexValidator<JoinedByCollection<[String], String>>()
let validator2 = IndexValidator<JoinedByClosureCollection<[String], String>>()
let validator2 = IndexValidator<
JoinedByClosureCollection<[String], String>
>()
// the last test case takes too long to run
for (strings, separator) in product(stringArrays.dropLast(), ["", " ", ", "]) {
for (strings, separator) in product(
stringArrays.dropLast(), ["", " ", ", "])
{
validator1.validate(strings.joined(by: separator))
validator2.validate(strings.lazy.joined(by: { _, _ in separator }))
}
}
func testJoinedPrefixSuffix() {
let input = [
[5,3,0, 0,7,0, 0,0,0],
[6,0,0, 1,9,5, 0,0,0],
[0,9,8, 0,0,0, 0,6,0],
[8,0,0, 0,6,0, 0,0,3],
[4,0,0, 8,0,3, 0,0,1],
[7,0,0, 0,2,0, 0,0,6],
[0,6,0, 0,0,0, 2,8,0],
[0,0,0, 4,1,9, 0,0,5],
[0,0,0, 0,8,0, 0,7,9],
]
func prettyString(_ sudoku: [[Int]]) -> String {
sudoku.chunks(ofCount: 3).map { (bigChunk: ArraySlice<[Int]>) -> String in
bigChunk.map { (row: [Int]) -> String in
row.chunks(ofCount: 3).map { (smallChunk: ArraySlice<Int>) -> String in
smallChunk.lazy.map(String.init).joined(separator: " ", prefix: " ", suffix: " ")
}.joined(separator: "|", prefix: "|", suffix: "|")
}.joined(separator: "\n")
}.joined(
separator: "\n+-------+-------+-------+\n",
prefix: "+-------+-------+-------+\n",
suffix: "\n+-------+-------+-------+")
}
let output = prettyString(input)
XCTAssertEqual(
output,
"""
+-------+-------+-------+
| 5 3 0 | 0 7 0 | 0 0 0 |
| 6 0 0 | 1 9 5 | 0 0 0 |
| 0 9 8 | 0 0 0 | 0 6 0 |
+-------+-------+-------+
| 8 0 0 | 0 6 0 | 0 0 3 |
| 4 0 0 | 8 0 3 | 0 0 1 |
| 7 0 0 | 0 2 0 | 0 0 6 |
+-------+-------+-------+
| 0 6 0 | 0 0 0 | 2 8 0 |
| 0 0 0 | 4 1 9 | 0 0 5 |
| 0 0 0 | 0 8 0 | 0 7 9 |
+-------+-------+-------+
"""
)
}
}
@@ -0,0 +1,93 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2020 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import Algorithms
import XCTest
final class KeyedTests: XCTestCase {
private final class SampleError: Error {}
func testUniqueKeys() {
let d = ["Apple", "Banana", "Cherry"].keyed(by: { $0.first! })
XCTAssertEqual(d.count, 3)
XCTAssertEqual(d["A"]!, "Apple")
XCTAssertEqual(d["B"]!, "Banana")
XCTAssertEqual(d["C"]!, "Cherry")
XCTAssertNil(d["D"])
}
func testEmpty() {
let d = EmptyCollection<String>().keyed(by: { $0.first! })
XCTAssertEqual(d.count, 0)
}
func testNonUniqueKeys() throws {
let d = ["Apple", "Avocado", "Banana", "Cherry"].keyed(by: { $0.first! })
XCTAssertEqual(d.count, 3)
XCTAssertEqual(
d["A"]!, "Avocado",
"On a key-collision, keyed(by:) should take the latest value.")
XCTAssertEqual(d["B"]!, "Banana")
XCTAssertEqual(d["C"]!, "Cherry")
}
func testNonUniqueKeysWithMergeFunction() {
var resolveCallHistory: [(key: Character, current: String, new: String)] =
[]
let expectedCallHistory = [
(key: "A", current: "Apple", new: "Avocado"),
(key: "C", current: "Cherry", new: "Coconut"),
]
let d = ["Apple", "Avocado", "Banana", "Cherry", "Coconut"].keyed(
by: { $0.first! },
resolvingConflictsWith: { key, older, newer in
resolveCallHistory.append((key, older, newer))
return "\(older)-\(newer)"
}
)
XCTAssertEqual(d.count, 3)
XCTAssertEqual(d["A"]!, "Apple-Avocado")
XCTAssertEqual(d["B"]!, "Banana")
XCTAssertEqual(d["C"]!, "Cherry-Coconut")
XCTAssertNil(d["D"])
// Quick/dirty workaround: tuples aren't Equatable
XCTAssertEqual(
resolveCallHistory.map(String.init(describing:)),
expectedCallHistory.map(String.init(describing:))
)
}
func testThrowingFromKeyFunction() {
let input = ["Apple", "Banana", "Cherry"]
let error = SampleError()
XCTAssertThrowsError(
try input.keyed(by: { (_: String) -> Character in throw error })
) { thrownError in
XCTAssertIdentical(error, thrownError as? SampleError)
}
}
func testThrowingFromCombineFunction() {
let input = ["Apple", "Avocado", "Banana", "Cherry"]
let error = SampleError()
XCTAssertThrowsError(
try input.keyed(
by: { $0.first! }, resolvingConflictsWith: { _, _, _ in throw error })
) { thrownError in
XCTAssertIdentical(error, thrownError as? SampleError)
}
}
}
+63 -55
View File
@@ -9,41 +9,41 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class SortedPrefixTests: XCTestCase {
func testMinCount() {
// Replacement at start and end
let input = [10, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 0, 7, 8, 9]
let min = input.min(count: 5)
XCTAssertEqualSequences(min, 0..<5)
expectEqualSequences(min, 0..<5)
// Stability with all equal values
let maxZeroes = Array(repeating: 0, count: 100)
.enumerated()
.max(count: 5, sortedBy: { $0.element < $1.element })
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
expectEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
}
func testMaxCount() {
// Replacement at start and end
let input = [0, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 7, 8, 9, 10]
let max = input.max(count: 5)
XCTAssertEqualSequences(max, 10..<15)
expectEqualSequences(max, 10..<15)
// Stability with all equal values
let maxZeroes = Array(repeating: 0, count: 100)
.enumerated()
.max(count: 5, sortedBy: { $0.element < $1.element })
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
expectEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
}
func testEmpty() {
let array = [Int]()
let array: [Int] = []
XCTAssertEqual(array.min(count: 0), [])
XCTAssertEqual(array.min(count: 100), [])
XCTAssertEqual(array.max(count: 0), [])
XCTAssertEqual(array.max(count: 100), [])
}
@@ -51,23 +51,23 @@ final class SortedPrefixTests: XCTestCase {
func testMinMaxSequences() {
let input = (1...100).shuffled().interspersed(with: 50)
let seq = AnySequence(input)
XCTAssertEqualSequences(seq.min(count: 0), [])
XCTAssertEqualSequences(seq.min(count: 5), 1...5)
XCTAssertEqualSequences(seq.max(count: 0), [])
XCTAssertEqualSequences(seq.max(count: 5), 96...100)
expectEqualSequences(seq.min(count: 0), [])
expectEqualSequences(seq.min(count: 5), 1...5)
expectEqualSequences(seq.max(count: 0), [])
expectEqualSequences(seq.max(count: 5), 96...100)
}
func testSortedPrefixComparable() {
let array: [Int] = [20, 1, 4, 70, 100, 2, 3, 7, 90]
XCTAssertEqual(array.min(count: 0), [])
XCTAssertEqual(array.min(count: 1), [1])
XCTAssertEqualSequences(array.min(count: 5), array.sorted().prefix(5))
expectEqualSequences(array.min(count: 5), array.sorted().prefix(5))
XCTAssertEqual(array.min(count: 10), array.sorted())
}
func testMinMaxWithHugeCount() {
XCTAssertEqual([4, 2, 1, 3].min(count: .max), [1, 2, 3, 4])
XCTAssertEqual([4, 2, 1, 3].max(count: .max), [1, 2, 3, 4])
@@ -83,20 +83,20 @@ final class SortedPrefixTests: XCTestCase {
XCTAssertEqual(input.min(count: 1, sortedBy: <), [range.lowerBound])
XCTAssertEqual(input.min(count: 1, sortedBy: >), [range.upperBound])
XCTAssertEqualSequences(input.min(count: 5, sortedBy: <), range.prefix(5))
XCTAssertEqualSequences(
expectEqualSequences(input.min(count: 5, sortedBy: <), range.prefix(5))
expectEqualSequences(
input.min(count: 5, sortedBy: >),
range.suffix(5).reversed())
XCTAssertEqualSequences(
expectEqualSequences(
input.min(count: 500, sortedBy: <),
range.prefix(500))
XCTAssertEqualSequences(
expectEqualSequences(
input.min(count: 500, sortedBy: >),
range.suffix(500).reversed())
XCTAssertEqualSequences(input.min(count: 1000, sortedBy: <), range)
XCTAssertEqualSequences(
expectEqualSequences(input.min(count: 1000, sortedBy: <), range)
expectEqualSequences(
input.min(count: 1000, sortedBy: >),
range.reversed())
}
@@ -111,52 +111,60 @@ final class SortedPrefixTests: XCTestCase {
XCTAssertEqual(input.max(count: 1, sortedBy: <), [range.upperBound])
XCTAssertEqual(input.max(count: 1, sortedBy: >), [range.lowerBound])
XCTAssertEqualSequences(input.max(count: 5, sortedBy: <), range.suffix(5))
XCTAssertEqualSequences(
expectEqualSequences(input.max(count: 5, sortedBy: <), range.suffix(5))
expectEqualSequences(
input.max(count: 5, sortedBy: >),
range.prefix(5).reversed())
XCTAssertEqualSequences(
expectEqualSequences(
input.max(count: 500, sortedBy: <),
range.suffix(500))
XCTAssertEqualSequences(
expectEqualSequences(
input.max(count: 500, sortedBy: >),
range.prefix(500).reversed())
XCTAssertEqualSequences(input.max(count: 1000, sortedBy: <), range)
XCTAssertEqualSequences(
expectEqualSequences(input.max(count: 1000, sortedBy: <), range)
expectEqualSequences(
input.max(count: 1000, sortedBy: >),
range.reversed())
}
func testStability() {
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 3)
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 6)
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 20)
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 1000)
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 3)
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 6)
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 20)
assertStability([1, 1, 1, 2, 5, 7, 3, 6, 2, 5, 7, 3, 6], withCount: 1000)
assertStability(Array(repeating: 0, count: 100), withCount: 0)
assertStability(Array(repeating: 0, count: 100), withCount: 1)
assertStability(Array(repeating: 0, count: 100), withCount: 2)
assertStability(Array(repeating: 0, count: 100), withCount: 5)
assertStability(Array(repeating: 0, count: 100), withCount: 20)
assertStability(Array(repeating: 0, count: 100), withCount: 100)
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 2)
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 5)
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 20)
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 50)
assertStability([0,0], withCount: 1)
assertStability([0,0], withCount: 2)
assertStability([0,1,0,1,0,1], withCount: 2)
assertStability([0,1,0,1,0,1], withCount: 6)
assertStability([0,0,0,1,1,1], withCount: 1)
assertStability([0,0,0,1,1,1], withCount: 3)
assertStability([0,0,0,1,1,1], withCount: 4)
assertStability([0,0,0,1,1,1], withCount: 6)
assertStability([1,1,1,0,0,0], withCount: 1)
assertStability([1,1,1,0,0,0], withCount: 3)
assertStability([1,1,1,0,0,0], withCount: 4)
assertStability([1,1,1,0,0,0], withCount: 6)
assertStability([1,1,1,0,0,0], withCount: 5)
assertStability(
Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50),
withCount: 2)
assertStability(
Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50),
withCount: 5)
assertStability(
Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50),
withCount: 20)
assertStability(
Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50),
withCount: 50)
assertStability([0, 0], withCount: 1)
assertStability([0, 0], withCount: 2)
assertStability([0, 1, 0, 1, 0, 1], withCount: 2)
assertStability([0, 1, 0, 1, 0, 1], withCount: 6)
assertStability([0, 0, 0, 1, 1, 1], withCount: 1)
assertStability([0, 0, 0, 1, 1, 1], withCount: 3)
assertStability([0, 0, 0, 1, 1, 1], withCount: 4)
assertStability([0, 0, 0, 1, 1, 1], withCount: 6)
assertStability([1, 1, 1, 0, 0, 0], withCount: 1)
assertStability([1, 1, 1, 0, 0, 0], withCount: 3)
assertStability([1, 1, 1, 0, 0, 0], withCount: 4)
assertStability([1, 1, 1, 0, 0, 0], withCount: 6)
assertStability([1, 1, 1, 0, 0, 0], withCount: 5)
}
func assertStability(
@@ -165,19 +173,19 @@ final class SortedPrefixTests: XCTestCase {
) {
func stableOrder(
a: (offset: Int, element: Int),
b: (offset: Int, element: Int)) -> Bool
{
b: (offset: Int, element: Int)
) -> Bool {
a.element == b.element
? a.offset < b.offset
: a.element < b.element
}
do {
let sorted = actual.enumerated()
.min(count: count) { $0.element < $1.element }
XCTAssert(sorted.isSorted(by: stableOrder))
}
do {
let sorted = actual.enumerated()
.max(count: count) { $0.element < $1.element }
+63 -47
View File
@@ -9,8 +9,8 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class PartitionTests: XCTestCase {
func testStablePartition() {
@@ -30,17 +30,17 @@ final class PartitionTests: XCTestCase {
var b = a
var r = b[p..<q].stablePartition(by: f)
XCTAssertEqualSequences(b[..<p], prefix)
XCTAssertEqualSequences(b[q...], suffix)
XCTAssertEqualSequences(b[p..<r], subrange.filter(notf))
XCTAssertEqualSequences(b[r..<q], subrange.filter(f))
expectEqualSequences(b[..<p], prefix)
expectEqualSequences(b[q...], suffix)
expectEqualSequences(b[p..<r], subrange.filter(notf))
expectEqualSequences(b[r..<q], subrange.filter(f))
b = a
r = b[p..<q].stablePartition(by: notf)
XCTAssertEqualSequences(b[..<p], prefix)
XCTAssertEqualSequences(b[q...], suffix)
XCTAssertEqualSequences(b[p..<r], subrange.filter(f))
XCTAssertEqualSequences(b[r..<q], subrange.filter(notf))
expectEqualSequences(b[..<p], prefix)
expectEqualSequences(b[q...], suffix)
expectEqualSequences(b[p..<r], subrange.filter(f))
expectEqualSequences(b[r..<q], subrange.filter(notf))
}
}
@@ -49,18 +49,18 @@ final class PartitionTests: XCTestCase {
let notf = { !f($0) }
var b = a
var r = b.stablePartition(by: f)
XCTAssertEqualSequences(b[..<r], a.filter(notf))
XCTAssertEqualSequences(b[r...], a.filter(f))
expectEqualSequences(b[..<r], a.filter(notf))
expectEqualSequences(b[r...], a.filter(f))
b = a
r = b.stablePartition(by: notf)
XCTAssertEqualSequences(b[..<r], a.filter(f))
XCTAssertEqualSequences(b[r...], a.filter(notf))
expectEqualSequences(b[..<r], a.filter(f))
expectEqualSequences(b[r...], a.filter(notf))
}
}
}
}
func testStablePartitionWithSubrange() {
for length in 10...20 {
let a = Array(0..<length)
@@ -72,13 +72,17 @@ final class PartitionTests: XCTestCase {
let p = b.stablePartition(subrange: partitionRange, by: condition)
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
XCTAssertEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
expectEqualSequences(
b[partitionRange.lowerBound..<p],
a[partitionRange].filter { !condition($0) })
expectEqualSequences(
b[p..<partitionRange.upperBound],
a[partitionRange].filter(condition))
}
}
}
}
func testPartitioningIndex() {
for i in 0..<7 {
for j in i..<11 {
@@ -91,27 +95,27 @@ final class PartitionTests: XCTestCase {
}
}
}
func testPartitioningIndexWithEmptyInput() {
let input: [Int] = []
let a = input.partitioningIndex(where: { _ in return true })
let a = input.partitioningIndex(where: { _ in true })
XCTAssertEqual(a, input.startIndex)
let b = input.partitioningIndex(where: { _ in return false })
let b = input.partitioningIndex(where: { _ in false })
XCTAssertEqual(b, input.endIndex)
}
func testPartitioningIndexWithOneEmptyPartition() {
let input: Range<Int> = (0 ..< 10)
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)
@@ -121,10 +125,14 @@ final class PartitionTests: XCTestCase {
let partitionRange = j..<i
let condition = { $0 < i - 1 }
let p = b.partition(subrange: partitionRange, by: condition)
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
expectEqualSequences(
b[partitionRange.lowerBound..<p],
a[partitionRange].filter { !condition($0) })
expectUnorderedEqualSequences(
b[p..<partitionRange.upperBound],
a[partitionRange].filter(condition))
}
}
}
@@ -141,51 +149,59 @@ final class PartitionTests: XCTestCase {
let condition = { $0 < i - 1 }
let p = b.partition(subrange: partitionRange, by: condition)
let bdcp = bdc.partition(subrange: partitionRange, by: condition)
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
expectEqualSequences(
b[partitionRange.lowerBound..<p],
a[partitionRange].filter { !condition($0) })
expectUnorderedEqualSequences(
b[p..<partitionRange.upperBound],
a[partitionRange].filter(condition))
// Must produce the same result as the `BidirectionalCollection` specialized overload.
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], bdc[partitionRange.lowerBound..<bdcp])
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], bdc[bdcp..<partitionRange.upperBound])
expectEqualSequences(
b[partitionRange.lowerBound..<p],
bdc[partitionRange.lowerBound..<bdcp])
expectUnorderedEqualSequences(
b[p..<partitionRange.upperBound],
bdc[bdcp..<partitionRange.upperBound])
}
}
}
}
func testPartitionedWithEmptyInput() {
let input: [Int] = []
let s0 = input.partitioned(by: { _ in return true })
let s0 = input.partitioned(by: { _ in true })
XCTAssertTrue(s0.0.isEmpty)
XCTAssertTrue(s0.1.isEmpty)
}
/// Test the example given in the `partitioned(by:)` documentation
/// 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"])
}
@@ -10,15 +10,16 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class PermutationsTests: XCTestCase {
func testPermutations() {
let c = "ABCDE"
func t(count: Int?) {
let p = c.permutations(ofCount: count)
let count = count ?? c.count
let permCount = c.count.factorial() / (c.count - count).factorial()
XCTAssertEqual(permCount, p.count)
@@ -26,20 +27,20 @@ final class PermutationsTests: XCTestCase {
XCTAssertTrue(p.allSatisfy { $0.count == count })
XCTAssertTrue(p.isSorted(by: { $0.lexicographicallyPrecedes($1) }))
}
func ts<R: RangeExpression>(count: R) where R.Bound == Int {
let p = count.relative(to: 0 ..< .max)
.clamped(to: 0 ..< c.count + 1)
.clamped(to: 0..<c.count + 1)
.flatMap {
c.permutations(ofCount: $0)
}
let p2 = c.permutations(ofCount: count)
XCTAssertEqual(p.count, p2.count)
XCTAssertEqualSequences(p, Array(p2))
expectEqualSequences(p, Array(p2))
}
t(count: 0)
t(count: 1)
t(count: 2)
@@ -47,7 +48,7 @@ final class PermutationsTests: XCTestCase {
t(count: 4)
t(count: 5)
t(count: nil)
ts(count: 0...0)
ts(count: 1...1)
ts(count: 0...1)
@@ -60,7 +61,7 @@ final class PermutationsTests: XCTestCase {
ts(count: ...4)
ts(count: ...6)
}
func testEmpty() {
// `k == 0` results in one zero-length permutation
XCTAssertEqual(1, "".permutations().count)
@@ -70,7 +71,7 @@ final class PermutationsTests: XCTestCase {
XCTAssertEqual(Array("".permutations(ofCount: 0)), [[]])
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0)), [[]])
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0...0)), [[]])
// `k` greater than element count results in zero permutations
XCTAssertEqual(0, "".permutations(ofCount: 5).count)
XCTAssertEqual(Array("".permutations(ofCount: 5)), [])
@@ -79,10 +80,10 @@ final class PermutationsTests: XCTestCase {
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5..<7)), [])
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5...)), [])
}
func testNextPermutation() {
var numbers = Array(1...7)
_ = numbers.nextPermutation()
XCTAssertEqual([1, 2, 3, 4, 5, 7, 6], numbers)
_ = numbers.nextPermutation()
@@ -95,110 +96,122 @@ final class PermutationsTests: XCTestCase {
XCTAssertEqual([1, 2, 3, 4, 7, 6, 5], numbers)
_ = numbers.nextPermutation()
XCTAssertEqual([1, 2, 3, 5, 4, 6, 7], numbers)
// Fast-forward to end of permutations.
while numbers.nextPermutation() {}
XCTAssertEqual([1, 2, 3, 4, 5, 6, 7], numbers)
}
func testPermutationsLazy() {
XCTAssertLazySequence("ABCD".lazy.permutations(ofCount: 2))
requireLazySequence("ABCD".lazy.permutations(ofCount: 2))
}
func testDocumentationExample1() {
// From Guides/Permutations.md
let numbers = [10, 20, 30]
let permutations = numbers.permutations()
XCTAssertEqualSequences(permutations, [
[10, 20, 30],
[10, 30, 20],
[20, 10, 30],
[20, 30, 10],
[30, 10, 20],
[30, 20, 10],
])
expectEqualSequences(
permutations,
[
[10, 20, 30],
[10, 30, 20],
[20, 10, 30],
[20, 30, 10],
[30, 10, 20],
[30, 20, 10],
])
}
func testDocumentationExample2() {
// From Guides/Permutations.md
let numbers = [10, 20, 30]
let permutations = numbers.permutations(ofCount: 2)
XCTAssertEqualSequences(permutations, [
[10, 20],
[10, 30],
[20, 10],
[20, 30],
[30, 10],
[30, 20],
])
expectEqualSequences(
permutations,
[
[10, 20],
[10, 30],
[20, 10],
[20, 30],
[30, 10],
[30, 20],
])
}
func testDocumentationExample3() {
// From Guides/Permutations.md
let numbers2 = [20, 10, 10]
let permutations = numbers2.permutations()
XCTAssertEqualSequences(permutations, [
[20, 10, 10],
[20, 10, 10],
[10, 20, 10],
[10, 10, 20],
[10, 20, 10],
[10, 10, 20],
])
expectEqualSequences(
permutations,
[
[20, 10, 10],
[20, 10, 10],
[10, 20, 10],
[10, 10, 20],
[10, 20, 10],
[10, 10, 20],
])
}
func testDocumentationExample4() {
// From Guides/Permutations.md
let numbers = [10, 20, 30]
let permutations = numbers.permutations(ofCount: 0...)
XCTAssertEqualSequences(permutations, [
[],
[10],
[20],
[30],
[10, 20],
[10, 30],
[20, 10],
[20, 30],
[30, 10],
[30, 20],
[10, 20, 30],
[10, 30, 20],
[20, 10, 30],
[20, 30, 10],
[30, 10, 20],
[30, 20, 10],
])
expectEqualSequences(
permutations,
[
[],
[10],
[20],
[30],
[10, 20],
[10, 30],
[20, 10],
[20, 30],
[30, 10],
[30, 20],
[10, 20, 30],
[10, 30, 20],
[20, 10, 30],
[20, 30, 10],
[30, 10, 20],
[30, 20, 10],
])
}
func testDocumentationExample5() {
// From Permutations.swift
let names = ["Alex", "Celeste", "Davide"]
let permutations = names.permutations(ofCount: 2)
XCTAssertEqualSequences(permutations, [
["Alex", "Celeste"],
["Alex", "Davide"],
["Celeste", "Alex"],
["Celeste", "Davide"],
["Davide", "Alex"],
["Davide", "Celeste"],
])
expectEqualSequences(
permutations,
[
["Alex", "Celeste"],
["Alex", "Davide"],
["Celeste", "Alex"],
["Celeste", "Davide"],
["Davide", "Alex"],
["Davide", "Celeste"],
])
}
func testDocumentationExample6() {
// From Permutations.swift
let names = ["Alex", "Celeste", "Davide"]
let permutations = names.permutations(ofCount: 1...2)
XCTAssertEqualSequences(permutations, [
["Alex"],
["Celeste"],
["Davide"],
["Alex", "Celeste"],
["Alex", "Davide"],
["Celeste", "Alex"],
["Celeste", "Davide"],
["Davide", "Alex"],
["Davide", "Celeste"],
])
expectEqualSequences(
permutations,
[
["Alex"],
["Celeste"],
["Davide"],
["Alex", "Celeste"],
["Alex", "Davide"],
["Celeste", "Alex"],
["Celeste", "Davide"],
["Davide", "Alex"],
["Davide", "Celeste"],
])
}
}
+11 -10
View File
@@ -10,34 +10,35 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class ProductTests: XCTestCase {
func testProduct() {
XCTAssertEqualSequences(
expectEqualSequences(
[(1, "A" as Character), (1, "B"), (2, "A"), (2, "B")],
product(1...2, "AB"),
by: ==)
XCTAssertEqualSequences(product(1...10, ""), [], by: ==)
XCTAssertEqualSequences(product("", 1...10), [], by: ==)
expectEqualSequences(product(1...10, ""), [], by: ==)
expectEqualSequences(product("", 1...10), [], by: ==)
}
func testProductReversed() {
XCTAssertEqualSequences(
expectEqualSequences(
[(2, "B" as Character), (2, "A"), (1, "B"), (1, "A")],
product(1...2, "AB").reversed(),
by: ==)
XCTAssertEqualSequences(product(1...10, "").reversed(), [], by: ==)
XCTAssertEqualSequences(product("", 1...10).reversed(), [], by: ==)
expectEqualSequences(product(1...10, "").reversed(), [], by: ==)
expectEqualSequences(product("", 1...10).reversed(), [], by: ==)
}
func testProductDistanceFromTo() {
let p = product([1, 2], "abc")
XCTAssertEqual(p.distance(from: p.startIndex, to: p.endIndex), 6)
}
func testProductIndexTraversals() {
let validator = IndexValidator<Product2Sequence<[Int], String>>(
indicesIncludingEnd: { product in
@@ -47,7 +48,7 @@ final class ProductTests: XCTestCase {
}
} + [.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)
@@ -10,16 +10,18 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
func validateRandomSamples<S: Sequence>(
_ samples: [Int: Int],
elements: S,
expectedValue: Int,
file: StaticString = #file, line: UInt = #line
file: StaticString = (#file), line: UInt = #line
) where S.Element == Int {
let expectedRange = ((expectedValue / 3) * 2) ... ((expectedValue / 3) * 4)
XCTAssertEqualSequences(samples.keys.sorted(), elements,
let expectedRange = ((expectedValue / 3) * 2)...((expectedValue / 3) * 4)
expectEqualSequences(
samples.keys.sorted(), elements,
file: file, line: line)
for v in samples.values {
XCTAssert(expectedRange.contains(v), file: file, line: line)
@@ -41,41 +43,44 @@ final class RandomSampleTests: XCTestCase {
result[x, default: 0] += 1
}
}
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
validateRandomSamples(
samples, elements: c, expectedValue: (k * iterations) / n)
}
func testRandomSampleCollection() {
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
for x in c.randomSample(count: k) {
result[x, default: 0] += 1
}
}
validateRandomSamples(samples, elements: c, expectedValue: (k * iterations) / n)
validateRandomSamples(
samples, elements: c, expectedValue: (k * iterations) / n)
}
func testRandomSampleSequence() {
let samples: [Int: Int] = (0..<iterations).reduce(into: [:]) { result, _ in
for x in s.randomSample(count: k) {
result[x, default: 0] += 1
}
}
validateRandomSamples(samples, elements: s, expectedValue: (k * iterations) / n)
validateRandomSamples(
samples, elements: s, expectedValue: (k * iterations) / n)
}
func testRandomSampleEdgeCases() {
XCTAssert(c.randomStableSample(count: 0).isEmpty)
XCTAssertEqualSequences(c.randomStableSample(count: n), c)
XCTAssertEqualSequences(c.randomStableSample(count: n * 2), c)
expectEqualSequences(c.randomStableSample(count: n), c)
expectEqualSequences(c.randomStableSample(count: n * 2), c)
XCTAssert(c.randomSample(count: 0).isEmpty)
XCTAssertEqualSequences(c.randomSample(count: n).sorted(), c)
XCTAssertEqualSequences(c.randomSample(count: n * 2).sorted(), c)
expectEqualSequences(c.randomSample(count: n).sorted(), c)
expectEqualSequences(c.randomSample(count: n * 2).sorted(), c)
XCTAssert(s.randomSample(count: 0).isEmpty)
XCTAssertEqualSequences(s.randomSample(count: n).sorted(), c)
XCTAssertEqualSequences(s.randomSample(count: n * 2).sorted(), c)
expectEqualSequences(s.randomSample(count: n).sorted(), c)
expectEqualSequences(s.randomSample(count: n * 2).sorted(), c)
}
func testRandomSampleRepeatable() {
var generator = SplitMix64(seed: 0)
let sample1a = c.randomSample(count: k, using: &generator)
@@ -88,7 +93,7 @@ final class RandomSampleTests: XCTestCase {
generator = SplitMix64(seed: 0)
let sample2b = s.randomSample(count: k, using: &generator)
XCTAssertEqual(sample1b, sample2b)
generator = SplitMix64(seed: 0)
let sample1c = c.randomStableSample(count: k, using: &generator)
generator = SplitMix64(seed: 0)
@@ -101,7 +106,7 @@ final class RandomSampleTests: XCTestCase {
mutating func next() -> UInt64 { 0 }
}
var zero = ZeroGenerator()
_ = nextOffset(w: 1, using: &zero) // must not crash
_ = nextOffset(w: 1, using: &zero) // must not crash
struct AlmostAllZeroGenerator: RandomNumberGenerator {
private var forward: SplitMix64
@@ -119,8 +124,8 @@ final class RandomSampleTests: XCTestCase {
}
var almostAllZero = AlmostAllZeroGenerator(seed: 0)
_ = s.randomSample(count: k, using: &almostAllZero) // must not crash
_ = s.randomSample(count: k, using: &almostAllZero) // must not crash
almostAllZero = AlmostAllZeroGenerator(seed: 0)
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
}
}
@@ -9,8 +9,8 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class ReductionsTests: XCTestCase {
struct TestError: Error {}
@@ -18,23 +18,26 @@ final class ReductionsTests: XCTestCase {
// MARK: - Exclusive Reductions
func testExclusiveLazy() {
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(0, +), [0, 1, 3, 6, 10])
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(0, +), [0, 1])
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(0, +), [0])
expectEqualSequences(
(1...).prefix(4).lazy.reductions(0, +), [0, 1, 3, 6, 10])
expectEqualSequences((1...).prefix(1).lazy.reductions(0, +), [0, 1])
expectEqualSequences((1...).prefix(0).lazy.reductions(0, +), [0])
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(0, +), [0, 1, 3, 6, 10])
XCTAssertEqualCollections([1].lazy.reductions(0, +), [0, 1])
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(0, +), [0])
expectEqualCollections(
[1, 2, 3, 4].lazy.reductions(0, +), [0, 1, 3, 6, 10])
expectEqualCollections([1].lazy.reductions(0, +), [0, 1])
expectEqualCollections(EmptyCollection<Int>().lazy.reductions(0, +), [0])
XCTAssertEqual([1, 2, 3, 4].lazy.reductions(into: 0, +=), [0, 1, 3, 6, 10])
XCTAssertEqual(
[1, 2, 3, 4].lazy.reductions(into: 0, +=), [0, 1, 3, 6, 10])
XCTAssertEqual([1].lazy.reductions(into: 0, +=), [0, 1])
XCTAssertEqual(EmptyCollection<Int>().lazy.reductions(into: 0, +=), [0])
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(0, +))
XCTAssertLazySequence([1].lazy.reductions(0, +))
XCTAssertLazyCollection([1].lazy.reductions(0, +))
requireLazySequence((1...).prefix(1).lazy.reductions(0, +))
requireLazySequence([1].lazy.reductions(0, +))
requireLazyCollection([1].lazy.reductions(0, +))
}
func testExclusiveEager() {
@@ -51,9 +54,11 @@ 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>>()
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)
@@ -62,17 +67,17 @@ final class ReductionsTests: XCTestCase {
// MARK: - Inclusive Reductions
func testInclusiveLazy() {
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(+), [1, 3, 6, 10])
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(+), [1])
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(+), [])
expectEqualSequences((1...).prefix(4).lazy.reductions(+), [1, 3, 6, 10])
expectEqualSequences((1...).prefix(1).lazy.reductions(+), [1])
expectEqualSequences((1...).prefix(0).lazy.reductions(+), [])
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(+), [1, 3, 6, 10])
XCTAssertEqualCollections([1].lazy.reductions(+), [1])
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(+), [])
expectEqualCollections([1, 2, 3, 4].lazy.reductions(+), [1, 3, 6, 10])
expectEqualCollections([1].lazy.reductions(+), [1])
expectEqualCollections(EmptyCollection<Int>().lazy.reductions(+), [])
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(+))
XCTAssertLazySequence([1].lazy.reductions(+))
XCTAssertLazyCollection([1].lazy.reductions(+))
requireLazySequence((1...).prefix(1).lazy.reductions(+))
requireLazySequence([1].lazy.reductions(+))
requireLazyCollection([1].lazy.reductions(+))
}
func testInclusiveEager() {
@@ -84,7 +89,7 @@ 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)
+32 -22
View File
@@ -10,77 +10,87 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class RotateTests: XCTestCase {
/// Tests the example given in `_reverse(subrange:until:)`’s documentation
/// Tests the example given in the `_reverse(subrange:until:)` documentation.
func testUnderscoreReverse() {
var input = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"]
var input = [
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
"p",
]
let limit: Int = 4
let (lower, upper) = input._reverse(subrange: input.startIndex..<input.endIndex, until: input.startIndex.advanced(by: limit))
let expected = ["p", "o", "n", "m", "e", "f", "g", "h", "i", "j", "k", "l", "d", "c", "b", "a"]
let (lower, upper) = input._reverse(
subrange: input.startIndex..<input.endIndex,
until: input.startIndex.advanced(by: limit))
let expected = [
"p", "o", "n", "m", "e", "f", "g", "h", "i", "j", "k", "l", "d", "c", "b",
"a",
]
XCTAssertEqual(input, expected)
XCTAssertEqual(lower, input.startIndex.advanced(by: limit))
XCTAssertEqual(upper, input.endIndex.advanced(by: -limit))
}
/// Tests the example given in `reverse(subrange:)`’s documentation
/// Tests the example given in the `reverse(subrange:)` documentation.
func testReverse() {
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
numbers.reverse(subrange: 0..<4)
XCTAssertEqual(numbers, [40, 30, 20, 10, 50, 60, 70, 80])
}
/// Tests `rotate(subrange:toStartAt:)` with an empty subrange
/// The order of elements are unchanged
/// Tests `rotate(subrange:toStartAt:)` with an empty subrange.
func testRotateEmptySubrange() {
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
let oldStart = numbers.rotate(subrange: 3..<3, toStartAt: 3)
// The order of elements are unchanged
XCTAssertEqual(numbers, [10, 20, 30, 40, 50, 60, 70, 80])
XCTAssertEqual(numbers[oldStart], 40)
}
/// Tests `rotate(subrange:toStartAt:)` with an empty collection
/// Tests `rotate(subrange:toStartAt:)` with an empty collection.
func testRotateSubrangeOnEmptyCollection() {
var numbers = [Int]()
var numbers: [Int] = []
let oldStart = numbers.rotate(subrange: 0..<0, toStartAt: 0)
XCTAssertEqual(numbers, [])
XCTAssertEqual(oldStart, numbers.startIndex)
}
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection.
func testRotateFullRange() {
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
let oldStart = numbers.rotate(subrange: 0..<8, toStartAt: 1)
XCTAssertEqual(numbers, [20, 30, 40, 50, 60, 70, 80, 10])
XCTAssertEqual(numbers[oldStart], 10)
}
/// Tests the example given in `rotate(subrange:toStartAt:)`’s documentation
/// Tests the example given in the `rotate(subrange:toStartAt:)`
/// documentation.
func testRotateSubrange() {
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
let oldStart = numbers.rotate(subrange: 0..<4, toStartAt: 2)
XCTAssertEqual(numbers, [30, 40, 10, 20, 50, 60, 70, 80])
XCTAssertEqual(numbers[oldStart], 10)
}
/// Tests the example given in `rotate(toStartAt:)`’s documentation
/// Tests the example given in the `rotate(toStartAt:)` documentation.
func testRotateExample() {
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
let oldStart = numbers.rotate(toStartAt: 3)
XCTAssertEqual(numbers, [40, 50, 60, 70, 80, 10, 20, 30])
XCTAssertEqual(numbers[oldStart], 10)
}
/// Tests `rotate(toStartAt:)` on collections of varying lengths, at different
/// starting points
/// Tests `rotate(toStartAt:)` on collections of varying lengths, at
/// different starting points.
func testRotate() {
for length in 0...15 {
let a = Array(0..<length)
var b = a
for j in 0..<length {
let i = b.rotate(toStartAt: j)
XCTAssertEqualSequences(a[j...] + a[..<j], b)
expectEqualSequences(a[j...] + a[..<j], b)
b.rotate(toStartAt: i)
XCTAssertEqual(a, b)
}
+36 -36
View File
@@ -112,7 +112,7 @@ final class SplitTests: XCTestCase {
func testAllEEES() {
let permutations = [
[1, 1, 1, 0], [1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1]
[1, 1, 1, 0], [1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1],
]
for permutation in permutations {
@@ -480,11 +480,11 @@ final class SplitTests: XCTestCase {
func testLaziness() {
let splitSequence = AnySequence([1, 2, 42, 3]).lazy.split(separator: 42)
XCTAssertLazySequence(splitSequence)
requireLazySequence(splitSequence)
let splitCollection = "foo.bar".lazy.split(separator: ".")
XCTAssertLazySequence(splitCollection)
XCTAssertLazyCollection(splitCollection)
requireLazySequence(splitCollection)
requireLazyCollection(splitCollection)
}
// TODO: Need a version of `validateIndexTraversals` that doesn't require
@@ -564,20 +564,20 @@ final class SplitTests: XCTestCase {
where T.Element == C.Element {
// Default max splits, omitting empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = s.split(separator: element).map { Array($0) }
let actual = s.lazy.split(separator: element)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .defaultValue,
omittingEmptySubsequences: .defaultValue)
)
case let .closure(closure):
case .closure(let closure):
let expected = s.split(whereSeparator: closure).map { Array($0) }
let actual = s.lazy.split(whereSeparator: closure)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -588,7 +588,7 @@ final class SplitTests: XCTestCase {
// Provided max splits, omitting empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = s.split(
separator: element,
maxSplits: maxSplits
@@ -597,14 +597,14 @@ final class SplitTests: XCTestCase {
separator: element,
maxSplits: maxSplits
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
omittingEmptySubsequences: .defaultValue)
)
case let .closure(closure):
case .closure(let closure):
let expected = s.split(
maxSplits: maxSplits,
whereSeparator: closure
@@ -613,7 +613,7 @@ final class SplitTests: XCTestCase {
maxSplits: maxSplits,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -624,7 +624,7 @@ final class SplitTests: XCTestCase {
// Default max splits, including empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = s.split(
separator: element,
omittingEmptySubsequences: false
@@ -633,14 +633,14 @@ final class SplitTests: XCTestCase {
separator: element,
omittingEmptySubsequences: false
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .defaultValue,
omittingEmptySubsequences: .provided(false))
)
case let .closure(closure):
case .closure(let closure):
let expected = s.split(
omittingEmptySubsequences: false,
whereSeparator: closure
@@ -649,7 +649,7 @@ final class SplitTests: XCTestCase {
omittingEmptySubsequences: false,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -660,7 +660,7 @@ final class SplitTests: XCTestCase {
// Provided max splits, including empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = s.split(
separator: element,
maxSplits: maxSplits,
@@ -671,14 +671,14 @@ final class SplitTests: XCTestCase {
maxSplits: maxSplits,
omittingEmptySubsequences: false
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
omittingEmptySubsequences: .provided(false))
)
case let .closure(closure):
case .closure(let closure):
let expected = s.split(
maxSplits: maxSplits,
omittingEmptySubsequences: false,
@@ -689,7 +689,7 @@ final class SplitTests: XCTestCase {
omittingEmptySubsequences: false,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -702,20 +702,20 @@ final class SplitTests: XCTestCase {
private func _validateAsCollection(_ c: C) {
// Default max splits, omitting empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = c.split(separator: element)
let actual = c.lazy.split(separator: element)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .defaultValue,
omittingEmptySubsequences: .defaultValue)
)
case let .closure(closure):
case .closure(let closure):
let expected = c.split(whereSeparator: closure)
let actual = c.lazy.split(whereSeparator: closure)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -726,7 +726,7 @@ final class SplitTests: XCTestCase {
// Provided max splits, omitting empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = c.split(
separator: element,
maxSplits: maxSplits
@@ -735,14 +735,14 @@ final class SplitTests: XCTestCase {
separator: element,
maxSplits: maxSplits
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
omittingEmptySubsequences: .defaultValue)
)
case let .closure(closure):
case .closure(let closure):
let expected = c.split(
maxSplits: maxSplits,
whereSeparator: closure
@@ -751,7 +751,7 @@ final class SplitTests: XCTestCase {
maxSplits: maxSplits,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -762,7 +762,7 @@ final class SplitTests: XCTestCase {
// Default max splits, including empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = c.split(
separator: element,
omittingEmptySubsequences: false
@@ -771,14 +771,14 @@ final class SplitTests: XCTestCase {
separator: element,
omittingEmptySubsequences: false
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .defaultValue,
omittingEmptySubsequences: .provided(false))
)
case let .closure(closure):
case .closure(let closure):
let expected = c.split(
omittingEmptySubsequences: false,
whereSeparator: closure
@@ -787,7 +787,7 @@ final class SplitTests: XCTestCase {
omittingEmptySubsequences: false,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
@@ -798,7 +798,7 @@ final class SplitTests: XCTestCase {
// Provided max splits, including empty sequences
switch separator {
case let .element(element):
case .element(let element):
let expected = c.split(
separator: element,
maxSplits: maxSplits,
@@ -809,14 +809,14 @@ final class SplitTests: XCTestCase {
maxSplits: maxSplits,
omittingEmptySubsequences: false
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
omittingEmptySubsequences: .provided(false))
)
case let .closure(closure):
case .closure(let closure):
let expected = c.split(
maxSplits: maxSplits,
omittingEmptySubsequences: false,
@@ -827,7 +827,7 @@ final class SplitTests: XCTestCase {
omittingEmptySubsequences: false,
whereSeparator: closure
)
XCTAssertEqualSequences(
expectEqualSequences(
expected,
actual,
failureMessage(
+48 -48
View File
@@ -9,45 +9,45 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class StridingTests: XCTestCase {
func testStride() {
let a = 0...10
XCTAssertEqualSequences(a.striding(by: 1), (0...10))
XCTAssertEqualSequences(a.striding(by: 2), [0, 2, 4, 6, 8, 10])
XCTAssertEqualSequences(a.striding(by: 3), [0, 3, 6, 9])
XCTAssertEqualSequences(a.striding(by: 4), [0, 4, 8])
XCTAssertEqualSequences(a.striding(by: 5), [0, 5, 10])
XCTAssertEqualSequences(a.striding(by: 10), [0, 10])
XCTAssertEqualSequences(a.striding(by: 11), [0])
expectEqualSequences(a.striding(by: 1), (0...10))
expectEqualSequences(a.striding(by: 2), [0, 2, 4, 6, 8, 10])
expectEqualSequences(a.striding(by: 3), [0, 3, 6, 9])
expectEqualSequences(a.striding(by: 4), [0, 4, 8])
expectEqualSequences(a.striding(by: 5), [0, 5, 10])
expectEqualSequences(a.striding(by: 10), [0, 10])
expectEqualSequences(a.striding(by: 11), [0])
let s = (0...).prefix(11)
XCTAssertEqualSequences(s.striding(by: 1), (0...10))
XCTAssertEqualSequences(s.striding(by: 2), [0, 2, 4, 6, 8, 10])
XCTAssertEqualSequences(s.striding(by: 3), [0, 3, 6, 9])
XCTAssertEqualSequences(s.striding(by: 4), [0, 4, 8])
XCTAssertEqualSequences(s.striding(by: 5), [0, 5, 10])
XCTAssertEqualSequences(s.striding(by: 10), [0, 10])
XCTAssertEqualSequences(s.striding(by: 11), [0])
expectEqualSequences(s.striding(by: 1), (0...10))
expectEqualSequences(s.striding(by: 2), [0, 2, 4, 6, 8, 10])
expectEqualSequences(s.striding(by: 3), [0, 3, 6, 9])
expectEqualSequences(s.striding(by: 4), [0, 4, 8])
expectEqualSequences(s.striding(by: 5), [0, 5, 10])
expectEqualSequences(s.striding(by: 10), [0, 10])
expectEqualSequences(s.striding(by: 11), [0])
let empty = (0...).prefix(0)
XCTAssertEqualSequences(empty.striding(by: 2), [])
expectEqualSequences(empty.striding(by: 2), [])
}
func testStrideString() {
let s = "swift"
XCTAssertEqualSequences(s.striding(by: 2), ["s", "i", "t"])
expectEqualSequences(s.striding(by: 2), ["s", "i", "t"])
}
func testStrideReversed() {
let a = [0, 1, 2, 3, 4, 5]
XCTAssertEqualSequences(a.striding(by: 3).reversed(), [3, 0])
XCTAssertEqualSequences(a.reversed().striding(by: 2), [5, 3, 1])
expectEqualSequences(a.striding(by: 3).reversed(), [3, 0])
expectEqualSequences(a.reversed().striding(by: 2), [5, 3, 1])
}
func testStrideIndexes() {
let a = [0, 1, 2, 3, 4, 5].striding(by: 2)
var i = a.startIndex
@@ -60,20 +60,20 @@ final class StridingTests: XCTestCase {
XCTAssertEqual(a[i], 2)
a.formIndex(before: &i)
XCTAssertEqual(a[i], 0)
// a.formIndex(before: &i) // Precondition failed: Incrementing past start index
// a.index(after: a.endIndex) // Precondition failed: Advancing past end index
// a.formIndex(before: &i) // Precondition failed: Incrementing past start index
// a.index(after: a.endIndex) // Precondition failed: Advancing past end index
}
func testStrideLast() {
XCTAssertEqual((1...10).striding(by: 2).last, 9) // 1, 3, 5, 7, 9
XCTAssertEqual((1...10).striding(by: 3).last, 10) // 1, 4, 7, 10
XCTAssertEqual((1...10).striding(by: 4).last, 9) // 1, 5, 9
XCTAssertEqual((1...10).striding(by: 5).last, 6) // 1, 6
XCTAssertEqual((1...100).striding(by: 50).last, 51) // 1, 51
XCTAssertEqual((1...5).striding(by: 2).last, 5) // 1, 3, 5
XCTAssertEqual([Int]().striding(by: 2).last, nil) // empty
XCTAssertEqual((1...10).striding(by: 2).last, 9) // 1, 3, 5, 7, 9
XCTAssertEqual((1...10).striding(by: 3).last, 10) // 1, 4, 7, 10
XCTAssertEqual((1...10).striding(by: 4).last, 9) // 1, 5, 9
XCTAssertEqual((1...10).striding(by: 5).last, 6) // 1, 6
XCTAssertEqual((1...100).striding(by: 50).last, 51) // 1, 51
XCTAssertEqual((1...5).striding(by: 2).last, 5) // 1, 3, 5
XCTAssertEqual([Int]().striding(by: 2).last, nil) // empty
}
func testCount() {
let empty = [Int]().striding(by: 2)
XCTAssertEqual(empty.count, 0)
@@ -86,15 +86,15 @@ final class StridingTests: XCTestCase {
XCTAssertEqual(a.striding(by: 10).count, [0, 10].count)
XCTAssertEqual(a.striding(by: 11).count, [0].count)
}
func testIndexTraversals() {
do {
let empty = [Int]()
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>>>()
@@ -102,7 +102,7 @@ final class StridingTests: XCTestCase {
validator.validate(range.striding(by: 11))
validator.validate(range.striding(by: 101))
}
do {
let array = Array(0...100)
let validator = IndexValidator<StridingCollection<[Int]>>()
@@ -110,7 +110,7 @@ final class StridingTests: XCTestCase {
validator.validate(array.striding(by: 11))
validator.validate(array.striding(by: 101))
}
do {
let string = "swift rocks"
let validator = IndexValidator<StridingCollection<String>>()
@@ -119,7 +119,7 @@ final class StridingTests: XCTestCase {
validator.validate(string.striding(by: 10))
}
}
func testOffsetBy() {
let a = (0...100).striding(by: 22)
let b = [0, 22, 44, 66, 88]
@@ -127,17 +127,17 @@ final class StridingTests: XCTestCase {
XCTAssertEqual(a[a.index(a.startIndex, offsetBy: i)], b[i])
}
}
func testOffsetByEndIndex() {
let a = 1...5
let b = a.striding(by: 3) // [1, 4]
let b = a.striding(by: 3) // [1, 4]
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))
requireLazySequence(AnySequence(0..<100).lazy.striding(by: 3))
requireLazySequence((0..<100).lazy.striding(by: 3))
requireLazyCollection((0..<100).lazy.striding(by: 3))
}
}
+13 -13
View File
@@ -9,40 +9,40 @@
//
//===----------------------------------------------------------------------===//
import Algorithms
import XCTest
@testable import Algorithms
final class SuffixTests: XCTestCase {
func testSuffix() {
let a = 0...10
XCTAssertEqualSequences(a.suffix(while: { $0 > 5 }), (6...10))
XCTAssertEqualSequences(a.suffix(while: { $0 > 10 }), [])
XCTAssertEqualSequences(a.suffix(while: { $0 > 9 }), [10])
XCTAssertEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
expectEqualSequences(a.suffix(while: { $0 > 5 }), (6...10))
expectEqualSequences(a.suffix(while: { $0 > 10 }), [])
expectEqualSequences(a.suffix(while: { $0 > 9 }), [10])
expectEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
let empty: [Int] = []
XCTAssertEqualSequences(empty.suffix(while: { $0 > 10 }), [])
expectEqualSequences(empty.suffix(while: { $0 > 10 }), [])
}
func testEndOfPrefix() {
let array = Array(0..<10)
XCTAssertEqual(array.endOfPrefix(while: { $0 < 3 }), 3)
XCTAssertEqual(array.endOfPrefix(while: { _ in false }), array.startIndex)
XCTAssertEqual(array.endOfPrefix(while: { _ in true }), array.endIndex)
let empty = [Int]()
let empty: [Int] = []
XCTAssertEqual(empty.endOfPrefix(while: { $0 < 3 }), 0)
XCTAssertEqual(empty.endOfPrefix(while: { _ in false }), empty.startIndex)
XCTAssertEqual(empty.endOfPrefix(while: { _ in true }), empty.endIndex)
}
func testStartOfSuffix() {
let array = Array(0..<10)
XCTAssertEqual(array.startOfSuffix(while: { $0 >= 3 }), 3)
XCTAssertEqual(array.startOfSuffix(while: { _ in false }), array.endIndex)
XCTAssertEqual(array.startOfSuffix(while: { _ in true }), array.startIndex)
let empty = [Int]()
let empty: [Int] = []
XCTAssertEqual(empty.startOfSuffix(while: { $0 < 3 }), 0)
XCTAssertEqual(empty.startOfSuffix(while: { _ in false }), empty.endIndex)
XCTAssertEqual(empty.startOfSuffix(while: { _ in true }), empty.startIndex)
+80 -64
View File
@@ -32,16 +32,16 @@ extension Numeric {
struct SplitMix64: RandomNumberGenerator {
private var state: UInt64
init(seed: UInt64) {
self.state = seed
}
mutating func next() -> UInt64 {
self.state &+= 0x9e3779b97f4a7c15
self.state &+= 0x9e37_79b9_7f4a_7c15
var z: UInt64 = self.state
z = (z ^ (z &>> 30)) &* 0xbf58476d1ce4e5b9
z = (z ^ (z &>> 27)) &* 0x94d049bb133111eb
z = (z ^ (z &>> 30)) &* 0xbf58_476d_1ce4_e5b9
z = (z ^ (z &>> 27)) &* 0x94d0_49bb_1331_11eb
return z ^ (z &>> 31)
}
}
@@ -54,7 +54,7 @@ struct AnyMutableCollection<Base> where Base: MutableCollection {
extension AnyMutableCollection: MutableCollection {
typealias Index = Base.Index
typealias Element = Base.Element
var startIndex: Base.Index { base.startIndex }
var endIndex: Base.Index { base.endIndex }
@@ -74,21 +74,22 @@ extension MutableCollection {
}
}
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
func expectEqualSequences<S1: Sequence, S2: Sequence>(
_ expression1: @autoclosure () throws -> S1,
_ expression2: @autoclosure () throws -> S2,
_ message: @autoclosure () -> String = "",
file: StaticString = #file, line: UInt = #line
file: StaticString = (#file), line: UInt = #line
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
try XCTAssertEqualSequences(expression1(), expression2(), by: ==,
try expectEqualSequences(
expression1(), expression2(), by: ==,
message(), file: file, line: line)
}
// Two sequences contains exactly the same element but not necessarily in the same order.
func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
func expectUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
_ expression1: @autoclosure () throws -> S1,
_ expression2: @autoclosure () throws -> S2,
file: StaticString = #file, line: UInt = #line
file: StaticString = (#file), line: UInt = #line
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
var s1 = Array(try expression1())
var missing: [S1.Element] = []
@@ -99,9 +100,10 @@ func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
}
s1.remove(at: idx)
}
XCTAssertTrue(
missing.isEmpty, "first sequence missing '\(missing)' elements from second sequence",
missing.isEmpty,
"first sequence missing '\(missing)' elements from second sequence",
file: file, line: line
)
@@ -111,18 +113,19 @@ func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
)
}
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
func expectEqualSequences<S1: Sequence, S2: Sequence>(
_ expression1: @autoclosure () throws -> S1,
_ expression2: @autoclosure () throws -> S2,
by areEquivalent: (S1.Element, S1.Element) -> Bool,
_ message: @autoclosure () -> String = "",
file: StaticString = #file, line: UInt = #line
file: StaticString = (#file), line: UInt = #line
) rethrows where S1.Element == S2.Element {
func fail(_ reason: String) {
let message = message()
XCTFail(message.isEmpty ? reason : "\(message) - \(reason)",
file: file, line: line)
XCTFail(
message.isEmpty ? reason : "\(message) - \(reason)",
file: file, line: line)
}
var iter1 = try expression1().makeIterator()
@@ -130,11 +133,13 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
var idx = 0
while true {
switch (iter1.next(), iter2.next()) {
case let (e1?, e2?) where areEquivalent(e1, e2):
case (let e1?, let e2?) where areEquivalent(e1, e2):
idx += 1
continue
case let (e1?, e2?):
fail("element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)")
case (let e1?, let e2?):
fail(
"element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)"
)
case (_?, nil):
fail("second sequence shorter than first")
case (nil, _?):
@@ -145,19 +150,20 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
}
}
func XCTAssertLazySequence<S: LazySequenceProtocol>(_: S) {}
func XCTAssertLazyCollection<S: LazyCollectionProtocol>(_: S) {}
func requireLazySequence<S: LazySequenceProtocol>(_: S) {}
func requireLazyCollection<S: LazyCollectionProtocol>(_: S) {}
/// Asserts two collections are equal by using their indices to access elements.
func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
func expectEqualCollections<C1: Collection, C2: Collection>(
_ expression1: @autoclosure () throws -> C1,
_ expression2: @autoclosure () throws -> C2,
_ message: @autoclosure () -> String = "",
file: StaticString = #file, line: UInt = #line
file: StaticString = (#file), line: UInt = #line
) rethrows where C1.Element: Equatable, C1.Element == C2.Element {
let c1 = try expression1()
let c2 = try expression2()
XCTAssertEqual(c1.indices.count, c2.indices.count, message(), file: file, line: line)
XCTAssertEqual(
c1.indices.count, c2.indices.count, message(), file: file, line: line)
for index in zip(c1.indices, c2.indices) {
XCTAssertEqual(c1[index.0], c2[index.1], message(), file: file, line: line)
}
@@ -166,7 +172,7 @@ 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.
///
@@ -188,7 +194,9 @@ struct IndexValidator<C: Collection> {
/// using the contents of the collection directly.
init(
testRandomAccess: Bool = true,
indicesIncludingEnd: @escaping (C) -> [C.Index] = { $0.indices + [$0.endIndex] }
indicesIncludingEnd: @escaping (C) -> [C.Index] = {
$0.indices + [$0.endIndex]
}
) {
self.indicesIncludingEnd = indicesIncludingEnd
}
@@ -202,7 +210,7 @@ extension IndexValidator {
let file: StaticString
let line: UInt
}
/// Verifies that all index traversal methods behave as expected.
///
/// Verifies the correctness of the implementations of `startIndex`,
@@ -211,12 +219,8 @@ extension IndexValidator {
/// `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).
/// collection conforms to `RandomAccessCollection`, otherwise O(*n*^4).
func validate(
_ collection: C,
expectedCount: Int? = nil,
@@ -224,13 +228,13 @@ extension IndexValidator {
) {
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)
@@ -244,13 +248,13 @@ extension IndexValidator where C: BidirectionalCollection {
) {
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)
@@ -264,7 +268,7 @@ extension IndexValidator.Validator {
XCTAssertEqual(
expectedCount, count, "Count mismatch", file: file, line: line)
}
XCTAssertEqual(
collection.count, count,
"Count mismatch",
@@ -281,21 +285,21 @@ extension IndexValidator.Validator {
collection.endIndex, indicesIncludingEnd.last,
"`endIndex` does not equal the last index",
file: file, line: line)
validateIndexAfter()
validateIndices()
validateIndexComparisons()
if testRandomAccess {
validateDistanceFromTo()
validateIndexOffsetBy()
validateIndexOffsetByLimitedBy()
}
}
func validateIndexAfter() {
var index = collection.startIndex
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
collection.formIndex(after: &index)
XCTAssertEqual(
@@ -307,7 +311,7 @@ extension IndexValidator.Validator {
file: file, line: line)
}
}
func validateIndices() {
XCTAssertEqual(collection.indices.count, count)
for (offset, index) in collection.indices.enumerated() {
@@ -317,7 +321,7 @@ extension IndexValidator.Validator {
file: file, line: line)
}
}
func validateIndexComparisons() {
for (offsetA, a) in indicesIncludingEnd.enumerated() {
XCTAssertEqual(
@@ -328,7 +332,7 @@ extension IndexValidator.Validator {
a < a,
"Index at offset \(offsetA) is less than itself",
file: file, line: line)
for (offsetB, b) in indicesIncludingEnd[..<offsetA].enumerated() {
XCTAssertNotEqual(
a, b,
@@ -343,10 +347,12 @@ extension IndexValidator.Validator {
}
}
}
func validateDistanceFromTo() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(
startOffset)
{
let distance = endOffset - startOffset
XCTAssertEqual(
collection.distance(from: start, to: end), distance,
@@ -358,10 +364,12 @@ extension IndexValidator.Validator {
}
}
}
func validateIndexOffsetBy() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(startOffset) {
for (endOffset, end) in indicesIncludingEnd.enumerated().dropFirst(
startOffset)
{
let distance = endOffset - startOffset
XCTAssertEqual(
collection.index(start, offsetBy: distance), end,
@@ -373,7 +381,7 @@ extension IndexValidator.Validator {
}
}
}
func validateIndexOffsetByLimitedBy() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
@@ -384,8 +392,9 @@ extension IndexValidator.Validator {
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 = collection.index(
start, offsetBy: distance, limitedBy: limit)
if pastLimit {
XCTAssertNil(
end,
@@ -406,7 +415,7 @@ extension IndexValidator.Validator {
}
}
}
if limit >= start {
// the limit has an effect
checkTargetRange(startOffset...limitOffset, pastLimit: false)
@@ -423,18 +432,20 @@ extension IndexValidator.Validator {
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() {
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast()
.reversed()
{
collection.formIndex(before: &index)
XCTAssertEqual(
index, expected,
@@ -445,10 +456,12 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
file: file, line: line)
}
}
func validateDistanceFromTo() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(
startOffset)
{
let distance = endOffset - startOffset
XCTAssertEqual(
collection.distance(from: start, to: end), distance,
@@ -460,10 +473,12 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
}
}
}
func validateIndexOffsetBy() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(startOffset) {
for (endOffset, end) in indicesIncludingEnd.enumerated().prefix(
startOffset)
{
let distance = endOffset - startOffset
XCTAssertEqual(
collection.index(start, offsetBy: distance), end,
@@ -475,7 +490,7 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
}
}
}
func validateIndexOffsetByLimitedBy() {
for (startOffset, start) in indicesIncludingEnd.enumerated() {
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
@@ -486,8 +501,9 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
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 = collection.index(
start, offsetBy: distance, limitedBy: limit)
if pastLimit {
XCTAssertNil(
end,
@@ -508,7 +524,7 @@ extension IndexValidator.Validator where C: BidirectionalCollection {
}
}
}
if limit <= start {
// the limit has an effect
checkTargetRange(limitOffset...startOffset, pastLimit: false)
+30 -26
View File
@@ -13,74 +13,78 @@ import Algorithms
import XCTest
final class TrimTests: XCTestCase {
func testEmpty() {
let results_empty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
XCTAssertEqual(results_empty, [])
let resultsEmpty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
XCTAssertEqual(resultsEmpty, [])
}
func testNoMatch() {
// No match (nothing trimmed).
let results_nomatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
let resultsNoMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
$0.isMultiple(of: 2)
}
XCTAssertEqual(results_nomatch, [1, 3, 5, 7, 9, 11, 13, 15])
XCTAssertEqual(resultsNoMatch, [1, 3, 5, 7, 9, 11, 13, 15])
}
func testNoTailMatch() {
// No tail match (only trim head).
let results_notailmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
XCTAssertEqual(results_notailmatch, [11, 13, 15])
let resultsNoTailMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
XCTAssertEqual(resultsNoTailMatch, [11, 13, 15])
}
func testNoHeadMatch() {
// No head match (only trim tail).
let results_noheadmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
XCTAssertEqual(results_noheadmatch, [1, 3, 5, 7, 9])
let resultsNoHeadMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
XCTAssertEqual(resultsNoHeadMatch, [1, 3, 5, 7, 9])
}
func testBothEndsMatch() {
// Both ends match, some string of >1 elements do not (return that string).
let results = [2, 10, 11, 15, 20, 21, 100].trimming { $0.isMultiple(of: 2) }
XCTAssertEqual(results, [11, 15, 20, 21])
}
func testEverythingMatches() {
// Everything matches (trim everything).
let results_allmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
XCTAssertEqual(results_allmatch, [])
let resultsAllMatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
XCTAssertEqual(resultsAllMatch, [])
}
func testEverythingButOneMatches() {
// Both ends match, one element does not (trim all except that element).
let results_one = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
XCTAssertEqual(results_one, [15])
let resultsOne = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
XCTAssertEqual(resultsOne, [15])
}
func testTrimmingPrefix() {
let results = [2, 10, 12, 15, 20, 100].trimmingPrefix { $0.isMultiple(of: 2) }
let results = [2, 10, 12, 15, 20, 100].trimmingPrefix {
$0.isMultiple(of: 2)
}
XCTAssertEqual(results, [15, 20, 100])
}
func testTrimmingSuffix() {
let results = [2, 10, 12, 15, 20, 100].trimmingSuffix { $0.isMultiple(of: 2) }
let results = [2, 10, 12, 15, 20, 100].trimmingSuffix {
$0.isMultiple(of: 2)
}
XCTAssertEqual(results, [2, 10, 12, 15])
}
// Self == Self.Subsequence
func testTrimNoAmbiguity() {
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
values.trim { $0.isMultiple(of: 2) }
XCTAssertEqual(values, [15])
}
// Self == Self.Subsequence
func testTrimPrefixNoAmbiguity() {
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
values.trimPrefix { $0.isMultiple(of: 2) }
XCTAssertEqual(values, [15, 20, 100])
}
// Self == Self.Subsequence
func testTrimSuffixNoAmbiguity() {
var values = [2, 10, 12, 15, 20, 100] as ArraySlice
@@ -9,12 +9,12 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class UniquePermutationsTests: XCTestCase {
static let numbers = [1, 1, 1, 2, 3]
static let numbersPermutations: [[[Int]]] = [
// k = 0
[[]],
@@ -23,64 +23,70 @@ final class UniquePermutationsTests: XCTestCase {
// 2
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]],
// 3
[[1, 1, 1], [1, 1, 2], [1, 1, 3],
[1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2],
[2, 1, 1], [2, 1, 3], [2, 3, 1],
[3, 1, 1], [3, 1, 2], [3, 2, 1]],
[
[1, 1, 1], [1, 1, 2], [1, 1, 3],
[1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2],
[2, 1, 1], [2, 1, 3], [2, 3, 1],
[3, 1, 1], [3, 1, 2], [3, 2, 1],
],
// 4
[[1, 1, 1, 2], [1, 1, 1, 3],
[1, 1, 2, 1], [1, 1, 2, 3],
[1, 1, 3, 1], [1, 1, 3, 2],
[1, 2, 1, 1], [1, 2, 1, 3], [1, 2, 3, 1],
[1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 2, 1],
[2, 1, 1, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1],
[3, 1, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1]],
[
[1, 1, 1, 2], [1, 1, 1, 3],
[1, 1, 2, 1], [1, 1, 2, 3],
[1, 1, 3, 1], [1, 1, 3, 2],
[1, 2, 1, 1], [1, 2, 1, 3], [1, 2, 3, 1],
[1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 2, 1],
[2, 1, 1, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1],
[3, 1, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1],
],
// 5
[[1, 1, 1, 2, 3], [1, 1, 1, 3, 2],
[1, 1, 2, 1, 3], [1, 1, 2, 3, 1],
[1, 1, 3, 1, 2], [1, 1, 3, 2, 1],
[1, 2, 1, 1, 3], [1, 2, 1, 3, 1], [1, 2, 3, 1, 1],
[1, 3, 1, 1, 2], [1, 3, 1, 2, 1], [1, 3, 2, 1, 1],
[2, 1, 1, 1, 3], [2, 1, 1, 3, 1], [2, 1, 3, 1, 1], [2, 3, 1, 1, 1],
[3, 1, 1, 1, 2], [3, 1, 1, 2, 1], [3, 1, 2, 1, 1], [3, 2, 1, 1, 1]]
[
[1, 1, 1, 2, 3], [1, 1, 1, 3, 2],
[1, 1, 2, 1, 3], [1, 1, 2, 3, 1],
[1, 1, 3, 1, 2], [1, 1, 3, 2, 1],
[1, 2, 1, 1, 3], [1, 2, 1, 3, 1], [1, 2, 3, 1, 1],
[1, 3, 1, 1, 2], [1, 3, 1, 2, 1], [1, 3, 2, 1, 1],
[2, 1, 1, 1, 3], [2, 1, 1, 3, 1], [2, 1, 3, 1, 1], [2, 3, 1, 1, 1],
[3, 1, 1, 1, 2], [3, 1, 1, 2, 1], [3, 1, 2, 1, 1], [3, 2, 1, 1, 1],
],
]
}
extension UniquePermutationsTests {
func testEmpty() {
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(), [[]])
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 0), [[]])
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 1), [])
XCTAssertEqualSequences(
expectEqualSequences(([] as [Int]).uniquePermutations(), [[]])
expectEqualSequences(([] as [Int]).uniquePermutations(ofCount: 0), [[]])
expectEqualSequences(([] as [Int]).uniquePermutations(ofCount: 1), [])
expectEqualSequences(
([] as [Int]).uniquePermutations(ofCount: 1...3), [])
}
func testSingleCounts() {
for (k, expectation) in Self.numbersPermutations.enumerated() {
XCTAssertEqualSequences(
expectEqualSequences(
expectation,
Self.numbers.uniquePermutations(ofCount: k))
}
XCTAssertEqualSequences(
expectEqualSequences(
Self.numbersPermutations[5],
Self.numbers.uniquePermutations())
}
func testRanges() {
for lower in Self.numbersPermutations.indices {
// upper bounded
XCTAssertEqualSequences(
expectEqualSequences(
Self.numbersPermutations[...lower].joined(),
Self.numbers.uniquePermutations(ofCount: ...lower))
// lower bounded
XCTAssertEqualSequences(
expectEqualSequences(
Self.numbersPermutations[lower...].joined(),
Self.numbers.uniquePermutations(ofCount: lower...))
for upper in lower..<Self.numbersPermutations.count {
XCTAssertEqualSequences(
expectEqualSequences(
Self.numbersPermutations[lower..<upper].joined(),
Self.numbers.uniquePermutations(ofCount: lower..<upper))
}
@@ -91,11 +97,11 @@ extension UniquePermutationsTests {
extension UniquePermutationsTests {
private final class IntBox: Hashable {
var value: Int
init(_ value: Int) {
self.value = value
}
static func == (lhs: IntBox, rhs: IntBox) -> Bool {
lhs.value == rhs.value
}
@@ -111,12 +117,13 @@ extension UniquePermutationsTests {
let numbers = Self.numbers.map(IntBox.init)
for k in 0...numbers.count {
for p in numbers.uniquePermutations(ofCount: k) {
XCTAssertTrue(p.filter { $0.value == 1 }.allSatisfy { $0 === numbers[0] })
XCTAssertTrue(
p.filter { $0.value == 1 }.allSatisfy { $0 === numbers[0] })
}
}
}
func testLaziness() {
XCTAssertLazySequence("ABCD".lazy.uniquePermutations())
requireLazySequence("ABCD".lazy.uniquePermutations())
}
}
+33 -29
View File
@@ -9,8 +9,8 @@
//
//===----------------------------------------------------------------------===//
import XCTest
import Algorithms
import XCTest
final class UniqueTests: XCTestCase {
func testUnique() {
@@ -18,36 +18,40 @@ final class UniqueTests: XCTestCase {
let b = a.uniqued()
XCTAssertEqual(b.sorted(), Set(a).sorted())
XCTAssertEqual(10, Array(b).count)
let c: [Int] = []
XCTAssertEqualSequences(c.uniqued(), [])
let d = Array(repeating: 1, count: 10)
XCTAssertEqualSequences(d.uniqued(), [1])
}
func testUniqueOn() {
let a = ["Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom"]
let b = a.uniqued(on: { $0.first })
XCTAssertEqual(["Albemarle", "Brandywine"], b)
let c: [Int] = []
XCTAssertEqual(c.uniqued(on: { $0.bitWidth }), [])
let d = Array(repeating: "Andromeda", count: 10)
XCTAssertEqualSequences(d.uniqued(on: { $0.first }), ["Andromeda"])
}
func testLazyUniqueOn() {
let a = ["Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom"]
let b = a.lazy.uniqued(on: { $0.first })
XCTAssertEqualSequences(b, ["Albemarle", "Brandywine"])
XCTAssertLazySequence(b)
let c: [Int] = []
XCTAssertEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
expectEqualSequences(c.uniqued(), [])
let d = Array(repeating: 1, count: 10)
expectEqualSequences(d.uniqued(), [1])
}
func testUniqueOn() {
let a = [
"Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom",
]
let b = a.uniqued(on: { $0.first })
XCTAssertEqual(["Albemarle", "Brandywine"], b)
let c: [Int] = []
XCTAssertEqual(c.uniqued(on: { $0.bitWidth }), [])
let d = Array(repeating: "Andromeda", count: 10)
XCTAssertEqualSequences(d.lazy.uniqued(on: { $0.first }), ["Andromeda"])
expectEqualSequences(d.uniqued(on: { $0.first }), ["Andromeda"])
}
func testLazyUniqueOn() {
let a = [
"Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom",
]
let b = a.lazy.uniqued(on: { $0.first })
expectEqualSequences(b, ["Albemarle", "Brandywine"])
requireLazySequence(b)
let c: [Int] = []
expectEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
let d = Array(repeating: "Andromeda", count: 10)
expectEqualSequences(d.lazy.uniqued(on: { $0.first }), ["Andromeda"])
}
}
+33 -32
View File
@@ -10,6 +10,7 @@
//===----------------------------------------------------------------------===//
import XCTest
@testable import Algorithms
final class WindowsTests: XCTestCase {
@@ -18,73 +19,73 @@ final class WindowsTests: XCTestCase {
let w = s.windows(ofCount: 2)
var i = w.startIndex
XCTAssertEqualSequences(w[i], "sw")
expectEqualSequences(w[i], "sw")
w.formIndex(after: &i)
XCTAssertEqualSequences(w[i], "wi")
expectEqualSequences(w[i], "wi")
w.formIndex(after: &i)
XCTAssertEqualSequences(w[i], "if")
expectEqualSequences(w[i], "if")
w.formIndex(after: &i)
XCTAssertEqualSequences(w[i], "ft")
expectEqualSequences(w[i], "ft")
// w.index(after: w.endIndex) // ← Precondition failed: windows index is out of range
// w.index(before: w.startIndex) // ← Precondition failed: windows index is out of range
// w.formIndex(after: &i); w[i] // ← Precondition failed: windows index is out of range
// w.index(after: w.endIndex) // ← Precondition failed: windows index is out of range
// w.index(before: w.startIndex) // ← Precondition failed: windows index is out of range
// w.formIndex(after: &i); w[i] // ← Precondition failed: windows index is out of range
}
func testWindowsOfRange() {
let a = 0...100
XCTAssertTrue(a.windows(ofCount: 200).isEmpty)
let w = a.windows(ofCount: 10)
XCTAssertEqualSequences(w.first!, 0..<10)
XCTAssertEqualSequences(w.last!, 91..<101)
expectEqualSequences(w.first!, 0..<10)
expectEqualSequences(w.last!, 91..<101)
}
func testWindowsOfInt() {
let a = [ 0, 1, 0, 1 ].windows(ofCount: 2)
let a = [0, 1, 0, 1].windows(ofCount: 2)
XCTAssertEqual(a.count, 3)
XCTAssertEqual(a.map { $0.reduce(0, +) }, [1, 1, 1])
let a2 = [0, 1, 2, 3, 4, 5, 6].windows(ofCount: 3).map {
$0.reduce(0, +)
}.reduce(0, +)
XCTAssertEqual(a2, 3 + 6 + 9 + 12 + 15)
}
func testWindowsCount() {
let a = [0, 1, 2, 3, 4, 5]
XCTAssertEqual(a.windows(ofCount: 3).count, 4)
let a2 = [0, 1, 2, 3, 4]
XCTAssertEqual(a2.windows(ofCount: 6).count, 0)
let a3 = [Int]()
let a3: [Int] = []
XCTAssertEqual(a3.windows(ofCount: 2).count, 0)
}
func testWindowsSecondAndLast() {
let a = [0, 1, 2, 3, 4, 5]
let w = a.windows(ofCount: 4)
let snd = w[w.index(after: w.startIndex)]
XCTAssertEqualSequences(snd, [1, 2, 3, 4])
expectEqualSequences(snd, [1, 2, 3, 4])
let w2 = a.windows(ofCount: 3)
XCTAssertEqualSequences(w2.last!, [3, 4, 5])
expectEqualSequences(w2.last!, [3, 4, 5])
}
func testWindowsIndexAfterAndBefore() {
let a = [0, 1, 2, 3, 4, 5].windows(ofCount: 2)
var i = a.startIndex
a.formIndex(after: &i)
a.formIndex(after: &i)
a.formIndex(before: &i)
XCTAssertEqualSequences(a[i], [1, 2])
expectEqualSequences(a[i], [1, 2])
}
func testWindowsIndexTraversals() {
let validator = IndexValidator<WindowsOfCountCollection<String>>(
indicesIncludingEnd: { windows in
@@ -92,9 +93,9 @@ final class WindowsTests: XCTestCase {
let indices = windows.base.indices + [endIndex]
return zip(indices, indices.dropFirst(windows.windowSize))
.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)
@@ -106,6 +107,6 @@ final class WindowsTests: XCTestCase {
}
func testWindowsLazy() {
XCTAssertLazyCollection([0, 1, 2, 3].lazy.windows(ofCount: 2))
requireLazyCollection([0, 1, 2, 3].lazy.windows(ofCount: 2))
}
}
+39
View File
@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2023 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
//
//===----------------------------------------------------------------------===//
PRODUCT_NAME = Algorithms
PRODUCT_BUNDLE_IDENTIFIER = org.swift.Algorithms
SUPPORTED_PLATFORMS = macosx iphoneos iphonesimulator watchos watchsimulator appletvos appletvsimulator
ARCHS = $(ARCHS_STANDARD)
MACOSX_DEPLOYMENT_TARGET = 12.0
IPHONEOS_DEPLOYMENT_TARGET = 15.0
WATCHOS_DEPLOYMENT_TARGET = 8.0
TVOS_DEPLOYMENT_TARGET = 15.0
MARKETING_VERSION = 1.2
CURRENT_PROJECT_VERSION = 1
VERSIONING_SYSTEM = apple-generic
VERSION_INFO_PREFIX =
DYLIB_COMPATIBILITY_VERSION = $(CURRENT_PROJECT_VERSION)
DYLIB_CURRENT_VERSION = $(CURRENT_PROJECT_VERSION)
INSTALL_PATH = $(LOCAL_LIBRARY_DIR)/Frameworks
SKIP_INSTALL = YES
DYLIB_INSTALL_NAME_BASE = @rpath
LD_RUNPATH_SEARCH_PATHS = $(inherited) @executable_path/../Frameworks @loader_path/Frameworks
ENABLE_TESTABILITY = NO
ENABLE_TESTABILITY[config=Debug] = YES
GENERATE_INFOPLIST_FILE = YES
+566
View File
@@ -0,0 +1,566 @@
// !$*UTF8*$!
{
archiveVersion = 1;
classes = {
};
objectVersion = 60;
objects = {
/* Begin PBXBuildFile section */
4347CECC2CE1D54900CD2979 /* Suffix.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA52CE1D54900CD2979 /* Suffix.swift */; };
4347CECD2CE1D54900CD2979 /* Chunked.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8F2CE1D54900CD2979 /* Chunked.swift */; };
4347CECE2CE1D54900CD2979 /* Keyed.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9B2CE1D54900CD2979 /* Keyed.swift */; };
4347CECF2CE1D54900CD2979 /* Stride.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA42CE1D54900CD2979 /* Stride.swift */; };
4347CED02CE1D54900CD2979 /* Windows.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA82CE1D54900CD2979 /* Windows.swift */; };
4347CED32CE1D54900CD2979 /* Partition.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9D2CE1D54900CD2979 /* Partition.swift */; };
4347CED52CE1D54900CD2979 /* FirstNonNil.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE952CE1D54900CD2979 /* FirstNonNil.swift */; };
4347CED62CE1D54900CD2979 /* Rotate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA22CE1D54900CD2979 /* Rotate.swift */; };
4347CEDF2CE1D54900CD2979 /* Split.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA32CE1D54900CD2979 /* Split.swift */; };
4347CEE02CE1D54900CD2979 /* Chain.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8E2CE1D54900CD2979 /* Chain.swift */; };
4347CEE12CE1D54900CD2979 /* Trim.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA62CE1D54900CD2979 /* Trim.swift */; };
4347CEE22CE1D54900CD2979 /* Product.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9F2CE1D54900CD2979 /* Product.swift */; };
4347CEE42CE1D54900CD2979 /* Indexed.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE982CE1D54900CD2979 /* Indexed.swift */; };
4347CEE52CE1D54900CD2979 /* Documentation.docc in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE932CE1D54900CD2979 /* Documentation.docc */; };
4347CEE82CE1D54900CD2979 /* Combinations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE902CE1D54900CD2979 /* Combinations.swift */; };
4347CEE92CE1D54900CD2979 /* MinMax.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9C2CE1D54900CD2979 /* MinMax.swift */; };
4347CEEA2CE1D54900CD2979 /* Joined.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9A2CE1D54900CD2979 /* Joined.swift */; };
4347CEEB2CE1D54900CD2979 /* Grouped.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE972CE1D54900CD2979 /* Grouped.swift */; };
4347CEED2CE1D54900CD2979 /* AdjacentPairs.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */; };
4347CEEE2CE1D54900CD2979 /* Permutations.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE9E2CE1D54900CD2979 /* Permutations.swift */; };
4347CEF02CE1D54900CD2979 /* FlattenCollection.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE962CE1D54900CD2979 /* FlattenCollection.swift */; };
4347CEF32CE1D54900CD2979 /* Reductions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA12CE1D54900CD2979 /* Reductions.swift */; };
4347CEF42CE1D54900CD2979 /* Intersperse.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE992CE1D54900CD2979 /* Intersperse.swift */; };
4347CEF52CE1D54900CD2979 /* RandomSample.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA02CE1D54900CD2979 /* RandomSample.swift */; };
4347CEFB2CE1D54900CD2979 /* Unique.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CEA72CE1D54900CD2979 /* Unique.swift */; };
4347CEFD2CE1D54900CD2979 /* EitherSequence.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE942CE1D54900CD2979 /* EitherSequence.swift */; };
4347CEFE2CE1D54900CD2979 /* Cycle.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE922CE1D54900CD2979 /* Cycle.swift */; };
4347CEFF2CE1D54900CD2979 /* Compacted.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CE912CE1D54900CD2979 /* Compacted.swift */; };
4347CF262CE1D56C00CD2979 /* IndexedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF112CE1D56C00CD2979 /* IndexedTests.swift */; };
4347CF272CE1D56C00CD2979 /* RotateTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */; };
4347CF282CE1D56C00CD2979 /* RandomSampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */; };
4347CF292CE1D56C00CD2979 /* StrideTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */; };
4347CF2A2CE1D56C00CD2979 /* IntersperseTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */; };
4347CF2B2CE1D56C00CD2979 /* CombinationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */; };
4347CF2C2CE1D56C00CD2979 /* SplitTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */; };
4347CF2D2CE1D56C00CD2979 /* ReductionsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */; };
4347CF2E2CE1D56C00CD2979 /* TrimTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF202CE1D56C00CD2979 /* TrimTests.swift */; };
4347CF2F2CE1D56C00CD2979 /* FirstNonNilTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */; };
4347CF302CE1D56C00CD2979 /* SuffixTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */; };
4347CF312CE1D56C00CD2979 /* KeyedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF142CE1D56C00CD2979 /* KeyedTests.swift */; };
4347CF322CE1D56C00CD2979 /* UniqueTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF222CE1D56C00CD2979 /* UniqueTests.swift */; };
4347CF332CE1D56C00CD2979 /* PermutationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */; };
4347CF342CE1D56C00CD2979 /* CompactedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */; };
4347CF352CE1D56C00CD2979 /* UniquePermutationsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */; };
4347CF362CE1D56C00CD2979 /* GroupedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF102CE1D56C00CD2979 /* GroupedTests.swift */; };
4347CF372CE1D56C00CD2979 /* MinMaxTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */; };
4347CF382CE1D56C00CD2979 /* ProductTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF182CE1D56C00CD2979 /* ProductTests.swift */; };
4347CF392CE1D56C00CD2979 /* ChainTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */; };
4347CF3A2CE1D56C00CD2979 /* ChunkedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */; };
4347CF3B2CE1D56C00CD2979 /* PartitionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF162CE1D56C00CD2979 /* PartitionTests.swift */; };
4347CF3C2CE1D56C00CD2979 /* CycleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */; };
4347CF3D2CE1D56C00CD2979 /* AdjacentPairsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */; };
4347CF3E2CE1D56C00CD2979 /* TestUtilities.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */; };
4347CF3F2CE1D56C00CD2979 /* WindowsTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF232CE1D56C00CD2979 /* WindowsTests.swift */; };
4347CF402CE1D56C00CD2979 /* JoinedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4347CF132CE1D56C00CD2979 /* JoinedTests.swift */; };
7D489E4829CE969D00499B21 /* Algorithms.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 7D489E3F29CE969D00499B21 /* Algorithms.framework */; };
/* End PBXBuildFile section */
/* Begin PBXContainerItemProxy section */
7D489E4929CE969D00499B21 /* PBXContainerItemProxy */ = {
isa = PBXContainerItemProxy;
containerPortal = 7D489E3629CE969D00499B21 /* Project object */;
proxyType = 1;
remoteGlobalIDString = 7D489E3E29CE969D00499B21;
remoteInfo = Algorithms;
};
/* End PBXContainerItemProxy section */
/* Begin PBXFileReference section */
4347CE862CE1D54900CD2979 /* CHANGELOG.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CHANGELOG.md; path = ../CHANGELOG.md; sourceTree = SOURCE_ROOT; };
4347CE872CE1D54900CD2979 /* CODE_OF_CONDUCT.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CODE_OF_CONDUCT.md; path = ../CODE_OF_CONDUCT.md; sourceTree = SOURCE_ROOT; };
4347CE882CE1D54900CD2979 /* CONTRIBUTING.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = CONTRIBUTING.md; path = ../CONTRIBUTING.md; sourceTree = SOURCE_ROOT; };
4347CE892CE1D54900CD2979 /* LICENSE.txt */ = {isa = PBXFileReference; lastKnownFileType = text; name = LICENSE.txt; path = ../LICENSE.txt; sourceTree = SOURCE_ROOT; };
4347CE8A2CE1D54900CD2979 /* Package.resolved */ = {isa = PBXFileReference; lastKnownFileType = text; name = Package.resolved; path = ../Package.resolved; sourceTree = SOURCE_ROOT; };
4347CE8B2CE1D54900CD2979 /* Package.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = Package.swift; path = ../Package.swift; sourceTree = SOURCE_ROOT; };
4347CE8C2CE1D54900CD2979 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; name = README.md; path = ../README.md; sourceTree = SOURCE_ROOT; };
4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AdjacentPairs.swift; sourceTree = "<group>"; };
4347CE8E2CE1D54900CD2979 /* Chain.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Chain.swift; sourceTree = "<group>"; };
4347CE8F2CE1D54900CD2979 /* Chunked.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Chunked.swift; sourceTree = "<group>"; };
4347CE902CE1D54900CD2979 /* Combinations.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Combinations.swift; sourceTree = "<group>"; };
4347CE912CE1D54900CD2979 /* Compacted.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Compacted.swift; sourceTree = "<group>"; };
4347CE922CE1D54900CD2979 /* Cycle.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Cycle.swift; sourceTree = "<group>"; };
4347CE932CE1D54900CD2979 /* Documentation.docc */ = {isa = PBXFileReference; lastKnownFileType = folder.documentationcatalog; path = Documentation.docc; sourceTree = "<group>"; };
4347CE942CE1D54900CD2979 /* EitherSequence.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EitherSequence.swift; sourceTree = "<group>"; };
4347CE952CE1D54900CD2979 /* FirstNonNil.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FirstNonNil.swift; sourceTree = "<group>"; };
4347CE962CE1D54900CD2979 /* FlattenCollection.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FlattenCollection.swift; sourceTree = "<group>"; };
4347CE972CE1D54900CD2979 /* Grouped.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Grouped.swift; sourceTree = "<group>"; };
4347CE982CE1D54900CD2979 /* Indexed.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Indexed.swift; sourceTree = "<group>"; };
4347CE992CE1D54900CD2979 /* Intersperse.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Intersperse.swift; sourceTree = "<group>"; };
4347CE9A2CE1D54900CD2979 /* Joined.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Joined.swift; sourceTree = "<group>"; };
4347CE9B2CE1D54900CD2979 /* Keyed.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Keyed.swift; sourceTree = "<group>"; };
4347CE9C2CE1D54900CD2979 /* MinMax.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MinMax.swift; sourceTree = "<group>"; };
4347CE9D2CE1D54900CD2979 /* Partition.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Partition.swift; sourceTree = "<group>"; };
4347CE9E2CE1D54900CD2979 /* Permutations.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Permutations.swift; sourceTree = "<group>"; };
4347CE9F2CE1D54900CD2979 /* Product.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Product.swift; sourceTree = "<group>"; };
4347CEA02CE1D54900CD2979 /* RandomSample.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RandomSample.swift; sourceTree = "<group>"; };
4347CEA12CE1D54900CD2979 /* Reductions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Reductions.swift; sourceTree = "<group>"; };
4347CEA22CE1D54900CD2979 /* Rotate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Rotate.swift; sourceTree = "<group>"; };
4347CEA32CE1D54900CD2979 /* Split.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Split.swift; sourceTree = "<group>"; };
4347CEA42CE1D54900CD2979 /* Stride.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Stride.swift; sourceTree = "<group>"; };
4347CEA52CE1D54900CD2979 /* Suffix.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Suffix.swift; sourceTree = "<group>"; };
4347CEA62CE1D54900CD2979 /* Trim.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Trim.swift; sourceTree = "<group>"; };
4347CEA72CE1D54900CD2979 /* Unique.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Unique.swift; sourceTree = "<group>"; };
4347CEA82CE1D54900CD2979 /* Windows.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Windows.swift; sourceTree = "<group>"; };
4347CEC82CE1D54900CD2979 /* swift-algorithms.xcworkspace */ = {isa = PBXFileReference; lastKnownFileType = wrapper.workspace; path = "swift-algorithms.xcworkspace"; sourceTree = "<group>"; };
4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AdjacentPairsTests.swift; sourceTree = "<group>"; };
4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChainTests.swift; sourceTree = "<group>"; };
4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChunkedTests.swift; sourceTree = "<group>"; };
4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CombinationsTests.swift; sourceTree = "<group>"; };
4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CompactedTests.swift; sourceTree = "<group>"; };
4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CycleTests.swift; sourceTree = "<group>"; };
4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FirstNonNilTests.swift; sourceTree = "<group>"; };
4347CF102CE1D56C00CD2979 /* GroupedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GroupedTests.swift; sourceTree = "<group>"; };
4347CF112CE1D56C00CD2979 /* IndexedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IndexedTests.swift; sourceTree = "<group>"; };
4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = IntersperseTests.swift; sourceTree = "<group>"; };
4347CF132CE1D56C00CD2979 /* JoinedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = JoinedTests.swift; sourceTree = "<group>"; };
4347CF142CE1D56C00CD2979 /* KeyedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeyedTests.swift; sourceTree = "<group>"; };
4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MinMaxTests.swift; sourceTree = "<group>"; };
4347CF162CE1D56C00CD2979 /* PartitionTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PartitionTests.swift; sourceTree = "<group>"; };
4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PermutationsTests.swift; sourceTree = "<group>"; };
4347CF182CE1D56C00CD2979 /* ProductTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProductTests.swift; sourceTree = "<group>"; };
4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RandomSampleTests.swift; sourceTree = "<group>"; };
4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ReductionsTests.swift; sourceTree = "<group>"; };
4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RotateTests.swift; sourceTree = "<group>"; };
4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SplitTests.swift; sourceTree = "<group>"; };
4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = StrideTests.swift; sourceTree = "<group>"; };
4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SuffixTests.swift; sourceTree = "<group>"; };
4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TestUtilities.swift; sourceTree = "<group>"; };
4347CF202CE1D56C00CD2979 /* TrimTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TrimTests.swift; sourceTree = "<group>"; };
4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UniquePermutationsTests.swift; sourceTree = "<group>"; };
4347CF222CE1D56C00CD2979 /* UniqueTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UniqueTests.swift; sourceTree = "<group>"; };
4347CF232CE1D56C00CD2979 /* WindowsTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = WindowsTests.swift; sourceTree = "<group>"; };
7D489E3F29CE969D00499B21 /* Algorithms.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Algorithms.framework; sourceTree = BUILT_PRODUCTS_DIR; };
7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = AlgorithmsTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
7D489ED629CE96DA00499B21 /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
7D489F6F29CE986A00499B21 /* Shared.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Shared.xcconfig; sourceTree = "<group>"; };
7D489F7029CE986A00499B21 /* Algorithms.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Algorithms.xcconfig; sourceTree = "<group>"; };
7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AlgorithmsTests.xcconfig; sourceTree = "<group>"; };
BB63DC6A29D782010054E9C2 /* Algorithms.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = Algorithms.xctestplan; sourceTree = "<group>"; };
/* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */
7D489E3C29CE969D00499B21 /* Frameworks */ = {
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
7D489E4429CE969D00499B21 /* Frameworks */ = {
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
7D489E4829CE969D00499B21 /* Algorithms.framework in Frameworks */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXFrameworksBuildPhase section */
/* Begin PBXGroup section */
4347CEA92CE1D54900CD2979 /* Algorithms */ = {
isa = PBXGroup;
children = (
4347CE8D2CE1D54900CD2979 /* AdjacentPairs.swift */,
4347CE8E2CE1D54900CD2979 /* Chain.swift */,
4347CE8F2CE1D54900CD2979 /* Chunked.swift */,
4347CE902CE1D54900CD2979 /* Combinations.swift */,
4347CE912CE1D54900CD2979 /* Compacted.swift */,
4347CE922CE1D54900CD2979 /* Cycle.swift */,
4347CE932CE1D54900CD2979 /* Documentation.docc */,
4347CE942CE1D54900CD2979 /* EitherSequence.swift */,
4347CE952CE1D54900CD2979 /* FirstNonNil.swift */,
4347CE962CE1D54900CD2979 /* FlattenCollection.swift */,
4347CE972CE1D54900CD2979 /* Grouped.swift */,
4347CE982CE1D54900CD2979 /* Indexed.swift */,
4347CE992CE1D54900CD2979 /* Intersperse.swift */,
4347CE9A2CE1D54900CD2979 /* Joined.swift */,
4347CE9B2CE1D54900CD2979 /* Keyed.swift */,
4347CE9C2CE1D54900CD2979 /* MinMax.swift */,
4347CE9D2CE1D54900CD2979 /* Partition.swift */,
4347CE9E2CE1D54900CD2979 /* Permutations.swift */,
4347CE9F2CE1D54900CD2979 /* Product.swift */,
4347CEA02CE1D54900CD2979 /* RandomSample.swift */,
4347CEA12CE1D54900CD2979 /* Reductions.swift */,
4347CEA22CE1D54900CD2979 /* Rotate.swift */,
4347CEA32CE1D54900CD2979 /* Split.swift */,
4347CEA42CE1D54900CD2979 /* Stride.swift */,
4347CEA52CE1D54900CD2979 /* Suffix.swift */,
4347CEA62CE1D54900CD2979 /* Trim.swift */,
4347CEA72CE1D54900CD2979 /* Unique.swift */,
4347CEA82CE1D54900CD2979 /* Windows.swift */,
);
path = Algorithms;
sourceTree = "<group>";
};
4347CEAA2CE1D54900CD2979 /* Sources */ = {
isa = PBXGroup;
children = (
4347CEA92CE1D54900CD2979 /* Algorithms */,
);
name = Sources;
path = ../Sources;
sourceTree = SOURCE_ROOT;
};
4347CEC92CE1D54900CD2979 /* Tools */ = {
isa = PBXGroup;
children = (
4347CEC82CE1D54900CD2979 /* swift-algorithms.xcworkspace */,
);
name = Tools;
path = ../Tools;
sourceTree = SOURCE_ROOT;
};
4347CF242CE1D56C00CD2979 /* SwiftAlgorithmsTests */ = {
isa = PBXGroup;
children = (
4347CF092CE1D56C00CD2979 /* AdjacentPairsTests.swift */,
4347CF0A2CE1D56C00CD2979 /* ChainTests.swift */,
4347CF0B2CE1D56C00CD2979 /* ChunkedTests.swift */,
4347CF0C2CE1D56C00CD2979 /* CombinationsTests.swift */,
4347CF0D2CE1D56C00CD2979 /* CompactedTests.swift */,
4347CF0E2CE1D56C00CD2979 /* CycleTests.swift */,
4347CF0F2CE1D56C00CD2979 /* FirstNonNilTests.swift */,
4347CF102CE1D56C00CD2979 /* GroupedTests.swift */,
4347CF112CE1D56C00CD2979 /* IndexedTests.swift */,
4347CF122CE1D56C00CD2979 /* IntersperseTests.swift */,
4347CF132CE1D56C00CD2979 /* JoinedTests.swift */,
4347CF142CE1D56C00CD2979 /* KeyedTests.swift */,
4347CF152CE1D56C00CD2979 /* MinMaxTests.swift */,
4347CF162CE1D56C00CD2979 /* PartitionTests.swift */,
4347CF172CE1D56C00CD2979 /* PermutationsTests.swift */,
4347CF182CE1D56C00CD2979 /* ProductTests.swift */,
4347CF192CE1D56C00CD2979 /* RandomSampleTests.swift */,
4347CF1A2CE1D56C00CD2979 /* ReductionsTests.swift */,
4347CF1B2CE1D56C00CD2979 /* RotateTests.swift */,
4347CF1C2CE1D56C00CD2979 /* SplitTests.swift */,
4347CF1D2CE1D56C00CD2979 /* StrideTests.swift */,
4347CF1E2CE1D56C00CD2979 /* SuffixTests.swift */,
4347CF1F2CE1D56C00CD2979 /* TestUtilities.swift */,
4347CF202CE1D56C00CD2979 /* TrimTests.swift */,
4347CF212CE1D56C00CD2979 /* UniquePermutationsTests.swift */,
4347CF222CE1D56C00CD2979 /* UniqueTests.swift */,
4347CF232CE1D56C00CD2979 /* WindowsTests.swift */,
);
path = SwiftAlgorithmsTests;
sourceTree = "<group>";
};
4347CF252CE1D56C00CD2979 /* Tests */ = {
isa = PBXGroup;
children = (
4347CF242CE1D56C00CD2979 /* SwiftAlgorithmsTests */,
);
name = Tests;
path = ../Tests;
sourceTree = SOURCE_ROOT;
};
7D489E3529CE969D00499B21 = {
isa = PBXGroup;
children = (
4347CE862CE1D54900CD2979 /* CHANGELOG.md */,
4347CE872CE1D54900CD2979 /* CODE_OF_CONDUCT.md */,
4347CE882CE1D54900CD2979 /* CONTRIBUTING.md */,
4347CE892CE1D54900CD2979 /* LICENSE.txt */,
4347CE8A2CE1D54900CD2979 /* Package.resolved */,
4347CE8B2CE1D54900CD2979 /* Package.swift */,
4347CE8C2CE1D54900CD2979 /* README.md */,
4347CEAA2CE1D54900CD2979 /* Sources */,
4347CF252CE1D56C00CD2979 /* Tests */,
4347CEC92CE1D54900CD2979 /* Tools */,
7D489ED229CE96DA00499B21 /* Xcode */,
7D489E4029CE969D00499B21 /* Products */,
);
sourceTree = "<group>";
tabWidth = 8;
};
7D489E4029CE969D00499B21 /* Products */ = {
isa = PBXGroup;
children = (
7D489E3F29CE969D00499B21 /* Algorithms.framework */,
7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */,
);
name = Products;
sourceTree = "<group>";
};
7D489ED229CE96DA00499B21 /* Xcode */ = {
isa = PBXGroup;
children = (
BB63DC6A29D782010054E9C2 /* Algorithms.xctestplan */,
7D489F6F29CE986A00499B21 /* Shared.xcconfig */,
7D489F7029CE986A00499B21 /* Algorithms.xcconfig */,
7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */,
7D489ED629CE96DA00499B21 /* README.md */,
);
name = Xcode;
sourceTree = "<group>";
};
/* End PBXGroup section */
/* Begin PBXHeadersBuildPhase section */
7D489E3A29CE969D00499B21 /* Headers */ = {
isa = PBXHeadersBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXHeadersBuildPhase section */
/* Begin PBXNativeTarget section */
7D489E3E29CE969D00499B21 /* Algorithms */ = {
isa = PBXNativeTarget;
buildConfigurationList = 7D489E5129CE969D00499B21 /* Build configuration list for PBXNativeTarget "Algorithms" */;
buildPhases = (
7D489E3A29CE969D00499B21 /* Headers */,
7D489E3B29CE969D00499B21 /* Sources */,
7D489E3C29CE969D00499B21 /* Frameworks */,
7D489E3D29CE969D00499B21 /* Resources */,
);
buildRules = (
);
dependencies = (
);
name = Algorithms;
productName = Algorithms;
productReference = 7D489E3F29CE969D00499B21 /* Algorithms.framework */;
productType = "com.apple.product-type.framework";
};
7D489E4629CE969D00499B21 /* AlgorithmsTests */ = {
isa = PBXNativeTarget;
buildConfigurationList = 7D489E5429CE969D00499B21 /* Build configuration list for PBXNativeTarget "AlgorithmsTests" */;
buildPhases = (
7D489E4329CE969D00499B21 /* Sources */,
7D489E4429CE969D00499B21 /* Frameworks */,
7D489E4529CE969D00499B21 /* Resources */,
);
buildRules = (
);
dependencies = (
7D489E4A29CE969D00499B21 /* PBXTargetDependency */,
);
name = AlgorithmsTests;
productName = AlgorithmsTests;
productReference = 7D489E4729CE969D00499B21 /* AlgorithmsTests.xctest */;
productType = "com.apple.product-type.bundle.unit-test";
};
/* End PBXNativeTarget section */
/* Begin PBXProject section */
7D489E3629CE969D00499B21 /* Project object */ = {
isa = PBXProject;
attributes = {
BuildIndependentTargetsInParallel = 1;
LastSwiftUpdateCheck = 1420;
LastUpgradeCheck = 1500;
TargetAttributes = {
7D489E3E29CE969D00499B21 = {
CreatedOnToolsVersion = 14.2;
LastSwiftMigration = 1420;
};
7D489E4629CE969D00499B21 = {
CreatedOnToolsVersion = 14.2;
};
};
};
buildConfigurationList = 7D489E3929CE969D00499B21 /* Build configuration list for PBXProject "Algorithms" */;
compatibilityVersion = "Xcode 15.0";
developmentRegion = en;
hasScannedForEncodings = 0;
knownRegions = (
en,
Base,
);
mainGroup = 7D489E3529CE969D00499B21;
productRefGroup = 7D489E4029CE969D00499B21 /* Products */;
projectDirPath = "";
projectRoot = "";
targets = (
7D489E3E29CE969D00499B21 /* Algorithms */,
7D489E4629CE969D00499B21 /* AlgorithmsTests */,
);
};
/* End PBXProject section */
/* Begin PBXResourcesBuildPhase section */
7D489E3D29CE969D00499B21 /* Resources */ = {
isa = PBXResourcesBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
7D489E4529CE969D00499B21 /* Resources */ = {
isa = PBXResourcesBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXResourcesBuildPhase section */
/* Begin PBXSourcesBuildPhase section */
7D489E3B29CE969D00499B21 /* Sources */ = {
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4347CECC2CE1D54900CD2979 /* Suffix.swift in Sources */,
4347CECD2CE1D54900CD2979 /* Chunked.swift in Sources */,
4347CECE2CE1D54900CD2979 /* Keyed.swift in Sources */,
4347CECF2CE1D54900CD2979 /* Stride.swift in Sources */,
4347CED02CE1D54900CD2979 /* Windows.swift in Sources */,
4347CED32CE1D54900CD2979 /* Partition.swift in Sources */,
4347CED52CE1D54900CD2979 /* FirstNonNil.swift in Sources */,
4347CED62CE1D54900CD2979 /* Rotate.swift in Sources */,
4347CEDF2CE1D54900CD2979 /* Split.swift in Sources */,
4347CEE02CE1D54900CD2979 /* Chain.swift in Sources */,
4347CEE12CE1D54900CD2979 /* Trim.swift in Sources */,
4347CEE22CE1D54900CD2979 /* Product.swift in Sources */,
4347CEE42CE1D54900CD2979 /* Indexed.swift in Sources */,
4347CEE52CE1D54900CD2979 /* Documentation.docc in Sources */,
4347CEE82CE1D54900CD2979 /* Combinations.swift in Sources */,
4347CEE92CE1D54900CD2979 /* MinMax.swift in Sources */,
4347CEEA2CE1D54900CD2979 /* Joined.swift in Sources */,
4347CEEB2CE1D54900CD2979 /* Grouped.swift in Sources */,
4347CEED2CE1D54900CD2979 /* AdjacentPairs.swift in Sources */,
4347CEEE2CE1D54900CD2979 /* Permutations.swift in Sources */,
4347CEF02CE1D54900CD2979 /* FlattenCollection.swift in Sources */,
4347CEF32CE1D54900CD2979 /* Reductions.swift in Sources */,
4347CEF42CE1D54900CD2979 /* Intersperse.swift in Sources */,
4347CEF52CE1D54900CD2979 /* RandomSample.swift in Sources */,
4347CEFB2CE1D54900CD2979 /* Unique.swift in Sources */,
4347CEFD2CE1D54900CD2979 /* EitherSequence.swift in Sources */,
4347CEFE2CE1D54900CD2979 /* Cycle.swift in Sources */,
4347CEFF2CE1D54900CD2979 /* Compacted.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
7D489E4329CE969D00499B21 /* Sources */ = {
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
4347CF262CE1D56C00CD2979 /* IndexedTests.swift in Sources */,
4347CF272CE1D56C00CD2979 /* RotateTests.swift in Sources */,
4347CF282CE1D56C00CD2979 /* RandomSampleTests.swift in Sources */,
4347CF292CE1D56C00CD2979 /* StrideTests.swift in Sources */,
4347CF2A2CE1D56C00CD2979 /* IntersperseTests.swift in Sources */,
4347CF2B2CE1D56C00CD2979 /* CombinationsTests.swift in Sources */,
4347CF2C2CE1D56C00CD2979 /* SplitTests.swift in Sources */,
4347CF2D2CE1D56C00CD2979 /* ReductionsTests.swift in Sources */,
4347CF2E2CE1D56C00CD2979 /* TrimTests.swift in Sources */,
4347CF2F2CE1D56C00CD2979 /* FirstNonNilTests.swift in Sources */,
4347CF302CE1D56C00CD2979 /* SuffixTests.swift in Sources */,
4347CF312CE1D56C00CD2979 /* KeyedTests.swift in Sources */,
4347CF322CE1D56C00CD2979 /* UniqueTests.swift in Sources */,
4347CF332CE1D56C00CD2979 /* PermutationsTests.swift in Sources */,
4347CF342CE1D56C00CD2979 /* CompactedTests.swift in Sources */,
4347CF352CE1D56C00CD2979 /* UniquePermutationsTests.swift in Sources */,
4347CF362CE1D56C00CD2979 /* GroupedTests.swift in Sources */,
4347CF372CE1D56C00CD2979 /* MinMaxTests.swift in Sources */,
4347CF382CE1D56C00CD2979 /* ProductTests.swift in Sources */,
4347CF392CE1D56C00CD2979 /* ChainTests.swift in Sources */,
4347CF3A2CE1D56C00CD2979 /* ChunkedTests.swift in Sources */,
4347CF3B2CE1D56C00CD2979 /* PartitionTests.swift in Sources */,
4347CF3C2CE1D56C00CD2979 /* CycleTests.swift in Sources */,
4347CF3D2CE1D56C00CD2979 /* AdjacentPairsTests.swift in Sources */,
4347CF3E2CE1D56C00CD2979 /* TestUtilities.swift in Sources */,
4347CF3F2CE1D56C00CD2979 /* WindowsTests.swift in Sources */,
4347CF402CE1D56C00CD2979 /* JoinedTests.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXSourcesBuildPhase section */
/* Begin PBXTargetDependency section */
7D489E4A29CE969D00499B21 /* PBXTargetDependency */ = {
isa = PBXTargetDependency;
target = 7D489E3E29CE969D00499B21 /* Algorithms */;
targetProxy = 7D489E4929CE969D00499B21 /* PBXContainerItemProxy */;
};
/* End PBXTargetDependency section */
/* Begin XCBuildConfiguration section */
7D489E4F29CE969D00499B21 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F6F29CE986A00499B21 /* Shared.xcconfig */;
buildSettings = {
};
name = Debug;
};
7D489E5029CE969D00499B21 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F6F29CE986A00499B21 /* Shared.xcconfig */;
buildSettings = {
};
name = Release;
};
7D489E5229CE969D00499B21 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F7029CE986A00499B21 /* Algorithms.xcconfig */;
buildSettings = {
};
name = Debug;
};
7D489E5329CE969D00499B21 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F7029CE986A00499B21 /* Algorithms.xcconfig */;
buildSettings = {
};
name = Release;
};
7D489E5529CE969D00499B21 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */;
buildSettings = {
};
name = Debug;
};
7D489E5629CE969D00499B21 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7D489F7129CE986A00499B21 /* AlgorithmsTests.xcconfig */;
buildSettings = {
};
name = Release;
};
/* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */
7D489E3929CE969D00499B21 /* Build configuration list for PBXProject "Algorithms" */ = {
isa = XCConfigurationList;
buildConfigurations = (
7D489E4F29CE969D00499B21 /* Debug */,
7D489E5029CE969D00499B21 /* Release */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
7D489E5129CE969D00499B21 /* Build configuration list for PBXNativeTarget "Algorithms" */ = {
isa = XCConfigurationList;
buildConfigurations = (
7D489E5229CE969D00499B21 /* Debug */,
7D489E5329CE969D00499B21 /* Release */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
7D489E5429CE969D00499B21 /* Build configuration list for PBXNativeTarget "AlgorithmsTests" */ = {
isa = XCConfigurationList;
buildConfigurations = (
7D489E5529CE969D00499B21 /* Debug */,
7D489E5629CE969D00499B21 /* Release */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
/* End XCConfigurationList section */
};
rootObject = 7D489E3629CE969D00499B21 /* Project object */;
}
@@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<Workspace
version = "1.0">
<FileRef
location = "self:">
</FileRef>
</Workspace>
@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>IDEDidComputeMac32BitWarning</key>
<true/>
</dict>
</plist>
@@ -0,0 +1,84 @@
<?xml version="1.0" encoding="UTF-8"?>
<Scheme
LastUpgradeVersion = "1500"
version = "1.7">
<BuildAction
parallelizeBuildables = "YES"
buildImplicitDependencies = "YES">
<BuildActionEntries>
<BuildActionEntry
buildForTesting = "YES"
buildForRunning = "YES"
buildForProfiling = "YES"
buildForArchiving = "YES"
buildForAnalyzing = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "7D489E3E29CE969D00499B21"
BuildableName = "Algorithms.framework"
BlueprintName = "Algorithms"
ReferencedContainer = "container:Algorithms.xcodeproj">
</BuildableReference>
</BuildActionEntry>
</BuildActionEntries>
</BuildAction>
<TestAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
shouldUseLaunchSchemeArgsEnv = "YES">
<TestPlans>
<TestPlanReference
reference = "container:Algorithms.xctestplan"
default = "YES">
</TestPlanReference>
</TestPlans>
<Testables>
<TestableReference
skipped = "NO"
parallelizable = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "7D489E4629CE969D00499B21"
BuildableName = "AlgorithmsTests.xctest"
BlueprintName = "AlgorithmsTests"
ReferencedContainer = "container:Algorithms.xcodeproj">
</BuildableReference>
</TestableReference>
</Testables>
</TestAction>
<LaunchAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
launchStyle = "0"
useCustomWorkingDirectory = "NO"
ignoresPersistentStateOnLaunch = "NO"
debugDocumentVersioning = "YES"
debugServiceExtension = "internal"
allowLocationSimulation = "YES">
</LaunchAction>
<ProfileAction
buildConfiguration = "Release"
shouldUseLaunchSchemeArgsEnv = "YES"
savedToolIdentifier = ""
useCustomWorkingDirectory = "NO"
debugDocumentVersioning = "YES">
<MacroExpansion>
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "7D489E3E29CE969D00499B21"
BuildableName = "Algorithms.framework"
BlueprintName = "Algorithms"
ReferencedContainer = "container:Algorithms.xcodeproj">
</BuildableReference>
</MacroExpansion>
</ProfileAction>
<AnalyzeAction
buildConfiguration = "Debug">
</AnalyzeAction>
<ArchiveAction
buildConfiguration = "Release"
revealArchiveInOrganizer = "YES">
</ArchiveAction>
</Scheme>
+32
View File
@@ -0,0 +1,32 @@
{
"configurations" : [
{
"id" : "CF37E70B-D810-4CF2-AB41-571BAFF72572",
"name" : "Default",
"options" : {
}
},
{
"id" : "33436295-E24E-439B-9B8E-4602E0A6C8BB",
"name" : "TSan",
"options" : {
"threadSanitizerEnabled" : true
}
}
],
"defaultOptions" : {
"codeCoverage" : false
},
"testTargets" : [
{
"parallelizable" : true,
"target" : {
"containerPath" : "container:Algorithms.xcodeproj",
"identifier" : "7D489E4629CE969D00499B21",
"name" : "AlgorithmsTests"
}
}
],
"version" : 1
}
+23
View File
@@ -0,0 +1,23 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2023 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
//
//===----------------------------------------------------------------------===//
PRODUCT_NAME = AlgorithmsTests
PRODUCT_BUNDLE_IDENTIFIER = org.swift.AlgorithmsTests
SUPPORTED_PLATFORMS = macosx iphoneos iphonesimulator watchos watchsimulator appletvos appletvsimulator
ARCHS = $(ARCHS_STANDARD)
CURRENT_PROJECT_VERSION = 1
MARKETING_VERSION = 1.0
GENERATE_INFOPLIST_FILE = YES
ENABLE_TESTABILITY = NO
+5
View File
@@ -0,0 +1,5 @@
# Xcode build files
The project file here can be used to build a variant of this package with Xcode, producing a single framework bundle. Build settings are entirely configured via the provided xcconfig files.
Beware! The contents of this directory are not source stable. They are provided as is, with no compatibility promises across package releases. Future versions of this package can arbitrarily change these files or remove them, without any advance notice. (This can include patch releases.)
+88
View File
@@ -0,0 +1,88 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Algorithms open source project
//
// Copyright (c) 2023 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
//
//===----------------------------------------------------------------------===//
SDKROOT = macosx
CODE_SIGN_STYLE = Automatic
CODE_SIGN_IDENTITY = -
CODE_SIGN_IDENTITY[sdk=iphoneos*] = "iOS Developer"
CODE_SIGN_IDENTITY[sdk=watchos*] = "iOS Developer"
CODE_SIGN_IDENTITY[sdk=appletvos*] = "iOS Developer"
SWIFT_VERSION = 5.5
ONLY_ACTIVE_ARCH[config=Debug] = YES
SWIFT_ACTIVE_COMPILATION_CONDITIONS = $(inherited) ALGORITHMS_DARWIN_ONLY
SWIFT_COMPILATION_MODE[config=Release] = wholemodule
SWIFT_COMPILATION_MODE[config=Debug] = singlefile
SWIFT_OPTIMIZATION_LEVEL[config=Release] = -O
SWIFT_OPTIMIZATION_LEVEL[config=Debug] = -Onone
SWIFT_EMIT_LOC_STRINGS = NO
SWIFT_INSTALL_OBJC_HEADER = NO
COPY_PHASE_STRIP = NO
DEBUG_INFORMATION_FORMAT[config=Release] = dwarf-with-dsym
DEBUG_INFORMATION_FORMAT[config=Debug] = dwarf
ALWAYS_SEARCH_USER_PATHS = NO
ENABLE_TESTABILITY = NO
ENABLE_USER_SCRIPT_SANDBOXING = YES
DEAD_CODE_STRIPPING = YES
GCC_DYNAMIC_NO_PIC = NO
GCC_NO_COMMON_BLOCKS = YES
GCC_OPTIMIZATION_LEVEL[config=Debug] = 0
GCC_C_LANGUAGE_STANDARD = gnu11
CLANG_CXX_LANGUAGE_STANDARD = gnu++20
CLANG_ENABLE_MODULES = YES
CLANG_ENABLE_OBJC_ARC = YES
CLANG_ENABLE_OBJC_WEAK = YES
ENABLE_NS_ASSERTIONS[config=Release] = NO
ENABLE_STRICT_OBJC_MSGSEND = YES
GCC_PREPROCESSOR_DEFINITIONS[config=Release] = DEBUG=1 $(inherited)
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES
CLANG_WARN_BOOL_CONVERSION = YES
CLANG_WARN_COMMA = YES
CLANG_WARN_CONSTANT_CONVERSION = YES
CLANG_WARN_DOCUMENTATION_COMMENTS = YES
CLANG_WARN_EMPTY_BODY = YES
CLANG_WARN_ENUM_CONVERSION = YES
CLANG_WARN_INFINITE_RECURSION = YES
CLANG_WARN_INT_CONVERSION = YES
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES
CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES
CLANG_WARN_STRICT_PROTOTYPES = YES
CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE
CLANG_WARN_UNREACHABLE_CODE = YES
GCC_WARN_64_TO_32_BIT_CONVERSION = YES
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE
GCC_WARN_UNUSED_FUNCTION = YES
GCC_WARN_UNUSED_VARIABLE = YES
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES
CLANG_WARN_SUSPICIOUS_MOVE = YES
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES
GCC_WARN_UNDECLARED_SELECTOR = YES
CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES
CLANG_ANALYZER_NONNULL = YES
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE