4_flat_map_example_test.go

package mu_test

import (
	"errors"
	"fmt"

	"github.com/appthrust/mu"
)

func ExampleOption_FlatMap() {
	// FlatMap with Some value
	some42 := mu.Some(42)
	result := some42.FlatMap(func(x int) mu.Option[int] {
		if x > 40 {
			return mu.Some(x * 2)
		}
		return mu.None[int]()
	})
	fmt.Println("Some(42).FlatMap(x*2 if >40):", result.OrZero())

	// FlatMap with None value
	none := mu.None[int]()
	result2 := none.FlatMap(func(x int) mu.Option[int] {
		return mu.Some(x * 2)
	})
	fmt.Println("None.FlatMap(x*2):", result2.IsNone())

	// Output:
	// Some(42).FlatMap(x*2 if >40): 84
	// None.FlatMap(x*2): true
}

func ExampleEither_FlatMapLeft() {
	// FlatMapLeft with Left value
	left := mu.Left[string, int]("error")
	result := left.FlatMapLeft(func(s string) mu.Either[string, int] {
		return mu.Left[string, int]("processed: " + s)
	})
	fmt.Println("Left(\"error\").FlatMapLeft():", result.LeftOrZero())

	// FlatMapLeft with Right value
	right := mu.Right[string, int](42)
	result2 := right.FlatMapLeft(func(s string) mu.Either[string, int] {
		return mu.Left[string, int]("processed: " + s)
	})
	fmt.Println("Right(42).FlatMapLeft():", result2.OrZero())

	// Output:
	// Left("error").FlatMapLeft(): processed: error
	// Right(42).FlatMapLeft(): 42
}

func ExampleEither_FlatMap() {
	// FlatMap with Right value
	right := mu.Right[string, int](42)
	result := right.FlatMap(func(x int) mu.Either[string, int] {
		if x > 40 {
			return mu.Right[string, int](x * 2)
		}
		return mu.Left[string, int]("too small")
	})
	fmt.Println("Right(42).FlatMap(x*2 if >40):", result.OrZero())

	// FlatMap with Left value
	left := mu.Left[string, int]("error")
	result2 := left.FlatMap(func(x int) mu.Either[string, int] {
		return mu.Right[string, int](x * 2)
	})
	fmt.Println("Left(\"error\").FlatMap():", result2.LeftOrZero())

	// Output:
	// Right(42).FlatMap(x*2 if >40): 84
	// Left("error").FlatMap(): error
}

func ExampleResult_FlatMap() {
	// FlatMap with Ok value
	ok := mu.Ok(42)
	result := ok.FlatMap(func(x int) mu.Result[int] {
		if x > 40 {
			return mu.Ok(x * 2)
		}
		return mu.Err[int](errors.New("too small"))
	})
	fmt.Println("Ok(42).FlatMap(x*2 if >40):", result.OrZero())

	// FlatMap with Err value
	err := mu.Err[int](errors.New("initial error"))
	result2 := err.FlatMap(func(x int) mu.Result[int] {
		return mu.Ok(x * 2)
	})
	fmt.Println("Err.FlatMap():", result2.ErrOrZero().Error())

	// Output:
	// Ok(42).FlatMap(x*2 if >40): 84
	// Err.FlatMap(): initial error
}

func ExampleResult_FlatMapErr() {
	// FlatMapErr with Err value
	err := mu.Err[int](errors.New("connection failed"))
	result := err.FlatMapErr(func(e error) mu.Result[int] {
		if e.Error() == "connection failed" {
			return mu.Ok(42) // Recover from specific error
		}
		return mu.Err[int](e)
	})
	fmt.Println("Err(\"connection failed\").FlatMapErr():", result.OrZero())

	// FlatMapErr with Ok value
	ok := mu.Ok(42)
	result2 := ok.FlatMapErr(func(_ error) mu.Result[int] {
		return mu.Ok(0)
	})
	fmt.Println("Ok(42).FlatMapErr():", result2.OrZero())

	// Output:
	// Err("connection failed").FlatMapErr(): 42
	// Ok(42).FlatMapErr(): 42
}