fn: reimplement internals of either, add tests

fn/either.go

@@ -2,97 +2,119 @@ package fn
 
 // Either is a type that can be either left or right.
 type Either[L any, R any] struct {
-	left  Option[L]
-	right Option[R]
+	isRight bool
+	left    L
+	right   R
 }
 
 // NewLeft returns an Either with a left value.
 func NewLeft[L any, R any](l L) Either[L, R] {
-	return Either[L, R]{left: Some(l), right: None[R]()}
+	return Either[L, R]{left: l}
 }
 
 // NewRight returns an Either with a right value.
 func NewRight[L any, R any](r R) Either[L, R] {
-	return Either[L, R]{left: None[L](), right: Some(r)}
+	return Either[L, R]{isRight: true, right: r}
 }
 
 // ElimEither is the universal Either eliminator. It can be used to safely
 // handle all possible values inside the Either by supplying two continuations,
 // one for each side of the Either.
 func ElimEither[L, R, O any](f func(L) O, g func(R) O, e Either[L, R]) O {
-	if e.left.IsSome() {
-		return f(e.left.some)
+	if !e.isRight {
+		return f(e.left)
 	}
 
-	return g(e.right.some)
+	return g(e.right)
 }
 
 // WhenLeft executes the given function if the Either is left.
 func (e Either[L, R]) WhenLeft(f func(L)) {
-	e.left.WhenSome(f)
+	if !e.isRight {
+		f(e.left)
+	}
 }
 
 // WhenRight executes the given function if the Either is right.
 func (e Either[L, R]) WhenRight(f func(R)) {
-	e.right.WhenSome(f)
+	if e.isRight {
+		f(e.right)
+	}
 }
 
 // IsLeft returns true if the Either is left.
 func (e Either[L, R]) IsLeft() bool {
-	return e.left.IsSome()
+	return !e.isRight
 }
 
 // IsRight returns true if the Either is right.
 func (e Either[L, R]) IsRight() bool {
-	return e.right.IsSome()
+	return e.isRight
 }
 
 // LeftToOption converts a Left value to an Option, returning None if the inner
 // Either value is a Right value.
 func (e Either[L, R]) LeftToOption() Option[L] {
-	return e.left
+	if e.isRight {
+		return None[L]()
+	}
+
+	return Some(e.left)
 }
 
 // RightToOption converts a Right value to an Option, returning None if the
 // inner Either value is a Left value.
 func (e Either[L, R]) RightToOption() Option[R] {
-	return e.right
+	if !e.isRight {
+		return None[R]()
+	}
+
+	return Some(e.right)
 }
 
 // UnwrapLeftOr will extract the Left value from the Either if it is present
 // returning the supplied default if it is not.
 func (e Either[L, R]) UnwrapLeftOr(l L) L {
-	return e.left.UnwrapOr(l)
+	if e.isRight {
+		return l
+	}
+
+	return e.left
 }
 
 // UnwrapRightOr will extract the Right value from the Either if it is present
 // returning the supplied default if it is not.
 func (e Either[L, R]) UnwrapRightOr(r R) R {
-	return e.right.UnwrapOr(r)
+	if !e.isRight {
+		return r
+	}
+
+	return e.right
 }
 
 // Swap reverses the type argument order. This can be useful as an adapter
 // between APIs.
 func (e Either[L, R]) Swap() Either[R, L] {
 	return Either[R, L]{
-		left:  e.right,
-		right: e.left,
+		isRight: !e.isRight,
+		left:    e.right,
+		right:   e.left,
 	}
 }
 
 // MapLeft maps the left value of the Either to a new value.
 func MapLeft[L, R, O any](f func(L) O) func(Either[L, R]) Either[O, R] {
 	return func(e Either[L, R]) Either[O, R] {
-		if e.IsLeft() {
+		if !e.isRight {
 			return Either[O, R]{
-				left:  MapOption(f)(e.left),
-				right: None[R](),
+				isRight: false,
+				left:    f(e.left),
 			}
 		}
 
 		return Either[O, R]{
-			left:  None[O](),
-			right: e.right,
+			isRight: true,
+			right:   e.right,
 		}
 	}
 }
@@ -100,16 +122,16 @@ func MapLeft[L, R, O any](f func(L) O) func(Either[L, R]) Either[O, R] {
 // MapRight maps the right value of the Either to a new value.
 func MapRight[L, R, O any](f func(R) O) func(Either[L, R]) Either[L, O] {
 	return func(e Either[L, R]) Either[L, O] {
-		if e.IsRight() {
+		if e.isRight {
 			return Either[L, O]{
-				left:  None[L](),
-				right: MapOption(f)(e.right),
+				isRight: true,
+				right:   f(e.right),
 			}
 		}
 
 		return Either[L, O]{
-			left:  e.left,
-			right: None[O](),
+			isRight: false,
+			left:    e.left,
 		}
 	}
 }