[Compacted] Implementation of CompactedCollection and CompactedSequence as convenience for .compactMap { $0 }

Author: LucianoPAlmeida

Sources/Algorithms/Compacted.swift

@@ -0,0 +1,170 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+public struct CompactedSequence<Base: Sequence, Element>: Sequence
+  where Base.Element == Element? {
+
+  @usableFromInline
+  let base: Base
+  
+  @inlinable
+  init(base: Base) {
+    self.base = base
+  }
+
+  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() {
+        guard let some = wrapped else { continue }
+        return some
+      }
+      return nil
+    }
+  }
+
+  @inlinable
+  public func makeIterator() -> Iterator {
+    return Iterator(base: base.makeIterator())
+  }
+}
+
+extension Sequence {
+  /// Complexity: O(1)
+  @inlinable
+  public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
+    where Element == Unwrapped? {
+    CompactedSequence(base: self)
+  }
+}
+
+public struct CompactedCollection<Base: Collection, Element>: Collection
+  where Base.Element == Element? {
+
+  @usableFromInline
+  let base: Base
+  
+  @usableFromInline
+  let _startIdx: Base.Index
+  
+  @inlinable
+  init(base: Base) {
+    self.base = base
+    self._startIdx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
+  }
+  
+  public struct Index {
+    @usableFromInline
+    let base: Base.Index
+    
+    @inlinable
+    init(base: Base.Index) {
+      self.base = base
+    }
+  }
+  
+  /// Complexity: O(1)
+  @inlinable
+  public var startIndex: Index { Index(base: _startIdx) }
+  
+  @inlinable
+  public var endIndex: Index { Index(base: base.endIndex) }
+  
+  @inlinable
+  public subscript(position: Index) -> Element {
+    base[position.base]!
+  }
+  
+  @inlinable
+  public func index(after i: Index) -> Index {
+    guard i.base != base.endIndex else {
+      return Index(base: base.endIndex)
+    }
+    
+    var idx = base.index(after: i.base)
+    while idx != base.endIndex {
+      guard base[idx] != nil else {
+        base.formIndex(after: &idx)
+        continue
+      }
+      return Index(base: idx)
+    }
+    return Index(base: base.endIndex)
+  }
+}
+
+extension CompactedCollection: BidirectionalCollection
+  where Base: BidirectionalCollection {
+
+  @inlinable
+  public func index(before i: Index) -> Index {
+    guard i.base != base.startIndex else {
+      return Index(base: base.startIndex)
+    }
+
+    var idx = base.index(before: i.base)
+    while idx > base.startIndex {
+      guard base[idx] != nil else {
+        base.formIndex(before: &idx)
+        continue
+      }
+      return Index(base: idx)
+    }
+    return Index(base: base.startIndex)
+  }
+}
+
+extension CompactedCollection.Index: Comparable {  
+  @inlinable
+  public static func < (lhs: CompactedCollection.Index,
+                        rhs: CompactedCollection.Index) -> Bool {
+    lhs.base < rhs.base
+  }
+}
+
+extension Collection {
+  /// Complexity: O(*n*) where *n*  is the number of elements in the
+  /// base collection.
+  @inlinable
+  public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
+    where Element == Unwrapped? {
+    CompactedCollection(base: self)
+  }
+}
+
+extension CompactedSequence: LazySequenceProtocol where Base: LazySequenceProtocol {}
+extension CompactedSequence: Equatable where Base: Equatable {}
+extension CompactedSequence: Hashable where Base: Hashable {}
+
+extension CompactedCollection: RandomAccessCollection where Base: RandomAccessCollection {}
+extension CompactedCollection: LazySequenceProtocol where Base: LazySequenceProtocol {}
+extension CompactedCollection: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
+extension CompactedCollection: Equatable where Base: Equatable {}
+
+// Since we have another stored property of type `Base.Index` on the
+// collection, synthesis of `Hashble` conformace would require
+// a `Base.Index: Hashable` constraint, so we implement the hasher
+// only in terms of `base`. Since the computed index is based on it,
+// it should not make a difference here.
+extension CompactedCollection: Hashable where Base: Hashable {
+  @inlinable
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(base)
+  }
+}