fn: fix Result[T].FlatMap and add OrElse

For a Result[T], FlatMap should apply f when the result is Ok, and
propagate the error unchanged when it’s Err. The original code returns r
on Ok and tries to use r.left when Err, which is wrong. This commit
fixes that. It also adds an OrElse func that complements the AndThen
func that was already present.

Secondly, the group of FlatMap/AndThen and OrElse functions are now
properly tested with new unit tests.

fixes #10401

Author: gijswijs

fn/result.go

@@ -149,10 +149,10 @@ func FlattenResult[A any](r Result[Result[A]]) Result[A] {
 // success value if it exists.
 func (r Result[T]) FlatMap(f func(T) Result[T]) Result[T] {
 	if r.IsOk() {
-		return r
+		return f(r.left)
 	}
 
-	return f(r.left)
+	return r
 }
 
 // AndThen is an alias for FlatMap. This along with OrElse can be used to
@@ -189,6 +189,17 @@ func AndThen[A, B any](r Result[A], f func(A) Result[B]) Result[B] {
 	return FlatMapResult(r, f)
 }
 
+// OrElse returns the original Result if it is a success, otherwise it returns
+// the provided alternative Result. This along with AndThen can be used to
+// Railway Oriented Programming (ROP).
+func OrElse[A any](r Result[A], f func(error) Result[A]) Result[A] {
+	if r.IsOk() {
+		return r
+	}
+
+	return f(r.right)
+}
+
 // LiftA2Result lifts a two-argument function to a function that can operate
 // over results of its arguments.
 func LiftA2Result[A, B, C any](f func(A, B) C,

fn/result_test.go

@@ -96,3 +96,114 @@ func TestSinkOnOkContinuationCall(t *testing.T) {
 	require.True(t, called)
 	require.Nil(t, res)
 }
+
+func TestFlatMap(t *testing.T) {
+	// Case 1: Ok -> Ok
+	r1 := Ok(1).FlatMap(func(i int) Result[int] {
+		return Ok(i + 1)
+	})
+	require.Equal(t, Ok(2), r1)
+
+	// Case 2: Ok -> Err
+	err := errors.New("fail")
+	r2 := Ok(1).FlatMap(func(i int) Result[int] {
+		return Err[int](err)
+	})
+	require.Equal(t, Err[int](err), r2)
+
+	// Case 3: Err -> Err (function not called)
+	origErr := errors.New("original")
+	r3 := Err[int](origErr).FlatMap(func(i int) Result[int] {
+		return Ok(i + 1)
+	})
+	require.Equal(t, Err[int](origErr), r3)
+}
+
+func TestAndThenMethod(t *testing.T) {
+	// Case 1: Ok -> Ok
+	r1 := Ok(1).AndThen(func(i int) Result[int] {
+		return Ok(i + 1)
+	})
+	require.Equal(t, Ok(2), r1)
+
+	// Case 2: Err -> Err
+	origErr := errors.New("original")
+	r2 := Err[int](origErr).AndThen(func(i int) Result[int] {
+		return Ok(i + 1)
+	})
+	require.Equal(t, Err[int](origErr), r2)
+}
+
+func TestOrElseMethod(t *testing.T) {
+	// Case 1: Ok -> Ok (function not called)
+	r1 := Ok(1).OrElse(func(err error) Result[int] {
+		return Ok(2)
+	})
+	require.Equal(t, Ok(1), r1)
+
+	// Case 2: Err -> Ok
+	origErr := errors.New("original")
+	r2 := Err[int](origErr).OrElse(func(err error) Result[int] {
+		return Ok(2)
+	})
+	require.Equal(t, Ok(2), r2)
+
+	// Case 3: Err -> Err
+	newErr := errors.New("new")
+	r3 := Err[int](origErr).OrElse(func(err error) Result[int] {
+		return Err[int](newErr)
+	})
+	require.Equal(t, Err[int](newErr), r3)
+}
+
+func TestFlatMapResult(t *testing.T) {
+	// Case 1: Ok[int] -> Ok[string]
+	r1 := FlatMapResult(Ok(1), func(i int) Result[string] {
+		return Ok(fmt.Sprintf("%d", i))
+	})
+	require.Equal(t, Ok("1"), r1)
+
+	// Case 2: Ok[int] -> Err[string]
+	err := errors.New("fail")
+	r2 := FlatMapResult(Ok(1), func(i int) Result[string] {
+		return Err[string](err)
+	})
+	require.Equal(t, Err[string](err), r2)
+
+	// Case 3: Err[int] -> Err[string]
+	origErr := errors.New("original")
+	r3 := FlatMapResult(Err[int](origErr), func(i int) Result[string] {
+		return Ok("should not happen")
+	})
+	require.Equal(t, Err[string](origErr), r3)
+}
+
+func TestAndThenFunc(t *testing.T) {
+	// Case 1: Ok[int] -> Ok[string]
+	r1 := AndThen(Ok(1), func(i int) Result[string] {
+		return Ok(fmt.Sprintf("%d", i))
+	})
+	require.Equal(t, Ok("1"), r1)
+
+	// Case 2: Err[int] -> Err[string]
+	origErr := errors.New("original")
+	r2 := AndThen(Err[int](origErr), func(i int) Result[string] {
+		return Ok("should not happen")
+	})
+	require.Equal(t, Err[string](origErr), r2)
+}
+
+func TestOrElseFunc(t *testing.T) {
+	// Case 1: Ok -> Ok
+	r1 := OrElse(Ok(1), func(err error) Result[int] {
+		return Ok(2)
+	})
+	require.Equal(t, Ok(1), r1)
+
+	// Case 2: Err -> Ok
+	origErr := errors.New("original")
+	r2 := OrElse(Err[int](origErr), func(err error) Result[int] {
+		return Ok(2)
+	})
+	require.Equal(t, Ok(2), r2)
+}