 
 extension Collection where Iterator.Element: Equatable {
 
-	/**
-	Return everything before the first occurrence of ‘separator’ as 'head', and everything after it as 'tail'.
-	Including empty sequences if ‘separator’ is first or last.
 
-	If ‘separator’ is not found then ‘head’ contains everything and 'tail' is nil.
-	*/
+	/// Returns everything before the first occurrence of ‘separator’ as 'head', and everything after it as 'tail'.
+	/// Including empty sequences if ‘separator’ is first or last.
+	///
+	/// If ‘separator’ is not found then ‘head’ contains everything and 'tail' is nil.
 	func splitOnce (separator: Iterator.Element) -> (head: SubSequence, tail: SubSequence?) {
 		guard let nextindex = index(of: separator) else { return (self[startIndex..<endIndex], nil) }
 		return (self[startIndex..<nextindex], self[index(after: nextindex)..<endIndex])

	private var gs: LazyMapIterator<AnyIterator<Base>, LazySplitSequence<Base>>
	private var g: LazySplitSequence<Base>?

	public init (_ bases: @escaping ()->Base?, separator: Base.Iterator.Element) {
		gs = AnyIterator(bases).lazy.map {
			LazySplitSequence($0, separator: separator, allowEmptySlices: true).makeIterator()
			}.makeIterator()
	}

	public mutating func next() -> Base.SubSequence? {
		// Requires g handling repeated calls to next() after it is empty.
		// When g.remaining becomes nil there is always one item left in g.

	Elements.SubSequence.Iterator.Element==Elements.Iterator.Element,
	Elements.SubSequence==Elements.SubSequence.SubSequence {


	/// Creates a lazy sequence by splitting this Collection repeatedly.
	///
	/// - Parameters:
	///   - separator: The element of this collection to split over.
	///   - allowEmptySlices: If there are two or more separators in a row, or this Collection begins or ends with
	///     a separator, should empty slices be emitted? Defaults to false.
	public func split (
		separator: Elements.Iterator.Element, allowEmptySlices: Bool = false
		) -> LazySplitSequence<Elements> {

		return LazySplitSequence(self.elements, separator: separator, allowEmptySlices: allowEmptySlices)
	}
}

/// A sequence from splitting a series of Collections lazily, as if they were one Collection.
public struct PartialSourceLazySplitSequence <Base: Collection>: IteratorProtocol, LazySequenceProtocol where
	Base.Iterator.Element: Equatable,
	Base.SubSequence: RangeReplaceableCollection,
