Add inlinability annotations throughout

Author: natecook1000

Sources/Algorithms/Chain.swift

@@ -28,19 +28,25 @@ public struct Chain<Base1: Sequence, Base2: Sequence>
 extension Chain: Sequence {
   /// The iterator for a `Chain` sequence.
   public struct Iterator: IteratorProtocol {
+    @usableFromInline
     internal var iterator1: Base1.Iterator
+    
+    @usableFromInline
     internal var iterator2: Base2.Iterator
 
+    @usableFromInline
     internal init(_ concatenation: Chain) {
       iterator1 = concatenation.base1.makeIterator()
       iterator2 = concatenation.base2.makeIterator()
     }
 
+    @inlinable
     public mutating func next() -> Base1.Element? {
       return iterator1.next() ?? iterator2.next()
     }
   }
 
+  @inlinable
   public func makeIterator() -> Iterator {
     Iterator(self)
   }
@@ -54,23 +60,28 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
     // is not to be used as a value - iterating over indices should go straight
     // from the penultimate index of the first collection to the start of the
     // second.
+    @usableFromInline
     internal enum Representation : Equatable {
       case first(Base1.Index)
       case second(Base2.Index)
     }
 
+    @usableFromInline
     internal let position: Representation
 
     /// Creates a new index into the first underlying collection.
+    @usableFromInline
     internal init(first i: Base1.Index) {
       position = .first(i)
     }
 
     /// Creates a new index into the second underlying collection.
+    @usableFromInline
     internal init(second i: Base2.Index) {
       position = .second(i)
     }
 
+    @inlinable
     public static func < (lhs: Index, rhs: Index) -> Bool {
       switch (lhs.position, rhs.position) {
       case (.first, .second):
@@ -87,20 +98,24 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
 
   /// Converts an index of `Base1` to the corresponding `Index` by mapping
   /// `base1.endIndex` to `base2.startIndex`.
+  @usableFromInline
   internal func convertIndex(_ i: Base1.Index) -> Index {
     i == base1.endIndex ? Index(second: base2.startIndex) : Index(first: i)
   }
 
+  @inlinable
   public var startIndex: Index {
     // if `base1` is empty, this will return `base2.startIndex` - if `base2` is
     // also empty, this will correctly equal `base2.endIndex`
     convertIndex(base1.startIndex)
   }
 
+  @inlinable
   public var endIndex: Index {
     return Index(second: base2.endIndex)
   }
 
+  @inlinable
   public subscript(i: Index) -> Base1.Element {
     switch i.position {
     case let .first(i):
@@ -110,6 +125,7 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
     }
   }
 
+  @inlinable
   public func index(after i: Index) -> Index {
     switch i.position {
     case let .first(i):
@@ -120,13 +136,15 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
     }
   }
 
+  @inlinable
   public func index(_ i: Index, offsetBy n: Int) -> Index {
     if n == 0 { return i }
     return n > 0
       ? offsetForward(i, by: n, limitedBy: endIndex)!
       : offsetBackward(i, by: -n, limitedBy: startIndex)!
   }
 
+  @inlinable
   public func index(
     _ i: Index,
     offsetBy n: Int,
@@ -138,7 +156,8 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
       : offsetBackward(i, by: -n, limitedBy: limit)
   }
 
-  private func offsetForward(
+  @usableFromInline
+  internal func offsetForward(
     _ i: Index, by n: Int, limitedBy limit: Index
   ) -> Index? {
     switch (i.position, limit.position) {
@@ -177,7 +196,8 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
     }
   }
 
-  private func offsetBackward(
+  @usableFromInline
+  internal func offsetBackward(
     _ i: Index, by n: Int, limitedBy limit: Index
   ) -> Index? {
     switch (i.position, limit.position) {
@@ -216,6 +236,7 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
     }
   }
 
+  @inlinable
   public func distance(from start: Index, to end: Index) -> Int {
     switch (start.position, end.position) {
     case let (.first(i), .first(j)):
@@ -235,6 +256,7 @@ extension Chain: Collection where Base1: Collection, Base2: Collection {
 extension Chain: 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 {

Sources/Algorithms/Chunked.swift

@@ -14,22 +14,38 @@ public struct LazyChunked<Base: Collection> {
   public let base: Base
 
   /// The projection function.
+  @usableFromInline
   internal var belongInSameGroup: (Base.Element, Base.Element) -> Bool
+  
+  @usableFromInline
+  internal init(base: Base, belongInSameGroup: @escaping (Base.Element, Base.Element) -> Bool) {
+    self.base = base
+    self.belongInSameGroup = belongInSameGroup
+  }
 }
 
 extension LazyChunked: LazyCollectionProtocol {
   /// A position in a chunked collection.
   public struct Index: Comparable {
     /// The lower bound of the chunk at this position.
+    @usableFromInline
     internal var lowerBound: Base.Index
 
     /// The upper bound of the chunk at this position.
     ///
     /// `upperBound` is optional so that computing `startIndex` can be an O(1)
     /// operation. When `upperBound` is `nil`, the actual upper bound is found
     /// when subscripting or calling `index(after:)`.
+    @usableFromInline
     internal var upperBound: Base.Index?
 
+    @usableFromInline
+    internal init(lowerBound: Base.Index, upperBound: Base.Index? = nil) {
+      self.lowerBound = lowerBound
+      self.upperBound = upperBound
+    }
+    
+    @inlinable
     public static func == (lhs: Index, rhs: Index) -> Bool {
       // Only use the lower bound to test for equality, since sometimes the
       // `startIndex` will have an upper bound of `nil` and sometimes it won't,
@@ -41,6 +57,7 @@ extension LazyChunked: LazyCollectionProtocol {
       lhs.lowerBound == rhs.lowerBound
     }
 
+    @inlinable
     public static func < (lhs: Index, rhs: Index) -> Bool {
       // Only use the lower bound to test for ordering, as above.
       lhs.lowerBound < rhs.lowerBound
@@ -49,26 +66,31 @@ extension LazyChunked: LazyCollectionProtocol {
 
   /// Returns the index in the base collection for the first element that
   /// doesn't match the current chunk.
+  @usableFromInline
   internal func endOfChunk(from i: Base.Index) -> Base.Index {
     guard i != base.endIndex else { return base.endIndex }
     return base[base.index(after: i)...]
       .firstIndex(where: { !belongInSameGroup($0, base[i]) }) ?? base.endIndex
   }
 
+  @inlinable
   public var startIndex: Index {
     Index(lowerBound: base.startIndex)
   }
 
+  @inlinable
   public var endIndex: Index {
     Index(lowerBound: base.endIndex, upperBound: base.endIndex)
   }
 
+  @inlinable
   public func index(after i: Index) -> Index {
     let upperBound = i.upperBound ?? endOfChunk(from: i.lowerBound)
     let end = endOfChunk(from: upperBound)
     return Index(lowerBound: upperBound, upperBound: end)
   }
 
+  @inlinable
   public subscript(position: Index) -> Base.SubSequence {
     let upperBound = position.upperBound
       ?? endOfChunk(from: position.lowerBound)
@@ -83,6 +105,7 @@ extension LazyChunked: BidirectionalCollection
 {
   /// Returns the index in the base collection for the element that starts
   /// the chunk ending at the given index.
+  @usableFromInline
   internal func startOfChunk(endingAt end: Base.Index) -> Base.Index {
     // Get the projected value of the last element in the range ending at `end`.
     let lastOfPreviousChunk = base[base.index(before: end)]
@@ -102,6 +125,7 @@ extension LazyChunked: BidirectionalCollection
     }
   }
 
+  @inlinable
   public func index(before i: Index) -> Index {
     let start = startOfChunk(endingAt: i.lowerBound)
     return Index(lowerBound: start, upperBound: i.lowerBound)
@@ -119,6 +143,7 @@ extension LazyCollectionProtocol {
   /// - Complexity: O(1). When iterating over the resulting collection,
   ///   accessing each successive chunk has a complexity of O(*m*), where *m*
   ///   is the length of the chunk.
+  @inlinable
   public func chunked(
     by belongInSameGroup: @escaping (Element, Element) -> Bool
   ) -> LazyChunked<Elements> {
@@ -131,6 +156,7 @@ extension LazyCollectionProtocol {
   /// - Complexity: O(1). When iterating over the resulting collection,
   ///   accessing each successive chunk has a complexity of O(*m*), where *m*
   ///   is the length of the chunk.
+  @inlinable
   public func chunked<Subject: Equatable>(
     on projection: @escaping (Element) -> Subject
   ) -> LazyChunked<Elements> {
@@ -149,6 +175,7 @@ extension Collection {
   /// the given predicate.
   ///
   /// - Complexity: O(*n*), where *n* is the length of this collection.
+  @inlinable
   public func chunked(
     by belongInSameGroup: (Element, Element) -> Bool
   ) -> [SubSequence] {
@@ -179,6 +206,7 @@ extension Collection {
   /// grouping elements that project to the same value.
   ///
   /// - Complexity: O(*n*), where *n* is the length of this collection.
+  @inlinable
   public func chunked<Subject: Equatable>(
     on projection: (Element) -> Subject
   ) -> [SubSequence] {

Sources/Algorithms/Combinations.swift

@@ -12,13 +12,17 @@
 public struct Combinations<Base: Collection> {
   /// The collection to iterate over for combinations.
   public let base: Base
+  
+  @usableFromInline
   internal var k: Int
 
+  @usableFromInline
   internal init(_ base: Base, k: Int) {
     self.base = base
     self.k = base.count < k ? -1 : k
   }
 
+  @inlinable
   public var count: Int {
     func binomial(n: Int, k: Int) -> Int {
       switch k {
@@ -37,8 +41,13 @@ public struct Combinations<Base: Collection> {
 
 extension Combinations: Sequence {
   public struct Iterator: IteratorProtocol {
+    @usableFromInline
     internal let base: Base
+    
+    @usableFromInline
     internal var indexes: [Base.Index]
+    
+    @usableFromInline
     internal var finished: Bool
 
     internal init(_ combinations: Combinations) {
@@ -67,6 +76,7 @@ extension Combinations: Sequence {
     ///     [2, 3, 4] *
     ///     // Can't advance without needing to go past `base.endIndex`,
     ///     // so the iteration is finished.
+    @usableFromInline
     internal mutating func advance() {
       guard !indexes.isEmpty else {
         // Initial state for combinations of 0 elements is an empty array with
@@ -99,6 +109,7 @@ extension Combinations: Sequence {
       }
     }
 
+    @inlinable
     public mutating func next() -> [Base.Element]? {
       if finished { return nil }
       defer { advance() }
@@ -146,6 +157,7 @@ extension Collection {
   /// - Parameter k: The number of elements to include in each combination.
   ///
   /// - Complexity: O(1)
+  @inlinable
   public func combinations(ofCount k: Int) -> Combinations<Self> {
     assert(k >= 0, "Can't have combinations with a negative number of elements.")
     return Combinations(self, k: k)

Sources/Algorithms/Cycle.swift

@@ -18,9 +18,19 @@ public struct Cycle<Base: Collection> {
 extension Cycle: Sequence {
   /// The iterator for a `Cycle` sequence.
   public struct Iterator: IteratorProtocol {
+    @usableFromInline
     let base: Base
+    
+    @usableFromInline
     var current: Base.Index
 
+    @usableFromInline
+    internal init(base: Base) {
+      self.base = base
+      self.current = base.startIndex
+    }
+    
+    @inlinable
     public mutating func next() -> Base.Element? {
       guard !base.isEmpty else { return nil }
 
@@ -34,7 +44,7 @@ extension Cycle: Sequence {
   }
 
   public func makeIterator() -> Iterator {
-    Iterator(base: base, current: base.startIndex)
+    Iterator(base: base)
   }
 }