func (r Result[T]) Map(mapper func(value T) (T, error)) Result[T]

// Basic Mo function for single argument (it should be not needed if Map follow the same signature as the method)
func Mo[A any, B any](f func(A) (B, error)) func(mo.Result[A]) mo.Result[B] {
	return func(r mo.Result[A]) mo.Result[B] {
		if r.IsError() {
			return mo.Err[B](r.Error())
		}
		result, err := f(r.MustGet())
		if err != nil {
			return mo.Err[B](err)
		}
		return mo.Ok(result)
	}
}

// Mo function with context - context is passed through the pipeline
func MoCtx[A any, B any](ctx context.Context, f func(context.Context, A) (B, error)) func(mo.Result[A]) mo.Result[B] {
	return func(r mo.Result[A]) mo.Result[B] {
		if r.IsError() {
			return mo.Err[B](r.Error())
		}
		result, err := f(ctx, r.MustGet())
		if err != nil {
			return mo.Err[B](err)
		}
		return mo.Ok(result)
	}
}

result := sequence(
    parseInput(data),           // string → Either[Error, User]
    validateUser,               // User → Either[Error, User]  
    saveToDatabase,             // User → Either[Error, UserID]
)
// Stops at first error, propagates success through sequence

func sequence(source Either[L, A], operator1, operator2, operator3) Either[L, D] {
    if source.IsLeft() {
        return source // Short-circuit on error
    }
    
    result1 := operator1(source.MustRight())
    if result1.IsLeft() {
        return result1 // Short-circuit on error
    }
    
    result2 := operator2(result1.MustRight())
    if result2.IsLeft() {
        return result2 // Short-circuit on error
    }
    
    return operator3(result2.MustRight())
}

result := sequence(
    parseInput(data),           // string → Either[Error, User]
    FlatMap(validateUser),               // User → Either[Error, User]  
    FlatMap(saveToDatabase),             // User → Either[Error, UserID]
)

wrapperValid := gen.ParallelZip3(
		gen.AsFunc1(s.validateRankingModelRequestWrapper)(requestWrapper),
		gen.AsFunc3(s.logRequestParameters)(ctx, requestWrapper, logger),
		gen.AsFunc3(s.recordRequestMetrics)(ctx, requestWrapper, requestWrapper.ItemIDs.GetOrVal([]string{})),
	).AsNothing()

	response := gen.Pipe6(
		pipe.As(wrapperValid, pipe.AsFn(pipe.Ok(requestWrapper))),
		func(requestWrapper *RequestWrapper) pipe.Result[tuple.Tuple3[*cfg.ModelConfig, []string, *WithUserFeatures]] {
			return gen.ParallelZip3(
				gen.AsFunc1(s.findModelConfig)(requestWrapper),
				gen.AsFunc1(s.getItemIDs)(requestWrapper),
				measureServiceCall(s, ctx, requestWrapper, "requestLatency", gen.AsFunc3(s.requestUserFeatures)(ctx, logger, requestWrapper)),
			)
		},
		func(tuple tuple.Tuple3[*cfg.ModelConfig, []string, *WithUserFeatures]) pipe.Result[*WithRankingInputData] {
		.........

func Sequence3[A, B, C any](
  step1 mo.Result[A],
  step2 func(A) mo.Result[B],
  step3 func(B) mo.Result[C],
) mo.Result[C] {
  if step1.IsError() {
    return mo.ErrC
  }
    
  result2 := step2(step1.MustGet())
  if result2.IsError() {
    return mo.ErrC // short circuit
  }

  return step3(result2.MustGet())
}

result := Sequence3(
  parseInput(data),    // mo.Result[User] (from string)
  validateUser,        // User → mo.Result[User]
  saveToDatabase,      // User → mo.Result[int]
)

type UserContext struct {
	Config    Config
	Params    map[string]any
	Parsed    *User
	Validated *User
	SavedID   *int
}

initialContext := UserContext{
	Config: Config{DatabaseURL: "localhost"},
	Params: map[string]any{"name": "test"},
}

result := Sequence(
  initialContext,
  parseInput,
  validateUser,
  saveUser,
)

func validateUser(ctx UserContext) mo.Result[UserContext] {
	user := *ctx.Parsed        // From previous step
	config := ctx.Config       // From initial context
	// validation logic...
	validated := user

	return mo.Ok(UserContext{
		Validated: &validated,
	})
}

func saveToDatabase(ctx UserContext) mo.Result[UserContext] {
	originalUser := *ctx.Parsed      // From step1
	validatedUser := *ctx.Validated  // From step2
	config := ctx.Config             // From initial context

	savedID := 12345
	return mo.Ok(UserContext{
		SavedID: &savedID,
	})
}

func Do[T any](
	initialContext T,
	steps ...func(T) mo.Result[T],
) mo.Result[T] {
	context := initialContext
	for _, step := range steps {
		result := step(context)
		if result.IsError() {
  		return result // circut breaking
		}

		context = mergeContext(context, result.MustGet())
	}

	return mo.Ok(context)
}

obs := ro.Pipe4(
   ro.Of("hello world"),
   ro.Map(strings.ToUpper),
   ro.Filter(validate),
   ro.Map(saveToDatabase),
   ro.Retry(3),
)

obs.Subscribe(
    func(value T) {
        // on value
    },
    func(err error) {
        // on failure
    },
    func() {
        // on success
    },
)