Files
Karl 9783c1be91 Inline all the things! 🎨 (#109)
* Make suffix functions inlinable

* Inline all the things!
2021-03-23 15:00:09 -05:00

751 lines
25 KiB
Swift

//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
// LazySplitSequence
//===----------------------------------------------------------------------===//
/// A sequence that lazily splits a base sequence into subsequences separated by
/// elements that satisfy the given `whereSeparator` predicate.
///
/// - Note: This type is the result of
///
/// x.split(maxSplits:omittingEmptySubsequences:whereSeparator)
/// x.split(separator:maxSplits:omittingEmptySubsequences)
///
/// where `x` conforms to `LazySequenceProtocol`.
public struct LazySplitSequence<Base: Sequence> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let isSeparator: (Base.Element) -> Bool
@usableFromInline
internal let maxSplits: Int
@usableFromInline
internal let omittingEmptySubsequences: Bool
@inlinable
internal init(
base: Base,
isSeparator: @escaping (Base.Element) -> Bool,
maxSplits: Int,
omittingEmptySubsequences: Bool
) {
self.base = base
self.isSeparator = isSeparator
self.maxSplits = maxSplits
self.omittingEmptySubsequences = omittingEmptySubsequences
}
}
extension LazySplitSequence {
public struct Iterator {
public typealias Element = [Base.Element]
@usableFromInline
internal var base: Base.Iterator
@usableFromInline
internal let isSeparator: (Base.Element) -> Bool
@usableFromInline
internal let maxSplits: Int
@usableFromInline
internal let omittingEmptySubsequences: Bool
/// The number of splits performed.
@usableFromInline
internal var splitCount = 0
/// The number of subsequences returned.
@usableFromInline
internal var sequenceLength = 0
@inlinable
internal init(
base: Base.Iterator,
whereSeparator: @escaping (Base.Element) -> Bool,
maxSplits: Int,
omittingEmptySubsequences: Bool
) {
self.base = base
self.isSeparator = whereSeparator
self.maxSplits = maxSplits
self.omittingEmptySubsequences = omittingEmptySubsequences
}
}
}
extension LazySplitSequence.Iterator: IteratorProtocol {
@inlinable
public mutating func next() -> Element? {
var currentElement = 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!) {
if omittingEmptySubsequences && subsequence.isEmpty {
// Keep going if we don't want to return an empty subsequence.
currentElement = base.next()
continue
} else {
splitCount += 1
break
}
} else {
subsequence.append(currentElement!)
currentElement = base.next()
}
}
// We're done iterating when we've reached the end of the base sequence,
// 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
&& (sequenceLength == splitCount + 1
|| omittingEmptySubsequences && subsequence.isEmpty)
{
return nil
} else {
sequenceLength += 1
return subsequence
}
}
}
extension LazySplitSequence: LazySequenceProtocol {
@inlinable
public func makeIterator() -> Iterator {
return Iterator(
base: base.makeIterator(),
whereSeparator: self.isSeparator,
maxSplits: self.maxSplits,
omittingEmptySubsequences: self.omittingEmptySubsequences
)
}
}
extension LazySequenceProtocol {
/// Lazily returns the longest possible subsequences of the sequence, in
/// order, that don't contain elements satisfying the given predicate.
///
/// The resulting lazy sequence consists of at most `maxSplits + 1`
/// subsequences. Elements that are used to split the sequence are not
/// returned as part of any subsequence (except possibly the last one, in the
/// case where `maxSplits` is less than the number of separators in the
/// sequence).
///
/// The following examples show the effects of the `maxSplits` and
/// `omittingEmptySubsequences` parameters when lazily splitting a sequence of
/// integers using a closure that matches numbers evenly divisible by 3 or 5.
/// The first use of `split` returns each subsequence that was originally
/// separated by one or more such numbers.
///
/// let numbers = stride(from: 1, through: 16, by: 1)
/// for subsequence in numbers.lazy.split(
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
/// ) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [4]
/// [7, 8]
/// [11]
/// [13, 14]
/// [16]
/// */
///
/// The second example passes `1` for the `maxSplits` parameter, so the
/// original sequence is split just once, into two subsequences.
///
/// for subsequence in numbers.lazy.split(
/// maxSplits: 1,
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
/// ) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
/// */
///
/// The final example passes `false` for the `omittingEmptySubsequences`
/// parameter, so the sequence of returned subsequences contains empty
/// subsequences where numbers evenly divisible by 3 or 5 were repeated.
///
/// for subsequence in numbers.lazy.split(
/// omittingEmptySubsequences: false,
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
/// ) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [4]
/// []
/// [7, 8]
/// []
/// [11]
/// [13, 14]
/// [16]
/// */
///
/// - Parameters:
/// - maxSplits: The maximum number of times to split the sequence, or
/// one less than the number of subsequences to return. If
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
/// of the original sequence containing the remaining elements.
/// `maxSplits` must be greater than or equal to zero. The default value
/// is `Int.max`.
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
/// returned in the result for each pair of consecutive elements
/// 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
/// 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
/// elements.
///
/// - Complexity: O(*n*), where *n* is the length of the sequence.
@inlinable
public func split(
maxSplits: Int = Int.max,
omittingEmptySubsequences: Bool = true,
whereSeparator isSeparator: @escaping (Element) -> Bool
) -> LazySplitSequence<Elements> {
precondition(maxSplits >= 0, "Must take zero or more splits")
return LazySplitSequence(
base: elements,
isSeparator: isSeparator,
maxSplits: maxSplits,
omittingEmptySubsequences: omittingEmptySubsequences
)
}
}
extension LazySequenceProtocol where Element: Equatable {
/// Lazily returns the longest possible subsequences of the sequence, in
/// order, around elements equal to the given element.
///
/// The resulting lazy sequence consists of at most `maxSplits + 1`
/// subsequences. Elements that are used to split the sequence are not
/// returned as part of any subsequence (except possibly the last one, in the
/// case where `maxSplits` is less than the number of separators in the
/// sequence).
///
/// The following examples show the effects of the `maxSplits` and
/// `omittingEmptySubsequences` parameters when splitting a sequence of
/// integers at each zero (`0`). The first use of `split` returns each
/// subsequence that was originally separated by one or more zeros.
///
/// let numbers = AnySequence([1, 2, 0, 3, 4, 0, 0, 5])
/// for subsequence in numbers.lazy.split(separator: 0) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [3, 4]
/// [5]
/// */
///
/// The second example passes `1` for the `maxSplits` parameter, so the
/// original sequence is split just once, into two subsequences.
///
/// for subsequence in numbers.lazy.split(
/// separator: 0,
/// maxSplits: 1
/// ) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [3, 4, 0, 0, 5]
/// */
///
/// The final example passes `false` for the `omittingEmptySubsequences`
/// parameter, so the sequence of returned subsequences contains empty
/// subsequences where zeros were repeated.
///
/// for subsequence in numbers.lazy.split(
/// separator: 0,
/// omittingEmptySubsequences: false
/// ) {
/// print(subsequence)
/// }
/// /* Prints:
/// [1, 2]
/// [3, 4]
/// []
/// [5]
/// */
///
/// - Parameters:
/// - separator: The element that should be split upon.
/// - maxSplits: The maximum number of times to split the sequence, or
/// one less than the number of subsequences to return. If
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
/// of the original sequence containing the remaining elements.
/// `maxSplits` must be greater than or equal to zero. The default value
/// is `Int.max`.
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
/// returned in the result for each consecutive pair of `separator`
/// elements in the sequence and for each instance of `separator` at
/// the start or end of the sequence. If `true`, only nonempty
/// subsequences are returned. The default value is `true`.
/// - Returns: A lazy sequence of subsequences, split from this sequence's
/// elements.
///
/// - Complexity: O(*n*), where *n* is the length of the sequence.
@inlinable
public func split(
separator: Element,
maxSplits: Int = Int.max,
omittingEmptySubsequences: Bool = true
) -> LazySplitSequence<Elements> {
precondition(maxSplits >= 0, "Must take zero or more splits")
return LazySplitSequence(
base: elements,
isSeparator: { $0 == separator },
maxSplits: maxSplits,
omittingEmptySubsequences: omittingEmptySubsequences
)
}
}
//===----------------------------------------------------------------------===//
// LazySplitCollection
//===----------------------------------------------------------------------===//
/// A collection that lazily splits a base collection into subsequences
/// separated by elements that satisfy the given `whereSeparator` predicate.
///
/// - Note: This type is the result of
///
/// x.split(maxSplits:omittingEmptySubsequences:whereSeparator)
/// x.split(separator:maxSplits:omittingEmptySubsequences)
///
/// where `x` conforms to `LazyCollectionProtocol`.
public struct LazySplitCollection<Base: Collection> {
@usableFromInline
internal let base: Base
@usableFromInline
internal let isSeparator: (Base.Element) -> Bool
@usableFromInline
internal let maxSplits: Int
@usableFromInline
internal let omittingEmptySubsequences: Bool
@usableFromInline
internal var _startIndex: Index
@inlinable
internal init(
base: Base,
isSeparator: @escaping (Base.Element) -> Bool,
maxSplits: Int,
omittingEmptySubsequences: Bool
) {
self.base = base
self.isSeparator = isSeparator
self.maxSplits = maxSplits
self.omittingEmptySubsequences = omittingEmptySubsequences
// We precalculate `startIndex`. There are three possibilities:
// 1. `base` is empty and we're _not_ omitting empty subsequences, in which
// case the following index describes the sole element of this collection;
self._startIndex = Index(
baseRange: base.startIndex..<base.startIndex,
sequenceLength: 1,
splitCount: 0
)
if base.isEmpty {
if omittingEmptySubsequences {
// 2. `base` is empty and we _are_ omitting empty subsequences, so this
// collection has no elements;
_startIndex = endIndex
}
} else {
// 3. `base` isn't empty, so we must iterate it to determine the start
// index.
_startIndex = indexForSubsequence(
atOrAfter: base.startIndex,
sequenceLength: 0,
splitCount: 0
)
}
}
}
extension LazySplitCollection: LazyCollectionProtocol {
/// Position of a subsequence in a split collection.
public struct Index: Comparable {
/// The range corresponding to the subsequence at this position.
@usableFromInline
internal let baseRange: Range<Base.Index>
/// The number of subsequences up to and including this position in the
/// collection.
@usableFromInline
internal let sequenceLength: Int
/// The number splits performed up to and including this position in the
/// collection.
@usableFromInline
internal let splitCount: Int
@inlinable
internal init(
baseRange: Range<Base.Index>,
sequenceLength: Int,
splitCount: Int
) {
self.baseRange = baseRange
self.sequenceLength = sequenceLength
self.splitCount = splitCount
}
@inlinable
public static func == (lhs: Index, rhs: Index) -> Bool {
// `sequenceLength` is equivalent to the index's 1-based position in the
// collection of indices.
lhs.sequenceLength == rhs.sequenceLength
}
@inlinable
public static func < (lhs: Index, rhs: Index) -> Bool {
lhs.sequenceLength < rhs.sequenceLength
}
}
/// Returns the index of the subsequence starting at or after the given base
/// collection index.
@inlinable
internal func indexForSubsequence(
atOrAfter lowerBound: Base.Index,
sequenceLength: Int,
splitCount: Int
) -> Index {
var start = lowerBound
// If we don't have any more splits to do (which we'll determine shortly),
// the end of this subsequence will be the end of the base collection.
var end = base.endIndex
if splitCount < maxSplits {
// The non-inclusive end of this subsequence is marked by the next
// separator, or the end of the base collection.
end =
base[start...].firstIndex(where: isSeparator)
?? base.endIndex
if base[start..<end].isEmpty {
if omittingEmptySubsequences {
// Find the next subsequence of non-separators.
start =
base[end...].firstIndex(where: { !isSeparator($0) })
?? base.endIndex
if start == base.endIndex {
// No non-separators left in the base collection. We're done.
return endIndex
}
end = base[start...].firstIndex(where: isSeparator) ?? base.endIndex
}
}
}
var updatedSplitCount = splitCount
if end < base.endIndex {
// This subsequence ends on a separator (and perhaps includes other
// separators, if we're omitting empty subsequences), so we've performed
// another split.
updatedSplitCount += 1
}
return Index(
baseRange: start..<end,
sequenceLength: sequenceLength + 1,
splitCount: updatedSplitCount
)
}
@inlinable
public var startIndex: Index {
_startIndex
}
@inlinable
public var endIndex: Index {
Index(
baseRange: base.endIndex..<base.endIndex,
sequenceLength: Int.max,
splitCount: Int.max
)
}
@inlinable
public func index(after i: Index) -> Index {
precondition(i != endIndex, "Can't advance past endIndex")
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 at the following element.
subsequenceStart = base.index(after: i.baseRange.upperBound)
}
guard subsequenceStart != base.endIndex else {
if !omittingEmptySubsequences
&& i.sequenceLength < i.splitCount + 1
{
// The base collection ended with a separator, so we need to emit one
// more empty subsequence. This one differs from `endIndex` in its
// `sequenceLength` (except in an extreme edge case!), which is the
// sole property tested for equality and comparison.
return Index(
baseRange: base.endIndex..<base.endIndex,
sequenceLength: i.sequenceLength + 1,
splitCount: i.splitCount
)
} else {
return endIndex
}
}
return indexForSubsequence(
atOrAfter: subsequenceStart,
sequenceLength: i.sequenceLength,
splitCount: i.splitCount
)
}
@inlinable
public subscript(position: Index) -> Base.SubSequence {
precondition(position != endIndex, "Can't subscript using endIndex")
return base[position.baseRange]
}
}
extension LazySplitCollection.Index: Hashable {
public func hash(into hasher: inout Hasher) {
hasher.combine(sequenceLength)
}
}
extension LazyCollectionProtocol {
/// Lazily returns the longest possible subsequences of the collection, in
/// order, that don't contain elements satisfying the given predicate.
///
/// The resulting lazy collection consists of at most `maxSplits + 1`
/// subsequences. Elements that are used to split the collection are not
/// returned as part of any subsequence (except possibly the last one, in the
/// case where `maxSplits` is less than the number of separators in the
/// collection).
///
/// The following examples show the effects of the `maxSplits` and
/// `omittingEmptySubsequences` parameters when lazily splitting a string
/// using a closure that matches spaces. The first use of `split` returns each
/// word that was originally separated by one or more spaces.
///
/// let line = "BLANCHE: I don't want realism. I want magic!"
/// for spaceless in line.lazy.split(whereSeparator: { $0 == " " }) {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// // I
/// // don't
/// // want
/// // realism.
/// // I
/// // want
/// // magic!
///
/// The second example passes `1` for the `maxSplits` parameter, so the
/// original string is split just once, into two new strings.
///
/// for spaceless in line.lazy.split(
/// maxSplits: 1,
/// whereSeparator: { $0 == " " }
/// ) {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// // I don't want realism. I want magic!
///
/// The final example passes `false` for the `omittingEmptySubsequences`
/// parameter, so the returned array contains empty strings where spaces
/// were repeated.
///
/// for spaceless in line.lazy.split(
/// omittingEmptySubsequences: false,
/// whereSeparator: { $0 == " " }
/// ) {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// //
/// //
/// // I
/// // don't
/// // want
/// // realism.
/// // I
/// // want
/// // magic!
///
/// - Parameters:
/// - maxSplits: The maximum number of times to split the collection, or
/// one less than the number of subsequences to return. If
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
/// of the original collection containing the remaining elements.
/// `maxSplits` must be greater than or equal to zero. The default value
/// is `Int.max`.
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
/// returned in the result for each pair of consecutive elements
/// 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
/// 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
/// elements.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
public func split(
maxSplits: Int = Int.max,
omittingEmptySubsequences: Bool = true,
whereSeparator isSeparator: @escaping (Element) -> Bool
) -> LazySplitCollection<Elements> {
precondition(maxSplits >= 0, "Must take zero or more splits")
return LazySplitCollection(
base: elements,
isSeparator: isSeparator,
maxSplits: maxSplits,
omittingEmptySubsequences: omittingEmptySubsequences
)
}
}
extension LazyCollectionProtocol
where Element: Equatable {
/// Lazily returns the longest possible subsequences of the collection, in
/// order, around elements equal to the given element.
///
/// The resulting lazy collection consists of at most `maxSplits + 1`
/// subsequences. Elements that are used to split the collection are not
/// returned as part of any subsequence (except possibly the last one, in the
/// case where `maxSplits` is less than the number of separators in the
/// collection).
///
/// The following examples show the effects of the `maxSplits` and
/// `omittingEmptySubsequences` parameters when splitting a string at each
/// space character (" "). The first use of `split` returns each word that
/// was originally separated by one or more spaces.
///
/// let line = "BLANCHE: I don't want realism. I want magic!"
/// for spaceless in line.lazy.split(separator: " ") {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// // I
/// // don't
/// // want
/// // realism.
/// // I
/// // want
/// // magic!
///
/// The second example passes `1` for the `maxSplits` parameter, so the
/// original string is split just once, into two new strings.
///
/// for spaceless in line.lazy.split(separator: " ", maxSplits: 1) {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// // I don't want realism. I want magic!
///
/// The final example passes `false` for the `omittingEmptySubsequences`
/// parameter, so the returned array contains empty strings where spaces
/// were repeated.
///
/// for spaceless in line.lazy.split(
/// separator: " ",
/// omittingEmptySubsequences: false
/// ) {
/// print(spaceless)
/// }
/// // Prints
/// // BLANCHE:
/// //
/// //
/// // I
/// // don't
/// // want
/// // realism.
/// // I
/// // want
/// // magic!
///
/// - Parameters:
/// - separator: The element that should be split upon.
/// - maxSplits: The maximum number of times to split the collection, or
/// one less than the number of subsequences to return. If
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
/// of the original collection containing the remaining elements.
/// `maxSplits` must be greater than or equal to zero. The default value
/// is `Int.max`.
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
/// returned in the result for each consecutive pair of `separator`
/// elements in the collection and for each instance of `separator` at
/// the start or end of the collection. If `true`, only nonempty
/// subsequences are returned. The default value is `true`.
/// - Returns: A lazy collection of subsequences split from this collection's
/// elements.
///
/// - Complexity: O(*n*), where *n* is the length of the collection.
@inlinable
public func split(
separator: Element,
maxSplits: Int = Int.max,
omittingEmptySubsequences: Bool = true
) -> LazySplitCollection<Elements> {
precondition(maxSplits >= 0, "Must take zero or more splits")
return LazySplitCollection(
base: elements,
isSeparator: { $0 == separator },
maxSplits: maxSplits,
omittingEmptySubsequences: omittingEmptySubsequences
)
}
}