Audit public functions and properties that could be inlinable and base properties on lazy collection that could be internal

Author: LucianoPAlmeida

Sources/Algorithms/Chain.swift

@@ -14,11 +14,14 @@ public struct Chain2<Base1: Sequence, Base2: Sequence>
   where Base1.Element == Base2.Element
 {
   /// The first sequence in this chain.
-  public let base1: Base1
+  @usableFromInline
+  internal let base1: Base1
 
   /// The second sequence in this chain.
-  public let base2: Base2
+  @usableFromInline
+  internal let base2: Base2
 
+  @usableFromInline
   internal init(base1: Base1, base2: Base2) {
     self.base1 = base1
     self.base2 = base2

Sources/Algorithms/Combinations.swift

@@ -12,7 +12,8 @@
 /// A collection wrapper that generates combinations of a base collection.
 public struct Combinations<Base: Collection> {
   /// The collection to iterate over for combinations.
-  public let base: Base
+  @usableFromInline
+  internal let base: Base
 
   @usableFromInline
   internal let baseCount: Int

Sources/Algorithms/Cycle.swift

@@ -12,7 +12,13 @@
 /// A collection wrapper that repeats the elements of a base collection.
 public struct Cycle<Base: Collection> {
   /// The collection to repeat.
-  public let base: Base
+  @usableFromInline
+  internal let base: Base
+  
+  @usableFromInline
+  internal init(base: Base) {
+    self.base = base
+  }
 }
 
 extension Cycle: Sequence {
@@ -43,6 +49,7 @@ extension Cycle: Sequence {
     }
   }
 
+  @inlinable
   public func makeIterator() -> Iterator {
     Iterator(base: base)
   }
@@ -80,6 +87,7 @@ extension Collection {
   ///   forever.
   ///
   /// - Complexity: O(1)
+  @inlinable
   public func cycled() -> Cycle<Self> {
     Cycle(base: self)
   }
@@ -101,6 +109,7 @@ extension Collection {
   ///   times.
   ///
   /// - Complexity: O(1)
+  @inlinable
   public func cycled(times: Int) -> FlattenSequence<Repeated<Self>> {
     repeatElement(self, count: times).joined()
   }

Sources/Algorithms/Indexed.swift

@@ -16,7 +16,8 @@ public struct Indexed<Base: Collection> {
   public typealias Element = (index: Base.Index, element: Base.Element)
 
   /// The base collection.
-  public let base: Base
+  @usableFromInline
+  internal let base: Base
 
   @usableFromInline
   internal init(base: Base) {

Sources/Algorithms/Intersperse.swift

@@ -12,23 +12,45 @@
 /// A sequence that presents the elements of a base sequence of elements
 /// with a separator between each of those elements.
 public struct Intersperse<Base: Sequence> {
-  let base: Base
-  let separator: Base.Element
+  @usableFromInline
+  internal let base: Base
+  
+  @usableFromInline
+  internal let separator: Base.Element
+  
+  @usableFromInline
+  internal init(base: Base, separator: Base.Element) {
+    self.base = base
+    self.separator = separator
+  }
 }
 
 extension Intersperse: Sequence {
   /// The iterator for an `Intersperse` sequence.
   public struct Iterator: IteratorProtocol {
-    var iterator: Base.Iterator
-    let separator: Base.Element
-    var state = State.start
-
+    @usableFromInline
+    internal var iterator: Base.Iterator
+    
+    @usableFromInline
+    internal let separator: Base.Element
+    
+    @usableFromInline
+    internal var state = State.start
+    
+    @usableFromInline
+    internal init(iterator: Base.Iterator, separator: Base.Element) {
+      self.iterator = iterator
+      self.separator = separator
+    }
+    
+    @usableFromInline
     enum State {
       case start
       case element(Base.Element)
       case separator
     }
 
+    @inlinable
     public mutating func next() -> Base.Element? {
       // After the start, the state flips between element and separator. Before
       // returning a separator, a check is made for the next element as a
@@ -49,6 +71,7 @@ extension Intersperse: Sequence {
     }
   }
 
+  @inlinable
   public func makeIterator() -> Intersperse<Base>.Iterator {
     Iterator(iterator: base.makeIterator(), separator: separator)
   }
@@ -57,12 +80,16 @@ extension Intersperse: Sequence {
 extension Intersperse: Collection where Base: Collection {
   /// A position in an `Intersperse` collection.
   public struct Index: Comparable {
+    @usableFromInline
     enum Representation: Equatable {
       case element(Base.Index)
       case separator(next: Base.Index)
     }
-    let representation: Representation
+    
+    @usableFromInline
+    internal let representation: Representation
 
+    @inlinable
     public static func < (lhs: Index, rhs: Index) -> Bool {
       switch (lhs.representation, rhs.representation) {
       case let (.element(li), .element(ri)),
@@ -73,24 +100,29 @@ extension Intersperse: Collection where Base: Collection {
         return li <= ri
       }
     }
-
+    
+    @usableFromInline
     static func element(_ index: Base.Index) -> Self {
       Self(representation: .element(index))
     }
 
+    @usableFromInline
     static func separator(next: Base.Index) -> Self {
       Self(representation: .separator(next: next))
     }
   }
 
+  @inlinable
   public var startIndex: Index {
     base.startIndex == base.endIndex ? endIndex : .element(base.startIndex)
   }
 
+  @inlinable
   public var endIndex: Index {
     .separator(next: base.endIndex)
   }
 
+  @inlinable
   public func index(after i: Index) -> Index {
     precondition(i != endIndex, "Can't advance past endIndex")
     switch i.representation {
@@ -101,13 +133,15 @@ extension Intersperse: Collection where Base: Collection {
     }
   }
 
+  @inlinable
   public subscript(position: Index) -> Element {
     switch position.representation {
     case .element(let index): return base[index]
     case .separator: return separator
     }
   }
-
+  
+  @inlinable
   public func index(_ i: Index, offsetBy distance: Int) -> Index {
     switch (i.representation, distance.isMultiple(of: 2)) {
     case (let .element(index), true):
@@ -122,7 +156,7 @@ extension Intersperse: Collection where Base: Collection {
   }
 
   // TODO: Implement index(_:offsetBy:limitedBy:)
-
+  @inlinable
   public func distance(from start: Index, to end: Index) -> Int {
     switch (start.representation, end.representation) {
     case let (.element(element), .separator(next: separator)):
@@ -139,6 +173,7 @@ extension Intersperse: Collection where Base: Collection {
 extension Intersperse: BidirectionalCollection
   where Base: BidirectionalCollection
 {
+  @inlinable
   public func index(before i: Index) -> Index {
     precondition(i != startIndex, "Can't move before startIndex")
     switch i.representation {
@@ -189,6 +224,7 @@ extension Sequence {
   /// - Returns: The interspersed sequence of elements.
   ///
   /// - Complexity: O(1)
+  @inlinable
   public func interspersed(with separator: Element) -> Intersperse<Self> {
     Intersperse(base: self, separator: separator)
   }

Sources/Algorithms/Permutations.swift

@@ -12,7 +12,8 @@
 /// A sequence of all the permutations of a collection's elements.
 public struct Permutations<Base: Collection> {
   /// The base collection to iterate over for permutations.
-  public let base: Base
+  @usableFromInline
+  internal let base: Base
 
   @usableFromInline
   internal let baseCount: Int
@@ -186,6 +187,7 @@ extension Permutations: Sequence {
     }
   }
 
+  @inlinable
   public func makeIterator() -> Iterator {
     Iterator(self)
   }

Sources/Algorithms/Product.swift

@@ -12,10 +12,13 @@
 /// A sequence that represents the product of two sequences' elements.
 public struct Product2<Base1: Sequence, Base2: Collection> {
   /// The outer sequence in the product.
-  public let base1: Base1
+  @usableFromInline
+  internal let base1: Base1
   /// The inner sequence in the product.
-  public let base2: Base2
+  @usableFromInline
+  internal let base2: Base2
 
+  @usableFromInline
   internal init(_ base1: Base1, _ base2: Base2) {
     self.base1 = base1
     self.base2 = base2