 	}
 }
 
-/// Monadic `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.
+/// 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): 

	}
}

// 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 `pure` function, lifts a value into an Right.
public func pure<L, R>(a: R) -> Either<L, R> {
	return .Right(Box(a))
}

/// Functor `fmap`. If the Either is Left, ignores the function and returns the Left.
/// If the Either is Right, applies the function to the Right value and returns the result
/// in a new Right.
public func <^><L, RA, RB>(f: RA -> RB, a: Either<L, RA>) -> Either<L, RB> {
	switch a {
	case let .Left(l): 

	}
}

/// Ap | 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), _): 
