4_map.go

package mu

// Map applies a function to the contained value, transforming T to T.
// If the option is [None], it returns `None[T]`.
// For type-changing transformations (T→U), use [pkg/github.com/appthrust/mu/muo.MapTo] instead. See package docs for details.
func (o Option[T]) Map(f func(T) T) Option[T] {
	if val, ok := o.Unwrap(); ok {
		return Some(f(val))
	}
	return None[T]()
}

// MapLeft applies a function to a [Left] value, leaving a [Right] value untouched.
// For type-changing transformations (L→L2), use [pkg/github.com/appthrust/mu/mue.MapLeftTo] instead. See package docs for details.
func (e Either[L, R]) MapLeft(f func(L) L) Either[L, R] {
	if val, ok := e.UnwrapLeft(); ok {
		return Left[L, R](f(val))
	}
	return e
}

// Map applies a function to a [Right] value, leaving a [Left] value untouched.
// For type-changing transformations (R→R2), use [pkg/github.com/appthrust/mu/mue.MapTo] instead. See package docs for details.
func (e Either[L, R]) Map(f func(R) R) Either[L, R] {
	if val, ok := e.Unwrap(); ok {
		return Right[L, R](f(val))
	}
	return e
}

// Map applies a function to a contained [Ok] value, leaving an [Err] value untouched.
// For type-changing transformations (T→U), use [pkg/github.com/appthrust/mu/mur.MapTo] instead. See package docs for details.
func (r Result[T]) Map(f func(T) T) Result[T] {
	if val, ok := r.Unwrap(); ok {
		return Ok(f(val))
	}
	return r
}

// MapErr applies a function to a contained [Err] value, leaving an [Ok] value untouched.
func (r Result[T]) MapErr(f func(error) error) Result[T] {
	if err, ok := r.UnwrapErr(); ok {
		return Err[T](f(err))
	}
	return r
}