 	case Left(L)
 	case Right(R)
 
-	/// Much like the ?? operator for Optional types, takes a value and a function, and if the
-	/// reciever is `.Left`, returns the value, otherwise maps the function over the value in
+	/// 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`
+	/// 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

	}
}

/// 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> {

		}
	}

	/// Determines if this `Either` value is a `Right`.
	public var isRight : Bool {
		switch self {
		case Right(_):
