fn: update helper funcs for option and either

Author: jharveyb

fn/either.go

@@ -35,3 +35,25 @@ func (e Either[L, R]) IsLeft() bool {
 func (e Either[L, R]) IsRight() bool {
 	return e.right.IsSome()
 }
+
+// MapLeft maps the left value of the Either to a new value.
+func MapLeft[L any, R any, O any](f func(L) O) func(Either[L, R]) Option[O] {
+	return func(e Either[L, R]) Option[O] {
+		if e.IsLeft() {
+			return MapOption(f)(e.left)
+		}
+
+		return None[O]()
+	}
+}
+
+// MapRight maps the right value of the Either to a new value.
+func MapRight[L any, R any, O any](f func(R) O) func(Either[L, R]) Option[O] {
+	return func(e Either[L, R]) Option[O] {
+		if e.IsRight() {
+			return MapOption(f)(e.right)
+		}
+
+		return None[O]()
+	}
+}

fn/option.go

@@ -17,13 +17,24 @@ func Some[A any](a A) Option[A] {
 	}
 }
 
-// None trivially constructs an empty option
+// None trivially constructs an empty option.
 //
 // None : Option[A].
 func None[A any]() Option[A] {
 	return Option[A]{}
 }
 
+// MaybeSome constructs an option from a pointer.
+//
+// MaybeSome : *A -> Option[A].
+func MaybeSome[A any](a *A) Option[A] {
+	if a == nil {
+		return None[A]()
+	}
+
+	return Some[A](*a)
+}
+
 // ElimOption is the universal Option eliminator. It can be used to safely
 // handle all possible values inside the Option by supplying two continuations.
 //
@@ -48,6 +59,33 @@ func (o Option[A]) UnwrapOr(a A) A {
 	return a
 }
 
+// UnwrapPtr is used to extract a reference to a value from an option, and we
+// supply an empty pointer in the case when the Option is empty.
+func (o Option[A]) UnwrapToPtr() *A {
+	var v *A
+	o.WhenSome(func(a A) {
+		v = &a
+	})
+
+	return v
+}
+
+// UnwrapOrFunc is used to extract a value from an option, and we supply a
+// thunk to be evaluated in the case when the Option is empty.
+func (o Option[A]) UnwrapOrFunc(f func() A) A {
+	return ElimOption(o, f, func(a A) A { return a })
+}
+
+// UnwrapOrFuncErr is used to extract a value from an option, and we supply a
+// thunk to be evaluated in the case when the Option is empty.
+func (o Option[A]) UnwrapOrFuncErr(f func() (A, error)) (A, error) {
+	if o.isSome {
+		return o.some, nil
+	}
+
+	return f()
+}
+
 // WhenSome is used to conditionally perform a side-effecting function that
 // accepts a value of the type that parameterizes the option. If this function
 // performs no side effects, WhenSome is useless.
@@ -117,6 +155,19 @@ func MapOption[A, B any](f func(A) B) func(Option[A]) Option[B] {
 	}
 }
 
+// MapOptionZ transforms a pure function A -> B into one that will operate
+// inside the Option context. Unlike MapOption, this function will return the
+// default/zero argument of the return type if the Option is empty.
+func MapOptionZ[A, B any](o Option[A], f func(A) B) B {
+	var zero B
+
+	if o.IsNone() {
+		return zero
+	}
+
+	return f(o.some)
+}
+
 // LiftA2Option transforms a pure function (A, B) -> C into one that will
 // operate in an Option context. For the returned function, if either of its
 // arguments are None, then the result will be None.