 		}
 	}
 
+	/// Begins enumerating the receiver on the given Scheduler.
+	///
+	/// This implies that any side effects embedded in the receiver will be
+	/// performed on the given Scheduler as well.
+	///
+	/// Values may still be sent upon other schedulers—this merely affects how
+	/// the `enumerate` method is invoked.
 	@final func enumerateOn(scheduler: Scheduler) -> Enumerable<T> {
 		return Enumerable { send in
 			return self.enumerate { event in

		}
	}

	@final func aggregate<U>(initialValue: U, _ f: (U, T) -> U) -> Enumerable<U> {
		let scanned = scan(initialValue, f)


		}
	}

	/// Creates an Enumerable that will never send any events.
	@final class func never() -> Enumerable<T> {
		return Enumerable { _ in nil }
	}

	/// Starts a new enumeration pass, performing any side effects embedded
	/// within the Enumerable.
	///
	/// Optionally returns a Disposable which will cancel the work associated
	/// with the enumeration, and prevent any further events from being sent.
	@final func enumerate(enumerator: Enumerator) -> Disposable? {
		return _enumerate(enumerator)
	}

	/// Maps over the elements of the Enumerable, accumulating a state along the
	/// way.
	///
	/// This is meant as a primitive operator from which more complex operators
	/// can be built.
	///
	/// Returns an Enumerable of the mapped values.
	@final func mapAccumulate<S, U>(initialState: S, _ f: (S, T) -> (S?, U)) -> Enumerable<U> {
		return Enumerable<U> { send in
			let state = Atomic(initialState)
