 	/// Much like the ?? operator for Optional types, takes a value and a function,
 	/// and if the Either 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 {
+	public func fold<B>(value : B, f : R -> B) -> B {
 		return either({ _ in value }, { r in f(r) });
 	}
 
 	/// 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> {
+	public func flatMap<S>(f : R -> Either<L, S>) -> Either<L, S> {
 		return self >>- f
 	}
 
 	/// Creates a Left with the given value.
-	public static func left(l: L) -> Either<L, R> {
+	public static func left(l : L) -> Either<L, R> {
 		return .Left(Box(l))
 	}
 
 	/// Creates a Right with the given value.
-	public static func right(r: R) -> Either<L, R> {
+	public static func right(r : R) -> Either<L, R> {
 		return .Right(Box(r))
 	}
 
 	/// Case analysis for the Either type. If the value is Left(a), apply the first function to a;
 	/// if it is Right(b), apply the second function to b.
-	public func either<A>(#onL: L -> A, onR: R -> A) -> A {
+	public func either<A>(#onLeft : L -> A, onRight : R -> A) -> A {
 		switch self {
 		case let Left(e):
-			return onL(e.value)
+			return onLeft(e.value)
 		case let Right(e):
-			return onR(e.value)
+			return onRight(e.value)
 		}
 	}
 


	/// Converts a Either to a Result, which is a more specialized type that
	/// contains an NSError or a value.
	public func toResult(ev: L -> NSError) -> Result<R> {
		return either({ e in Result.Error(ev(e)) }, { v in .Value(Box(v)) });
	}


	}
}

/// MARK : Equatable
public func == <L : Equatable, R : Equatable>(lhs : Either<L, R>, rhs : Either<L, R>) -> Bool {
	switch (lhs, rhs) {
	case let (.Left(l), .Left(r)) where l.value == r.value:
		return true
