4_map_example_test.go

package mu_test

import (
	"errors"
	"fmt"
	"strings"

	"github.com/appthrust/mu"
)

func ExampleOption_Map() {
	// Map with Some value
	some42 := mu.Some(42)
	mapped := some42.Map(func(x int) int { return x * 2 })
	fmt.Println("Some(42).Map(x*2):", mapped.OrZero())

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

	// Output:
	// Some(42).Map(x*2): 84
	// None.Map(x*2): true
}

func ExampleEither_MapLeft() {
	// MapLeft with Left value
	left := mu.Left[string, int]("error")
	mapped := left.MapLeft(func(s string) string { return strings.ToUpper(s) })
	fmt.Println("Left(\"error\").MapLeft(upper):", mapped.LeftOrZero())

	// MapLeft with Right value
	right := mu.Right[string, int](42)
	mapped2 := right.MapLeft(func(s string) string { return strings.ToUpper(s) })
	fmt.Println("Right(42).MapLeft(upper):", mapped2.OrZero())

	// Output:
	// Left("error").MapLeft(upper): ERROR
	// Right(42).MapLeft(upper): 42
}

func ExampleEither_Map() {
	// Map with Right value
	right := mu.Right[string, int](42)
	mapped := right.Map(func(x int) int { return x * 2 })
	fmt.Println("Right(42).Map(x*2):", mapped.OrZero())

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

	// Output:
	// Right(42).Map(x*2): 84
	// Left("error").Map(x*2): error
}

func ExampleResult_Map() {
	// Map with Ok value
	ok := mu.Ok(42)
	mapped := ok.Map(func(x int) int { return x * 2 })
	fmt.Println("Ok(42).Map(x*2):", mapped.OrZero())

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

	// Output:
	// Ok(42).Map(x*2): 84
	// Err.Map(x*2): error
}

func ExampleResult_MapErr() {
	// MapErr with Err value
	err := mu.Err[int](errors.New("connection failed"))
	mapped := err.MapErr(func(e error) error {
		return errors.New("wrapped: " + e.Error())
	})
	fmt.Println("Err.MapErr(wrap):", mapped.ErrOrZero().Error())

	// MapErr with Ok value
	ok := mu.Ok(42)
	mapped2 := ok.MapErr(func(e error) error {
		return errors.New("wrapped: " + e.Error())
	})
	fmt.Println("Ok(42).MapErr(wrap):", mapped2.OrZero())

	// Output:
	// Err.MapErr(wrap): wrapped: connection failed
	// Ok(42).MapErr(wrap): 42
}