 		return f(r.value)
 	}
 }
+
+/// 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
+	case let (.Right(l), .Right(r)) where l.value == r.value:
+		return true
+	default:
+		return false
+	}
+}
+
+public func !=<L: Equatable, R: Equatable>(lhs: Either<L, R>, rhs: Either<L, R>) -> Bool {
+	return !(lhs == rhs)
+}
	}
}

/// Applicative Functor `apply`. Given an Either<L, RA -> RB> and an Either<L,RA>,
/// returns an Either<L,RB>. If the `f` or `a' param is a Left, simply returns a Left with the
/// same value. Otherwise the function taken from Right(f) is applied to the value from Right(a)
/// And a Right is returned.
public func <*><L, RA, RB>(f: Either<L, RA -> RB>, a: Either<L, RA>) -> Either<L, RB> {
	switch (a, f) {
	case let (.Left(l), _): 

	}
}

/// Bind | Given an Either<L,RA>, and a function from RA -> Either<L,RB>, applies the function `f` 
/// if `a` is Right, otherwise the function is ignored and a Left with the Left value from `a` is 
/// returned.
public func >>-<L, RA, RB>(a: Either<L, RA>, f: RA -> Either<L, RB>) -> Either<L, RB> {
	switch a {
	case let .Left(l): 
