 }
 
 @_fixed_layout
-public struct LazyGatherSequence<C : Collection, I : Sequence> : LazySequenceProtocol where C.Index == I.Element {
-    
-    public typealias Iterator = LazyGatherIterator<C, I.Iterator>
+public struct GatheringSequence<C : Collection, I : Sequence> : Sequence where C.Index == I.Element {
+    
+    public typealias Iterator = GatheringIterator<C, I.Iterator>
     
     public let base: C
     

    }
}

extension LazyCollectionProtocol {
    
    @_inlineable
    public func collect<I>(_ indices: I) -> LazyGatherSequence<Elements, I> {
        return LazyGatherSequence(base: self.elements, indices: indices)
    }
    
    @_inlineable
    public func collect<I>(_ indices: I) -> LazyGatherCollection<Elements, I> {
        return LazyGatherCollection(base: self.elements, indices: indices)
    }
    
    @_inlineable
    public func collect<I>(_ indices: I) -> LazyGatherBidirectionalCollection<Elements, I> {
        return LazyGatherBidirectionalCollection(base: self.elements, indices: indices)
    }
    
    @_inlineable
    public func collect<I>(_ indices: I) -> LazyGatherRandomAccessCollection<Elements, I> {
        return LazyGatherRandomAccessCollection(base: self.elements, indices: indices)
    }
}


    
    @_inlineable
    public func makeIterator() -> Iterator {
        return GatheringIterator(base: base, indices: _indices.makeIterator())
    }
    
    @_inlineable
