 	}
 }
 
-/// Fmap | Applies a function to any non-error value contained in the given Either.
+/// Fmap | Applies a function to any non-error value contained in the given `Either`.
 ///
 /// If the `Either` is `.Left`, the given function is ignored and result of this function is `.Left`.
 public func <^> <L, RA, RB>(f : RA -> RB, e : Either<L, RA>) -> Either<L, RB> {

	}
}

/// Bind | Applies a function to any non-error value contained in the given Either.
///
/// If the `Either` is `.Left`, the given function is ignored and the result of this function is
/// `.Left`.  Else the reuslt of this function is the application of the function to the value
/// contained in teh Either.
public func >>- <L, RA, RB>(a : Either<L, RA>, f : RA -> Either<L, RB>) -> Either<L, RB> {
	switch a {
	case let .Left(l):

	case Left(L)
	case Right(R)

	/// Much like the ?? operator for `Optional` types, takes a value and a function, and if the
	/// receiver is `.Left`, returns the value, otherwise maps the function over the value in
	/// `.Right` and returns that value.
	public func fold<B>(value : B, f : R -> B) -> B {
		return either(onLeft: const(value), onRight: f);
	}

	/// Named function for `>>-`. If the `Either` is `Left`, simply returns
	/// a new `Left` with the value of the receiver. If `Right`, applies the function `f`
	/// and returns the result.
	public func flatMap<S>(f : R -> Either<L, S>) -> Either<L, S> {
		return self >>- f
