 }
 
 
+/// 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 {
 
-	fileprivate var remaining: Base.SubSequence?
-	private let separator: Base.Generator.Element
-	private let allowEmptySlices: Bool
+	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)

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

	public func split (
		separator: Elements.Iterator.Element,	allowEmptySlices: Bool = false
		) -> LazySplitSequence<Elements> {

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


public struct PartialSourceLazySplitSequence <Base: Collection>: IteratorProtocol, LazySequenceProtocol where
	Base.Iterator.Element: Equatable,
	Base.SubSequence: RangeReplaceableCollection,


extension Collection where Iterator.Element: Equatable {


	/// 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])
