 	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
+		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,

	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.

}


/// A sequence from splitting a Collection lazily.
public struct LazySplitSequence <Base: Collection>: IteratorProtocol, LazySequenceProtocol where
	Base.Iterator.Element: Equatable,
	Base.SubSequence: Collection,
	Base.SubSequence.Iterator.Element==Base.Iterator.Element,
	Base.SubSequence==Base.SubSequence.SubSequence {

	public fileprivate(set) var remaining: Base.SubSequence?
	public let separator: Base.Generator.Element
	public let allowEmptySlices: Bool

	/// Creates a lazy sequence by splitting a Collection repeatedly.
	///
	/// - Parameters:
	///   - base: The Collection to split.
	///   - separator: The element of `base` to split over.
	///   - allowEmptySlices: If there are two or more separators in a row, or `base` begins or ends with 
	///     a separator, should empty slices be emitted? Defaults to false.
	public init (_ base: Base, separator: Base.Iterator.Element, allowEmptySlices: Bool = false) {
		self.separator = separator
		self.remaining = base[base.startIndex..<base.endIndex]
		self.allowEmptySlices = allowEmptySlices
	}

	/// The contents of ‘base’ up to the next occurrence of ‘separator’.
	public mutating func next () -> Base.SubSequence? {
		guard let remaining = self.remaining else { return nil }
		let (head, tail) = remaining.splitOnce(separator: separator)
