feat: Add OrElse to ioeither for error recovery (#148)

* feat: add OrElse to ioeither for error recovery

Add OrElse function to both v1 and v2 ioeither packages for error recovery.
This allows recovering from a Left value by applying a function to the error
and returning a new IOEither, consistent with the Either package's API.

- Add OrElse to ioeither/generic/ioeither.go
- Add OrElse wrapper to ioeither/ioeither.go
- Add OrElse to v2/ioeither/generic/ioeither.go
- Add OrElse to v2/ioeither/ioeither.go
- Add comprehensive tests for both v1 and v2

Closes #146

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Signed-off-by: majiayu000 <1835304752@qq.com>

* chore(v2): drop ioeither OrElse addition

---------

Signed-off-by: majiayu000 <1835304752@qq.com>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

ioeither/generic/ioeither.go

@@ -369,6 +369,11 @@ func ToIOOption[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](i
 	)
 }
 
+// OrElse returns the original IOEither if it is a Right, otherwise it applies the given function to the error and returns the result.
+func OrElse[GA ~func() ET.Either[E, A], E, A any](onLeft func(E) GA) func(GA) GA {
+	return eithert.OrElse(IO.MonadChain[GA, GA, ET.Either[E, A], ET.Either[E, A]], IO.Of[GA, ET.Either[E, A]], onLeft)
+}
+
 func FromIOOption[GEA ~func() ET.Either[E, A], GA ~func() O.Option[A], E, A any](onNone func() E) func(ioo GA) GEA {
 	return IO.Map[GA, GEA](ET.FromOption[A](onNone))
 }

ioeither/ioeither.go

@@ -266,6 +266,11 @@ func Alt[E, A any](second L.Lazy[IOEither[E, A]]) func(IOEither[E, A]) IOEither[
 	return G.Alt(second)
 }
 
+// OrElse returns the original IOEither if it is a Right, otherwise it applies the given function to the error and returns the result.
+func OrElse[E, A any](onLeft func(E) IOEither[E, A]) func(IOEither[E, A]) IOEither[E, A] {
+	return G.OrElse[IOEither[E, A]](onLeft)
+}
+
 func MonadFlap[E, B, A any](fab IOEither[E, func(A) B], a A) IOEither[E, B] {
 	return G.MonadFlap[IOEither[E, func(A) B], IOEither[E, B]](fab, a)
 }

ioeither/ioeither_test.go

@@ -134,3 +134,44 @@ func TestApSecond(t *testing.T) {
 
 	assert.Equal(t, E.Of[error]("b"), x())
 }
+
+func TestOrElse(t *testing.T) {
+	// Test that OrElse recovers from a Left
+	recover := OrElse(func(err string) IOEither[string, int] {
+		return Right[string](42)
+	})
+
+	// When input is Left, should recover
+	leftResult := F.Pipe1(
+		Left[int]("error"),
+		recover,
+	)
+	assert.Equal(t, E.Right[string](42), leftResult())
+
+	// When input is Right, should pass through unchanged
+	rightResult := F.Pipe1(
+		Right[string](100),
+		recover,
+	)
+	assert.Equal(t, E.Right[string](100), rightResult())
+
+	// Test that OrElse can also return a Left (propagate different error)
+	recoverOrFail := OrElse(func(err string) IOEither[string, int] {
+		if err == "recoverable" {
+			return Right[string](0)
+		}
+		return Left[int]("unrecoverable: " + err)
+	})
+
+	recoverable := F.Pipe1(
+		Left[int]("recoverable"),
+		recoverOrFail,
+	)
+	assert.Equal(t, E.Right[string](0), recoverable())
+
+	unrecoverable := F.Pipe1(
+		Left[int]("fatal"),
+		recoverOrFail,
+	)
+	assert.Equal(t, E.Left[int]("unrecoverable: fatal"), unrecoverable())
+}

v2/DESIGN.md

@@ -55,7 +55,7 @@ import (
 
 // Create a pipeline of transformations
 pipeline := F.Flow3(
-    A.Filter(func(x int) bool { return x > 0 }),     // Keep positive numbers
+    A.Filter(N.MoreThan(0)),     // Keep positive numbers
     A.Map(N.Mul(2)),                                  // Double each number
     A.Reduce(func(acc, x int) int { return acc + x }, 0), // Sum them up
 )

v2/EXAMPLE_TESTS_PROGRESS.md

@@ -0,0 +1,212 @@
+# Example Tests Progress
+
+This document tracks the progress of converting documentation examples into executable example test files.
+
+## Overview
+
+The codebase has 300+ documentation examples across many packages. This document tracks which packages have been completed and which still need work.
+
+## Completed Packages
+
+### Core Packages
+- [x] **result** - Created `examples_bind_test.go`, `examples_curry_test.go`, `examples_apply_test.go`
+  - Files: `bind.go` (10 examples), `curry.go` (5 examples), `apply.go` (2 examples)
+  - Status: ✅ 17 tests passing
+
+### Utility Packages
+- [x] **pair** - Created `examples_test.go`
+  - Files: `pair.go` (14 examples)
+  - Status: ✅ 14 tests passing
+
+- [x] **tuple** - Created `examples_test.go`
+  - Files: `tuple.go` (6 examples)
+  - Status: ✅ 6 tests passing
+
+### Type Class Packages
+- [x] **semigroup** - Created `examples_test.go`
+  - Files: `semigroup.go` (7 examples)
+  - Status: ✅ 7 tests passing
+
+### Utility Packages (continued)
+- [x] **predicate** - Created `examples_test.go`
+  - Files: `bool.go` (3 examples), `contramap.go` (1 example)
+  - Status: ✅ 4 tests passing
+
+### Context Reader Packages
+- [x] **idiomatic/context/readerresult** - Created `examples_reader_test.go`, `examples_bind_test.go`
+  - Files: `reader.go` (8 examples), `bind.go` (14 examples)
+  - Status: ✅ 22 tests passing
+
+## Summary Statistics
+- **Total Example Tests Created**: 74
+- **Total Packages Completed**: 7 (result, pair, tuple, semigroup, predicate, idiomatic/context/readerresult)
+- **All Tests Status**: ✅ PASSING
+
+### Breakdown by Package
+- **result**: 21 tests (bind: 10, curry: 5, apply: 2, array: 4)
+- **pair**: 14 tests
+- **tuple**: 6 tests
+- **semigroup**: 7 tests
+- **predicate**: 4 tests
+- **idiomatic/context/readerresult**: 22 tests (reader: 8, bind: 14)
+
+## Packages with Existing Examples
+
+These packages already have some example test files:
+- result (has `examples_create_test.go`, `examples_extract_test.go`)
+- option (has `examples_create_test.go`, `examples_extract_test.go`)
+- either (has `examples_create_test.go`, `examples_extract_test.go`)
+- ioeither (has `examples_create_test.go`, `examples_do_test.go`, `examples_extract_test.go`)
+- ioresult (has `examples_create_test.go`, `examples_do_test.go`, `examples_extract_test.go`)
+- lazy (has `example_lazy_test.go`)
+- array (has `examples_basic_test.go`, `examples_sort_test.go`, `example_any_test.go`, `example_find_test.go`)
+- readerioeither (has `traverse_example_test.go`)
+- context/readerioresult (has `flip_example_test.go`)
+
+## Packages Needing Example Tests
+
+### Core Packages (High Priority)
+- [ ] **result** - Additional files need examples:
+  - `apply.go` (2 examples)
+  - `array.go` (7 examples)
+  - `core.go` (6 examples)
+  - `either.go` (26 examples)
+  - `eq.go` (2 examples)
+  - `functor.go` (1 example)
+  
+- [ ] **option** - Additional files need examples
+- [ ] **either** - Additional files need examples
+
+### Reader Packages (High Priority)
+- [ ] **reader** - Many examples in:
+  - `array.go` (12 examples)
+  - `bind.go` (10 examples)
+  - `curry.go` (8 examples)
+  - `flip.go` (2 examples)
+  - `reader.go` (21 examples)
+
+- [ ] **readeroption** - Examples in:
+  - `array.go` (3 examples)
+  - `bind.go` (7 examples)
+  - `curry.go` (5 examples)
+  - `flip.go` (2 examples)
+  - `from.go` (4 examples)
+  - `reader.go` (18 examples)
+  - `sequence.go` (4 examples)
+
+- [ ] **readerresult** - Examples in:
+  - `array.go` (3 examples)
+  - `bind.go` (24 examples)
+  - `curry.go` (7 examples)
+  - `flip.go` (2 examples)
+  - `from.go` (4 examples)
+  - `monoid.go` (3 examples)
+
+- [ ] **readereither** - Examples in:
+  - `array.go` (3 examples)
+  - `bind.go` (7 examples)
+  - `flip.go` (3 examples)
+
+- [ ] **readerio** - Examples in:
+  - `array.go` (3 examples)
+  - `bind.go` (7 examples)
+  - `flip.go` (2 examples)
+  - `logging.go` (4 examples)
+  - `reader.go` (30 examples)
+
+- [ ] **readerioeither** - Examples in:
+  - `bind.go` (7 examples)
+  - `flip.go` (1 example)
+
+- [ ] **readerioresult** - Examples in:
+  - `array.go` (8 examples)
+  - `bind.go` (24 examples)
+
+### State Packages
+- [ ] **statereaderioeither** - Examples in:
+  - `bind.go` (5 examples)
+  - `resource.go` (1 example)
+  - `state.go` (13 examples)
+
+### Utility Packages
+- [ ] **lazy** - Additional examples in:
+  - `apply.go` (2 examples)
+  - `bind.go` (7 examples)
+  - `lazy.go` (10 examples)
+  - `sequence.go` (4 examples)
+  - `traverse.go` (2 examples)
+
+- [ ] **pair** - Additional examples in:
+  - `monad.go` (12 examples)
+  - `pair.go` (remaining ~20 examples)
+
+- [ ] **tuple** - Examples in:
+  - `tuple.go` (6 examples)
+
+- [ ] **predicate** - Examples in:
+  - `bool.go` (3 examples)
+  - `contramap.go` (1 example)
+  - `monoid.go` (4 examples)
+
+- [ ] **retry** - Examples in:
+  - `retry.go` (7 examples)
+
+- [ ] **logging** - Examples in:
+  - `logger.go` (5 examples)
+
+### Collection Packages
+- [ ] **record** - Examples in:
+  - `bind.go` (3 examples)
+
+### Type Class Packages
+- [ ] **semigroup** - Examples in:
+  - `alt.go` (1 example)
+  - `apply.go` (1 example)
+  - `array.go` (4 examples)
+  - `semigroup.go` (7 examples)
+
+- [ ] **ord** - Examples in:
+  - `ord.go` (1 example)
+
+## Strategy for Completion
+
+1. **Prioritize by usage**: Focus on core packages (result, option, either) first
+2. **Group by package**: Complete all examples for one package before moving to next
+3. **Test incrementally**: Run tests after each file to catch errors early
+4. **Follow patterns**: Use existing example test files as templates
+5. **Document as you go**: Update this file with progress
+
+## Example Test File Template
+
+```go
+// Copyright header...
+
+package packagename_test
+
+import (
+	"fmt"
+	PKG "github.com/IBM/fp-go/v2/packagename"
+)
+
+func ExampleFunctionName() {
+	// Copy example from doc comment
+	// Ensure it compiles and produces correct output
+	fmt.Println(result)
+	// Output:
+	// expected output
+}
+```
+
+## Notes
+
+- Use `F.Constant1[error](defaultValue)` for GetOrElse in result package
+- Use `F.Pipe1` instead of `F.Pipe2` when only one transformation
+- Check function signatures carefully for type parameters
+- Some functions like `BiMap` are capitalized differently than in docs
+- **Prefer `R.Eitherize1(func)` over manual error handling** - converts `func(T) (R, error)` to `func(T) Result[R]`
+  - Example: Use `R.Eitherize1(strconv.Atoi)` instead of manual if/else error checking
+- **Add Go documentation comments to all example functions** - Each example should have a comment explaining what it demonstrates
+- **Idiomatic vs Non-Idiomatic packages**:
+  - Non-idiomatic (e.g., `result`): Uses `Result[A]` type (Either monad)
+  - Idiomatic (e.g., `idiomatic/result`): Uses `(A, error)` tuples (Go-style)
+  - Context readers use non-idiomatic `Result[A]` internally

v2/README.md

@@ -61,6 +61,7 @@ package main
 import (
     "fmt"
     "github.com/IBM/fp-go/v2/option"
+    N "github.com/IBM/fp-go/v2/number"
 )
 
 func main() {
@@ -145,6 +146,8 @@ func main() {
 }
 ```
 
+## ⚠️ Breaking Changes
+
 ### From V1 to V2
 
 #### 1. Generic Type Aliases
@@ -449,17 +452,27 @@ func process() IOResult[string] {
 
 ### Core Modules
 
+#### Standard Packages (Struct-based)
 - **Option** - Represent optional values without nil
 - **Either** - Type-safe error handling with left/right values
-- **Result** - Simplified Either with error as left type
+- **Result** - Simplified Either with error as left type (recommended for error handling)
 - **IO** - Lazy evaluation and side effect management
-- **IOEither** - Combine IO with error handling
+- **IOResult** - Combine IO with Result for error handling (recommended over IOEither)
 - **Reader** - Dependency injection pattern
-- **ReaderIOEither** - Combine Reader, IO, and Either for complex workflows
+- **ReaderIOResult** - Combine Reader, IO, and Result for complex workflows
 - **Array** - Functional array operations
 - **Record** - Functional record/map operations
 - **Optics** - Lens, Prism, Optional, and Traversal for immutable updates
 
+#### Idiomatic Packages (Tuple-based, High Performance)
+- **idiomatic/option** - Option monad using native Go `(value, bool)` tuples
+- **idiomatic/result** - Result monad using native Go `(value, error)` tuples
+- **idiomatic/ioresult** - IOResult monad using `func() (value, error)` for IO operations
+- **idiomatic/readerresult** - Reader monad combined with Result pattern
+- **idiomatic/readerioresult** - Reader monad combined with IOResult pattern
+
+The idiomatic packages offer 2-10x performance improvements and zero allocations by using Go's native tuple patterns instead of struct wrappers. Use them for performance-critical code or when you prefer Go's native error handling style.
+
 ## 🤔 Should I Migrate?
 
 **Migrate to V2 if:**

v2/array/array.go

@@ -536,3 +536,89 @@ func Flap[B, A any](a A) Operator[func(A) B, B] {
 func Prepend[A any](head A) Operator[A, A] {
 	return G.Prepend[Operator[A, A]](head)
 }
+
+// Reverse returns a new slice with elements in reverse order.
+// This function creates a new slice containing all elements from the input slice
+// in reverse order, without modifying the original slice.
+//
+// Type Parameters:
+//   - A: The type of elements in the slice
+//
+// Parameters:
+//   - as: The input slice to reverse
+//
+// Returns:
+//   - A new slice with elements in reverse order
+//
+// Behavior:
+//   - Creates a new slice with the same length as the input
+//   - Copies elements from the input slice in reverse order
+//   - Does not modify the original slice
+//   - Returns an empty slice if the input is empty
+//   - Returns a single-element slice unchanged if input has one element
+//
+// Example:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//	reversed := array.Reverse(numbers)
+//	// reversed: []int{5, 4, 3, 2, 1}
+//	// numbers: []int{1, 2, 3, 4, 5} (unchanged)
+//
+// Example with strings:
+//
+//	words := []string{"hello", "world", "foo", "bar"}
+//	reversed := array.Reverse(words)
+//	// reversed: []string{"bar", "foo", "world", "hello"}
+//
+// Example with empty slice:
+//
+//	empty := []int{}
+//	reversed := array.Reverse(empty)
+//	// reversed: []int{} (empty slice)
+//
+// Example with single element:
+//
+//	single := []string{"only"}
+//	reversed := array.Reverse(single)
+//	// reversed: []string{"only"}
+//
+// Use cases:
+//   - Reversing the order of elements for display or processing
+//   - Implementing stack-like behavior (LIFO)
+//   - Processing data in reverse chronological order
+//   - Reversing transformation pipelines
+//   - Creating palindrome checks
+//   - Implementing undo/redo functionality
+//
+// Example with processing in reverse:
+//
+//	events := []string{"start", "middle", "end"}
+//	reversed := array.Reverse(events)
+//	// Process events in reverse order
+//	for _, event := range reversed {
+//	    fmt.Println(event) // Prints: "end", "middle", "start"
+//	}
+//
+// Example with functional composition:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//	result := F.Pipe2(
+//	    numbers,
+//	    array.Map(N.Mul(2)),
+//	    array.Reverse,
+//	)
+//	// result: []int{10, 8, 6, 4, 2}
+//
+// Performance:
+//   - Time complexity: O(n) where n is the length of the slice
+//   - Space complexity: O(n) for the new slice
+//   - Does not allocate if the input slice is empty
+//
+// Note: This function is immutable - it does not modify the original slice.
+// If you need to reverse a slice in-place, consider using a different approach
+// or modifying the slice directly.
+//
+//go:inline
+func Reverse[A any](as []A) []A {
+	return G.Reverse(as)
+}

v2/array/array_test.go

@@ -22,6 +22,7 @@ import (
 
 	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/utils"
+	N "github.com/IBM/fp-go/v2/number"
 	O "github.com/IBM/fp-go/v2/option"
 	S "github.com/IBM/fp-go/v2/string"
 	T "github.com/IBM/fp-go/v2/tuple"
@@ -214,3 +215,262 @@ func ExampleFoldMap() {
 	// Output: ABC
 
 }
+
+// TestReverse tests the Reverse function
+func TestReverse(t *testing.T) {
+	t.Run("Reverse integers", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := Reverse(input)
+		expected := []int{5, 4, 3, 2, 1}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse strings", func(t *testing.T) {
+		input := []string{"hello", "world", "foo", "bar"}
+		result := Reverse(input)
+		expected := []string{"bar", "foo", "world", "hello"}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse empty slice", func(t *testing.T) {
+		input := []int{}
+		result := Reverse(input)
+		assert.Equal(t, []int{}, result)
+	})
+
+	t.Run("Reverse single element", func(t *testing.T) {
+		input := []string{"only"}
+		result := Reverse(input)
+		assert.Equal(t, []string{"only"}, result)
+	})
+
+	t.Run("Reverse two elements", func(t *testing.T) {
+		input := []int{1, 2}
+		result := Reverse(input)
+		assert.Equal(t, []int{2, 1}, result)
+	})
+
+	t.Run("Does not modify original slice", func(t *testing.T) {
+		original := []int{1, 2, 3, 4, 5}
+		originalCopy := []int{1, 2, 3, 4, 5}
+		_ = Reverse(original)
+		assert.Equal(t, originalCopy, original)
+	})
+
+	t.Run("Reverse with floats", func(t *testing.T) {
+		input := []float64{1.1, 2.2, 3.3}
+		result := Reverse(input)
+		expected := []float64{3.3, 2.2, 1.1}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse with structs", func(t *testing.T) {
+		type Person struct {
+			Name string
+			Age  int
+		}
+		input := []Person{
+			{"Alice", 30},
+			{"Bob", 25},
+			{"Charlie", 35},
+		}
+		result := Reverse(input)
+		expected := []Person{
+			{"Charlie", 35},
+			{"Bob", 25},
+			{"Alice", 30},
+		}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse with pointers", func(t *testing.T) {
+		a, b, c := 1, 2, 3
+		input := []*int{&a, &b, &c}
+		result := Reverse(input)
+		assert.Equal(t, []*int{&c, &b, &a}, result)
+	})
+
+	t.Run("Double reverse returns original order", func(t *testing.T) {
+		original := []int{1, 2, 3, 4, 5}
+		reversed := Reverse(original)
+		doubleReversed := Reverse(reversed)
+		assert.Equal(t, original, doubleReversed)
+	})
+
+	t.Run("Reverse with large slice", func(t *testing.T) {
+		input := MakeBy(1000, F.Identity[int])
+		result := Reverse(input)
+
+		// Check first and last elements
+		assert.Equal(t, 999, result[0])
+		assert.Equal(t, 0, result[999])
+
+		// Check length
+		assert.Equal(t, 1000, len(result))
+	})
+
+	t.Run("Reverse palindrome", func(t *testing.T) {
+		input := []int{1, 2, 3, 2, 1}
+		result := Reverse(input)
+		assert.Equal(t, input, result)
+	})
+}
+
+// TestReverseComposition tests Reverse with other array operations
+func TestReverseComposition(t *testing.T) {
+	t.Run("Reverse after Map", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := F.Pipe2(
+			input,
+			Map(N.Mul(2)),
+			Reverse[int],
+		)
+		expected := []int{10, 8, 6, 4, 2}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Map after Reverse", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := F.Pipe2(
+			input,
+			Reverse[int],
+			Map(N.Mul(2)),
+		)
+		expected := []int{10, 8, 6, 4, 2}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse with Filter", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5, 6}
+		result := F.Pipe2(
+			input,
+			Filter(func(n int) bool { return n%2 == 0 }),
+			Reverse[int],
+		)
+		expected := []int{6, 4, 2}
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("Reverse with Reduce", func(t *testing.T) {
+		input := []string{"a", "b", "c"}
+		reversed := Reverse(input)
+		result := Reduce(func(acc, val string) string {
+			return acc + val
+		}, "")(reversed)
+		assert.Equal(t, "cba", result)
+	})
+
+	t.Run("Reverse with Flatten", func(t *testing.T) {
+		input := [][]int{{1, 2}, {3, 4}, {5, 6}}
+		result := F.Pipe2(
+			input,
+			Reverse[[]int],
+			Flatten[int],
+		)
+		expected := []int{5, 6, 3, 4, 1, 2}
+		assert.Equal(t, expected, result)
+	})
+}
+
+// TestReverseUseCases demonstrates practical use cases for Reverse
+func TestReverseUseCases(t *testing.T) {
+	t.Run("Process events in reverse chronological order", func(t *testing.T) {
+		events := []string{"2024-01-01", "2024-01-02", "2024-01-03"}
+		reversed := Reverse(events)
+
+		// Most recent first
+		assert.Equal(t, "2024-01-03", reversed[0])
+		assert.Equal(t, "2024-01-01", reversed[2])
+	})
+
+	t.Run("Implement stack behavior (LIFO)", func(t *testing.T) {
+		stack := []int{1, 2, 3, 4, 5}
+		reversed := Reverse(stack)
+
+		// Pop from reversed (LIFO)
+		assert.Equal(t, 5, reversed[0])
+		assert.Equal(t, 4, reversed[1])
+	})
+
+	t.Run("Reverse string characters", func(t *testing.T) {
+		chars := []rune("hello")
+		reversed := Reverse(chars)
+		result := string(reversed)
+		assert.Equal(t, "olleh", result)
+	})
+
+	t.Run("Check palindrome", func(t *testing.T) {
+		word := []rune("racecar")
+		reversed := Reverse(word)
+		assert.Equal(t, word, reversed)
+
+		notPalindrome := []rune("hello")
+		reversedNot := Reverse(notPalindrome)
+		assert.NotEqual(t, notPalindrome, reversedNot)
+	})
+
+	t.Run("Reverse transformation pipeline", func(t *testing.T) {
+		// Apply transformations in reverse order
+		numbers := []int{1, 2, 3}
+
+		// Normal: add 10, then multiply by 2
+		normal := F.Pipe2(
+			numbers,
+			Map(N.Add(10)),
+			Map(N.Mul(2)),
+		)
+
+		// Reversed order of operations
+		reversed := F.Pipe2(
+			numbers,
+			Map(N.Mul(2)),
+			Map(N.Add(10)),
+		)
+
+		assert.NotEqual(t, normal, reversed)
+		assert.Equal(t, []int{22, 24, 26}, normal)
+		assert.Equal(t, []int{12, 14, 16}, reversed)
+	})
+}
+
+// TestReverseProperties tests mathematical properties of Reverse
+func TestReverseProperties(t *testing.T) {
+	t.Run("Involution property: Reverse(Reverse(x)) == x", func(t *testing.T) {
+		testCases := [][]int{
+			{1, 2, 3, 4, 5},
+			{1},
+			{},
+			{1, 2},
+			{5, 4, 3, 2, 1},
+		}
+
+		for _, original := range testCases {
+			result := Reverse(Reverse(original))
+			assert.Equal(t, original, result)
+		}
+	})
+
+	t.Run("Length preservation: len(Reverse(x)) == len(x)", func(t *testing.T) {
+		testCases := [][]int{
+			{1, 2, 3, 4, 5},
+			{1},
+			{},
+			MakeBy(100, F.Identity[int]),
+		}
+
+		for _, input := range testCases {
+			result := Reverse(input)
+			assert.Equal(t, len(input), len(result))
+		}
+	})
+
+	t.Run("First element becomes last", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result := Reverse(input)
+
+		if len(input) > 0 {
+			assert.Equal(t, input[0], result[len(result)-1])
+			assert.Equal(t, input[len(input)-1], result[0])
+		}
+	})
+}

v2/array/eq.go

@@ -16,22 +16,11 @@
 package array
 
 import (
+	"slices"
+
 	E "github.com/IBM/fp-go/v2/eq"
 )
 
-func equals[T any](left []T, right []T, eq func(T, T) bool) bool {
-	if len(left) != len(right) {
-		return false
-	}
-	for i, v1 := range left {
-		v2 := right[i]
-		if !eq(v1, v2) {
-			return false
-		}
-	}
-	return true
-}
-
 // Eq creates an equality checker for arrays given an equality checker for elements.
 // Two arrays are considered equal if they have the same length and all corresponding
 // elements are equal according to the provided Eq instance.
@@ -46,6 +35,11 @@ func equals[T any](left []T, right []T, eq func(T, T) bool) bool {
 func Eq[T any](e E.Eq[T]) E.Eq[[]T] {
 	eq := e.Equals
 	return E.FromEquals(func(left, right []T) bool {
-		return equals(left, right, eq)
+		return slices.EqualFunc(left, right, eq)
 	})
 }
+
+//go:inline
+func StrictEquals[T comparable]() E.Eq[[]T] {
+	return E.FromEquals(slices.Equal[[]T])
+}

v2/array/generic/array.go

@@ -140,22 +140,27 @@ func Empty[GA ~[]A, A any]() GA {
 	return array.Empty[GA]()
 }
 
+//go:inline
 func UpsertAt[GA ~[]A, A any](a A) func(GA) GA {
 	return array.UpsertAt[GA](a)
 }
 
+//go:inline
 func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return array.MonadMap[GA, GB](as, f)
 }
 
+//go:inline
 func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
 	return array.Map[GA, GB](f)
 }
 
+//go:inline
 func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
 	return array.MonadMapWithIndex[GA, GB](as, f)
 }
 
+//go:inline
 func MapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) B) func(GA) GB {
 	return F.Bind2nd(MonadMapWithIndex[GA, GB, A, B], f)
 }
@@ -297,7 +302,7 @@ func MatchLeft[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(A, AS) B) fu
 }
 
 //go:inline
-func Slice[AS ~[]A, A any](start int, end int) func(AS) AS {
+func Slice[AS ~[]A, A any](start, end int) func(AS) AS {
 	return array.Slice[AS](start, end)
 }
 
@@ -361,6 +366,12 @@ func Flap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](a A) func(GFAB) GB {
 	return FC.Flap(Map[GFAB, GB], a)
 }
 
+//go:inline
 func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {
 	return array.Prepend[ENDO](head)
 }
+
+//go:inline
+func Reverse[GT ~[]T, T any](as GT) GT {
+	return array.Reverse(as)
+}

v2/array/nonempty/array.go

@@ -18,14 +18,11 @@ package nonempty
 import (
 	G "github.com/IBM/fp-go/v2/array/generic"
 	EM "github.com/IBM/fp-go/v2/endomorphism"
-	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/array"
+	"github.com/IBM/fp-go/v2/option"
 	S "github.com/IBM/fp-go/v2/semigroup"
 )
 
-// NonEmptyArray represents an array with at least one element
-type NonEmptyArray[A any] []A
-
 // Of constructs a single element array
 func Of[A any](first A) NonEmptyArray[A] {
 	return G.Of[NonEmptyArray[A]](first)
@@ -44,20 +41,24 @@ func From[A any](first A, data ...A) NonEmptyArray[A] {
 	return buffer
 }
 
+//go:inline
 func IsEmpty[A any](_ NonEmptyArray[A]) bool {
 	return false
 }
 
+//go:inline
 func IsNonEmpty[A any](_ NonEmptyArray[A]) bool {
 	return true
 }
 
+//go:inline
 func MonadMap[A, B any](as NonEmptyArray[A], f func(a A) B) NonEmptyArray[B] {
 	return G.MonadMap[NonEmptyArray[A], NonEmptyArray[B]](as, f)
 }
 
-func Map[A, B any](f func(a A) B) func(NonEmptyArray[A]) NonEmptyArray[B] {
-	return F.Bind2nd(MonadMap[A, B], f)
+//go:inline
+func Map[A, B any](f func(a A) B) Operator[A, B] {
+	return G.Map[NonEmptyArray[A], NonEmptyArray[B]](f)
 }
 
 func Reduce[A, B any](f func(B, A) B, initial B) func(NonEmptyArray[A]) B {
@@ -72,22 +73,27 @@ func ReduceRight[A, B any](f func(A, B) B, initial B) func(NonEmptyArray[A]) B {
 	}
 }
 
+//go:inline
 func Tail[A any](as NonEmptyArray[A]) []A {
 	return as[1:]
 }
 
+//go:inline
 func Head[A any](as NonEmptyArray[A]) A {
 	return as[0]
 }
 
+//go:inline
 func First[A any](as NonEmptyArray[A]) A {
 	return as[0]
 }
 
+//go:inline
 func Last[A any](as NonEmptyArray[A]) A {
 	return as[len(as)-1]
 }
 
+//go:inline
 func Size[A any](as NonEmptyArray[A]) int {
 	return G.Size(as)
 }
@@ -96,11 +102,11 @@ func Flatten[A any](mma NonEmptyArray[NonEmptyArray[A]]) NonEmptyArray[A] {
 	return G.Flatten(mma)
 }
 
-func MonadChain[A, B any](fa NonEmptyArray[A], f func(a A) NonEmptyArray[B]) NonEmptyArray[B] {
+func MonadChain[A, B any](fa NonEmptyArray[A], f Kleisli[A, B]) NonEmptyArray[B] {
 	return G.MonadChain(fa, f)
 }
 
-func Chain[A, B any](f func(A) NonEmptyArray[B]) func(NonEmptyArray[A]) NonEmptyArray[B] {
+func Chain[A, B any](f func(A) NonEmptyArray[B]) Operator[A, B] {
 	return G.Chain[NonEmptyArray[A]](f)
 }
 
@@ -134,3 +140,89 @@ func Fold[A any](s S.Semigroup[A]) func(NonEmptyArray[A]) A {
 func Prepend[A any](head A) EM.Endomorphism[NonEmptyArray[A]] {
 	return array.Prepend[EM.Endomorphism[NonEmptyArray[A]]](head)
 }
+
+// ToNonEmptyArray attempts to convert a regular slice into a NonEmptyArray.
+// This function provides a safe way to create a NonEmptyArray from a slice that might be empty,
+// returning an Option type to handle the case where the input slice is empty.
+//
+// Type Parameters:
+//   - A: The element type of the array
+//
+// Parameters:
+//   - as: A regular slice that may or may not be empty
+//
+// Returns:
+//   - Option[NonEmptyArray[A]]: Some(NonEmptyArray) if the input slice is non-empty, None if empty
+//
+// Behavior:
+//   - If the input slice is empty, returns None
+//   - If the input slice has at least one element, wraps it in Some and returns it as a NonEmptyArray
+//   - The conversion is a type cast, so no data is copied
+//
+// Example:
+//
+//	// Convert non-empty slice
+//	numbers := []int{1, 2, 3}
+//	result := ToNonEmptyArray(numbers)  // Some(NonEmptyArray[1, 2, 3])
+//
+//	// Convert empty slice
+//	empty := []int{}
+//	result := ToNonEmptyArray(empty)  // None
+//
+//	// Use with Option methods
+//	numbers := []int{1, 2, 3}
+//	result := ToNonEmptyArray(numbers)
+//	if O.IsSome(result) {
+//	    nea := O.GetOrElse(F.Constant(From(0)))(result)
+//	    head := Head(nea)  // 1
+//	}
+//
+// Use cases:
+//   - Safely converting user input or external data to NonEmptyArray
+//   - Validating that a collection has at least one element before processing
+//   - Converting results from functions that return regular slices
+//   - Ensuring type safety when working with collections that must not be empty
+//
+// Example with validation:
+//
+//	func processItems(items []string) Option[string] {
+//	    return F.Pipe2(
+//	        items,
+//	        ToNonEmptyArray[string],
+//	        O.Map(func(nea NonEmptyArray[string]) string {
+//	            return Head(nea)  // Safe to get head since we know it's non-empty
+//	        }),
+//	    )
+//	}
+//
+// Example with error handling:
+//
+//	items := []int{1, 2, 3}
+//	result := ToNonEmptyArray(items)
+//	switch {
+//	case O.IsSome(result):
+//	    nea := O.GetOrElse(F.Constant(From(0)))(result)
+//	    fmt.Println("First item:", Head(nea))
+//	case O.IsNone(result):
+//	    fmt.Println("Array is empty")
+//	}
+//
+// Example with chaining:
+//
+//	// Process only if non-empty
+//	result := F.Pipe3(
+//	    []int{1, 2, 3},
+//	    ToNonEmptyArray[int],
+//	    O.Map(Map(func(x int) int { return x * 2 })),
+//	    O.Map(Head[int]),
+//	)  // Some(2)
+//
+// Note: This function is particularly useful when working with APIs or functions
+// that return regular slices but you need the type-level guarantee that the
+// collection is non-empty for subsequent operations.
+func ToNonEmptyArray[A any](as []A) Option[NonEmptyArray[A]] {
+	if G.IsEmpty(as) {
+		return option.None[NonEmptyArray[A]]()
+	}
+	return option.Some(NonEmptyArray[A](as))
+}

v2/array/nonempty/array_test.go

@@ -0,0 +1,370 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package nonempty
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestToNonEmptyArray tests the ToNonEmptyArray function
+func TestToNonEmptyArray(t *testing.T) {
+	t.Run("Convert non-empty slice of integers", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0)))(result)
+		assert.Equal(t, 3, Size(nea))
+		assert.Equal(t, 1, Head(nea))
+		assert.Equal(t, 3, Last(nea))
+	})
+
+	t.Run("Convert empty slice returns None", func(t *testing.T) {
+		input := []int{}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsNone(result))
+	})
+
+	t.Run("Convert single element slice", func(t *testing.T) {
+		input := []string{"hello"}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From("")))(result)
+		assert.Equal(t, 1, Size(nea))
+		assert.Equal(t, "hello", Head(nea))
+	})
+
+	t.Run("Convert non-empty slice of strings", func(t *testing.T) {
+		input := []string{"a", "b", "c", "d"}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From("")))(result)
+		assert.Equal(t, 4, Size(nea))
+		assert.Equal(t, "a", Head(nea))
+		assert.Equal(t, "d", Last(nea))
+	})
+
+	t.Run("Convert nil slice returns None", func(t *testing.T) {
+		var input []int
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsNone(result))
+	})
+
+	t.Run("Convert slice with struct elements", func(t *testing.T) {
+		type Person struct {
+			Name string
+			Age  int
+		}
+		input := []Person{
+			{Name: "Alice", Age: 30},
+			{Name: "Bob", Age: 25},
+		}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(Person{})))(result)
+		assert.Equal(t, 2, Size(nea))
+		assert.Equal(t, "Alice", Head(nea).Name)
+	})
+
+	t.Run("Convert slice with pointer elements", func(t *testing.T) {
+		val1, val2 := 10, 20
+		input := []*int{&val1, &val2}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From[*int](nil)))(result)
+		assert.Equal(t, 2, Size(nea))
+		assert.Equal(t, 10, *Head(nea))
+	})
+
+	t.Run("Convert large slice", func(t *testing.T) {
+		input := make([]int, 1000)
+		for i := range input {
+			input[i] = i
+		}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0)))(result)
+		assert.Equal(t, 1000, Size(nea))
+		assert.Equal(t, 0, Head(nea))
+		assert.Equal(t, 999, Last(nea))
+	})
+
+	t.Run("Convert slice with float64 elements", func(t *testing.T) {
+		input := []float64{1.5, 2.5, 3.5}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0.0)))(result)
+		assert.Equal(t, 3, Size(nea))
+		assert.Equal(t, 1.5, Head(nea))
+	})
+
+	t.Run("Convert slice with boolean elements", func(t *testing.T) {
+		input := []bool{true, false, true}
+		result := ToNonEmptyArray(input)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(false)))(result)
+		assert.Equal(t, 3, Size(nea))
+		assert.True(t, Head(nea))
+	})
+}
+
+// TestToNonEmptyArrayWithOption tests ToNonEmptyArray with Option operations
+func TestToNonEmptyArrayWithOption(t *testing.T) {
+	t.Run("Chain with Map to process elements", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[int],
+			O.Map(Map(func(x int) int { return x * 2 })),
+		)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0)))(result)
+		assert.Equal(t, 2, Head(nea))
+		assert.Equal(t, 6, Last(nea))
+	})
+
+	t.Run("Chain with Map to get head", func(t *testing.T) {
+		input := []string{"first", "second", "third"}
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[string],
+			O.Map(Head[string]),
+		)
+
+		assert.True(t, O.IsSome(result))
+		value := O.GetOrElse(F.Constant(""))(result)
+		assert.Equal(t, "first", value)
+	})
+
+	t.Run("GetOrElse with default value for empty slice", func(t *testing.T) {
+		input := []int{}
+		defaultValue := From(42)
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[int],
+			O.GetOrElse(F.Constant(defaultValue)),
+		)
+
+		assert.Equal(t, 1, Size(result))
+		assert.Equal(t, 42, Head(result))
+	})
+
+	t.Run("GetOrElse with default value for non-empty slice", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		defaultValue := From(42)
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[int],
+			O.GetOrElse(F.Constant(defaultValue)),
+		)
+
+		assert.Equal(t, 3, Size(result))
+		assert.Equal(t, 1, Head(result))
+	})
+
+	t.Run("Fold with Some case", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[int],
+			O.Fold(
+				F.Constant(0),
+				func(nea NonEmptyArray[int]) int { return Head(nea) },
+			),
+		)
+
+		assert.Equal(t, 1, result)
+	})
+
+	t.Run("Fold with None case", func(t *testing.T) {
+		input := []int{}
+		result := F.Pipe2(
+			input,
+			ToNonEmptyArray[int],
+			O.Fold(
+				F.Constant(-1),
+				func(nea NonEmptyArray[int]) int { return Head(nea) },
+			),
+		)
+
+		assert.Equal(t, -1, result)
+	})
+}
+
+// TestToNonEmptyArrayComposition tests composing ToNonEmptyArray with other operations
+func TestToNonEmptyArrayComposition(t *testing.T) {
+	t.Run("Compose with filter-like operation", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		// Filter even numbers then convert
+		filtered := []int{}
+		for _, x := range input {
+			if x%2 == 0 {
+				filtered = append(filtered, x)
+			}
+		}
+		result := ToNonEmptyArray(filtered)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0)))(result)
+		assert.Equal(t, 2, Size(nea))
+		assert.Equal(t, 2, Head(nea))
+	})
+
+	t.Run("Compose with map operation before conversion", func(t *testing.T) {
+		input := []int{1, 2, 3}
+		// Map then convert
+		mapped := make([]int, len(input))
+		for i, x := range input {
+			mapped[i] = x * 10
+		}
+		result := ToNonEmptyArray(mapped)
+
+		assert.True(t, O.IsSome(result))
+		nea := O.GetOrElse(F.Constant(From(0)))(result)
+		assert.Equal(t, 10, Head(nea))
+		assert.Equal(t, 30, Last(nea))
+	})
+
+	t.Run("Chain multiple Option operations", func(t *testing.T) {
+		input := []int{5, 10, 15}
+		result := F.Pipe3(
+			input,
+			ToNonEmptyArray[int],
+			O.Map(Map(func(x int) int { return x / 5 })),
+			O.Map(func(nea NonEmptyArray[int]) int {
+				return Head(nea) + Last(nea)
+			}),
+		)
+
+		assert.True(t, O.IsSome(result))
+		value := O.GetOrElse(F.Constant(0))(result)
+		assert.Equal(t, 4, value) // 1 + 3
+	})
+}
+
+// TestToNonEmptyArrayUseCases demonstrates practical use cases
+func TestToNonEmptyArrayUseCases(t *testing.T) {
+	t.Run("Validate user input has at least one item", func(t *testing.T) {
+		// Simulate user input
+		userInput := []string{"item1", "item2"}
+
+		result := ToNonEmptyArray(userInput)
+		if O.IsSome(result) {
+			nea := O.GetOrElse(F.Constant(From("")))(result)
+			firstItem := Head(nea)
+			assert.Equal(t, "item1", firstItem)
+		} else {
+			t.Fatal("Expected Some but got None")
+		}
+	})
+
+	t.Run("Process only non-empty collections", func(t *testing.T) {
+		processItems := func(items []int) Option[int] {
+			return F.Pipe2(
+				items,
+				ToNonEmptyArray[int],
+				O.Map(func(nea NonEmptyArray[int]) int {
+					// Safe to use Head since we know it's non-empty
+					return Head(nea) * 2
+				}),
+			)
+		}
+
+		result1 := processItems([]int{5, 10, 15})
+		assert.True(t, O.IsSome(result1))
+		assert.Equal(t, 10, O.GetOrElse(F.Constant(0))(result1))
+
+		result2 := processItems([]int{})
+		assert.True(t, O.IsNone(result2))
+	})
+
+	t.Run("Convert API response to NonEmptyArray", func(t *testing.T) {
+		// Simulate API response
+		type APIResponse struct {
+			Items []string
+		}
+
+		response := APIResponse{Items: []string{"data1", "data2", "data3"}}
+
+		result := F.Pipe2(
+			response.Items,
+			ToNonEmptyArray[string],
+			O.Map(func(nea NonEmptyArray[string]) string {
+				return "First item: " + Head(nea)
+			}),
+		)
+
+		assert.True(t, O.IsSome(result))
+		message := O.GetOrElse(F.Constant("No items"))(result)
+		assert.Equal(t, "First item: data1", message)
+	})
+
+	t.Run("Ensure collection is non-empty before processing", func(t *testing.T) {
+		calculateAverage := func(numbers []float64) Option[float64] {
+			return F.Pipe2(
+				numbers,
+				ToNonEmptyArray[float64],
+				O.Map(func(nea NonEmptyArray[float64]) float64 {
+					sum := 0.0
+					for _, n := range nea {
+						sum += n
+					}
+					return sum / float64(Size(nea))
+				}),
+			)
+		}
+
+		result1 := calculateAverage([]float64{10.0, 20.0, 30.0})
+		assert.True(t, O.IsSome(result1))
+		assert.Equal(t, 20.0, O.GetOrElse(F.Constant(0.0))(result1))
+
+		result2 := calculateAverage([]float64{})
+		assert.True(t, O.IsNone(result2))
+	})
+
+	t.Run("Safe head extraction with type guarantee", func(t *testing.T) {
+		getFirstOrDefault := func(items []string, defaultValue string) string {
+			return F.Pipe2(
+				items,
+				ToNonEmptyArray[string],
+				O.Fold(
+					F.Constant(defaultValue),
+					Head[string],
+				),
+			)
+		}
+
+		result1 := getFirstOrDefault([]string{"a", "b", "c"}, "default")
+		assert.Equal(t, "a", result1)
+
+		result2 := getFirstOrDefault([]string{}, "default")
+		assert.Equal(t, "default", result2)
+	})
+}

v2/array/nonempty/types.go

@@ -0,0 +1,20 @@
+package nonempty
+
+import "github.com/IBM/fp-go/v2/option"
+
+type (
+	// NonEmptyArray represents an array that is guaranteed to have at least one element.
+	// This provides compile-time safety for operations that require non-empty collections.
+	NonEmptyArray[A any] []A
+
+	// Kleisli represents a Kleisli arrow for the NonEmptyArray monad.
+	// It's a function from A to NonEmptyArray[B], used for composing operations that produce non-empty arrays.
+	Kleisli[A, B any] = func(A) NonEmptyArray[B]
+
+	// Operator represents a function that transforms one NonEmptyArray into another.
+	// It takes a NonEmptyArray[A] and produces a NonEmptyArray[B].
+	Operator[A, B any] = Kleisli[NonEmptyArray[A], B]
+
+	// Option represents an optional value that may or may not be present.
+	Option[A any] = option.Option[A]
+)

v2/array/types.go

@@ -3,7 +3,14 @@ package array
 import "github.com/IBM/fp-go/v2/option"
 
 type (
-	Kleisli[A, B any]  = func(A) []B
+	// Kleisli represents a Kleisli arrow for arrays.
+	// It's a function from A to []B, used for composing operations that produce arrays.
+	Kleisli[A, B any] = func(A) []B
+
+	// Operator represents a function that transforms one array into another.
+	// It takes a []A and produces a []B.
 	Operator[A, B any] = Kleisli[[]A, B]
-	Option[A any]      = option.Option[A]
+
+	// Option represents an optional value that may or may not be present.
+	Option[A any] = option.Option[A]
 )

v2/assert/assert.go

@@ -57,7 +57,7 @@
 //	assert.ArrayNotEmpty(arr)(t)
 //
 //	// Partial application - create reusable assertions
-//	isPositive := assert.That(func(n int) bool { return n > 0 })
+//	isPositive := assert.That(N.MoreThan(0))
 //	// Later, apply to different values:
 //	isPositive(42)(t)   // Passes
 //	isPositive(-5)(t)   // Fails
@@ -416,7 +416,7 @@ func NotContainsKey[T any, K comparable](expected K) Kleisli[map[K]T] {
 //
 //	func TestThat(t *testing.T) {
 //	    // Test if a number is positive
-//	    isPositive := func(n int) bool { return n > 0 }
+//	    isPositive := N.MoreThan(0)
 //	    assert.That(isPositive)(42)(t)  // Passes
 //	    assert.That(isPositive)(-5)(t)  // Fails
 //

v2/assert/assert_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/IBM/fp-go/v2/optics/prism"
 	"github.com/IBM/fp-go/v2/option"
 	"github.com/IBM/fp-go/v2/result"
+	S "github.com/IBM/fp-go/v2/string"
 )
 
 func TestEqual(t *testing.T) {
@@ -334,7 +335,7 @@ func TestThat(t *testing.T) {
 	})
 
 	t.Run("should work with string predicates", func(t *testing.T) {
-		startsWithH := func(s string) bool { return len(s) > 0 && s[0] == 'h' }
+		startsWithH := func(s string) bool { return S.IsNonEmpty(s) && s[0] == 'h' }
 		result := That(startsWithH)("hello")(t)
 		if !result {
 			t.Error("Expected That to pass for string predicate")
@@ -484,7 +485,7 @@ func TestLocal(t *testing.T) {
 	t.Run("should compose with other assertions", func(t *testing.T) {
 		// Create multiple focused assertions
 		nameNotEmpty := Local(func(u User) string { return u.Name })(
-			That(func(name string) bool { return len(name) > 0 }),
+			That(S.IsNonEmpty),
 		)
 		ageInRange := Local(func(u User) int { return u.Age })(
 			That(func(age int) bool { return age >= 18 && age <= 100 }),

v2/assert/example_test.go

@@ -21,6 +21,7 @@ import (
 	"testing"
 
 	"github.com/IBM/fp-go/v2/assert"
+	N "github.com/IBM/fp-go/v2/number"
 	"github.com/IBM/fp-go/v2/result"
 )
 
@@ -98,7 +99,7 @@ func Example_resultAssertions() {
 	var t *testing.T // placeholder for example
 
 	// Assert success
-	successResult := result.Of[int](42)
+	successResult := result.Of(42)
 	assert.Success(successResult)(t)
 
 	// Assert failure
@@ -111,7 +112,7 @@ func Example_predicateAssertions() {
 	var t *testing.T // placeholder for example
 
 	// Test if a number is positive
-	isPositive := func(n int) bool { return n > 0 }
+	isPositive := N.MoreThan(0)
 	assert.That(isPositive)(42)(t)
 
 	// Test if a string is uppercase

v2/assert/types.go

@@ -12,11 +12,24 @@ import (
 )
 
 type (
-	Result[T any]      = result.Result[T]
-	Reader             = reader.Reader[*testing.T, bool]
-	Kleisli[T any]     = reader.Reader[T, Reader]
-	Predicate[T any]   = predicate.Predicate[T]
-	Lens[S, T any]     = lens.Lens[S, T]
+	// Result represents a computation that may fail with an error.
+	Result[T any] = result.Result[T]
+
+	// Reader represents a test assertion that depends on a testing.T context and returns a boolean.
+	Reader = reader.Reader[*testing.T, bool]
+
+	// Kleisli represents a function that produces a test assertion Reader from a value of type T.
+	Kleisli[T any] = reader.Reader[T, Reader]
+
+	// Predicate represents a function that tests a value of type T and returns a boolean.
+	Predicate[T any] = predicate.Predicate[T]
+
+	// Lens is a functional reference to a subpart of a data structure.
+	Lens[S, T any] = lens.Lens[S, T]
+
+	// Optional is an optic that focuses on a value that may or may not be present.
 	Optional[S, T any] = optional.Optional[S, T]
-	Prism[S, T any]    = prism.Prism[S, T]
+
+	// Prism is an optic that focuses on a case of a sum type.
+	Prism[S, T any] = prism.Prism[S, T]
 )

v2/boolean/types.go

@@ -18,5 +18,7 @@ package boolean
 import "github.com/IBM/fp-go/v2/monoid"
 
 type (
+	// Monoid represents a monoid structure for boolean values.
+	// A monoid provides an associative binary operation and an identity element.
 	Monoid = monoid.Monoid[bool]
 )

v2/builder/types.go

@@ -7,9 +7,14 @@ import (
 )
 
 type (
+	// Result represents a computation that may fail with an error.
+	// It's an alias for Either[error, T].
 	Result[T any] = result.Result[T]
 
+	// Prism is an optic that focuses on a case of a sum type.
+	// It provides a way to extract and construct values of a specific variant.
 	Prism[S, A any] = prism.Prism[S, A]
 
+	// Option represents an optional value that may or may not be present.
 	Option[T any] = option.Option[T]
 )

v2/cli/lens.go

@@ -27,13 +27,15 @@ import (
 	"strings"
 	"text/template"
 
+	S "github.com/IBM/fp-go/v2/string"
 	C "github.com/urfave/cli/v2"
 )
 
 const (
-	keyLensDir     = "dir"
-	keyVerbose     = "verbose"
-	lensAnnotation = "fp-go:Lens"
+	keyLensDir         = "dir"
+	keyVerbose         = "verbose"
+	keyIncludeTestFile = "include-test-files"
+	lensAnnotation     = "fp-go:Lens"
 )
 
 var (
@@ -49,6 +51,13 @@ var (
 		Value:   false,
 		Usage:   "Enable verbose output",
 	}
+
+	flagIncludeTestFiles = &C.BoolFlag{
+		Name:    keyIncludeTestFile,
+		Aliases: []string{"t"},
+		Value:   false,
+		Usage:   "Include test files (*_test.go) when scanning for annotated types",
+	}
 )
 
 // structInfo holds information about a struct that needs lens generation
@@ -67,6 +76,7 @@ type fieldInfo struct {
 	BaseType     string // TypeName without leading * for pointer types
 	IsOptional   bool   // true if field is a pointer or has json omitempty tag
 	IsComparable bool   // true if the type is comparable (can use ==)
+	IsEmbedded   bool   // true if this field comes from an embedded struct
 }
 
 // templateData holds data for template rendering
@@ -80,12 +90,12 @@ const lensStructTemplate = `
 type {{.Name}}Lenses{{.TypeParams}} struct {
 	// mandatory fields
 {{- range .Fields}}
-	{{.Name}} L.Lens[{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
+	{{.Name}} __lens.Lens[{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
 {{- end}}
 	// optional fields
 {{- range .Fields}}
 {{- if .IsComparable}}
-	{{.Name}}O LO.LensO[{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
+	{{.Name}}O __lens_option.LensO[{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
 {{- end}}
 {{- end}}
 }
@@ -94,13 +104,24 @@ type {{.Name}}Lenses{{.TypeParams}} struct {
 type {{.Name}}RefLenses{{.TypeParams}} struct {
 	// mandatory fields
 {{- range .Fields}}
-	{{.Name}} L.Lens[*{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
+	{{.Name}} __lens.Lens[*{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
 {{- end}}
 	// optional fields
 {{- range .Fields}}
 {{- if .IsComparable}}
-	{{.Name}}O LO.LensO[*{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
+	{{.Name}}O __lens_option.LensO[*{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
 {{- end}}
+{{- end}}
+	// prisms
+{{- range .Fields}}
+	{{.Name}}P __prism.Prism[*{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
+{{- end}}
+}
+
+// {{.Name}}Prisms provides prisms for accessing fields of {{.Name}}
+type {{.Name}}Prisms{{.TypeParams}} struct {
+{{- range .Fields}}
+	{{.Name}} __prism.Prism[{{$.Name}}{{$.TypeParamNames}}, {{.TypeName}}]
 {{- end}}
 }
 `
@@ -110,15 +131,16 @@ const lensConstructorTemplate = `
 func Make{{.Name}}Lenses{{.TypeParams}}() {{.Name}}Lenses{{.TypeParamNames}} {
 	// mandatory lenses
 {{- range .Fields}}
-	lens{{.Name}} := L.MakeLens(
+	lens{{.Name}} := __lens.MakeLensWithName(
 		func(s {{$.Name}}{{$.TypeParamNames}}) {{.TypeName}} { return s.{{.Name}} },
 		func(s {{$.Name}}{{$.TypeParamNames}}, v {{.TypeName}}) {{$.Name}}{{$.TypeParamNames}} { s.{{.Name}} = v; return s },
+		"{{$.Name}}{{$.TypeParamNames}}.{{.Name}}",
 	)
 {{- end}}
 	// optional lenses
 {{- range .Fields}}
 {{- if .IsComparable}}
-	lens{{.Name}}O := LO.FromIso[{{$.Name}}{{$.TypeParamNames}}](IO.FromZero[{{.TypeName}}]())(lens{{.Name}})
+	lens{{.Name}}O := __lens_option.FromIso[{{$.Name}}{{$.TypeParamNames}}](__iso_option.FromZero[{{.TypeName}}]())(lens{{.Name}})
 {{- end}}
 {{- end}}
 	return {{.Name}}Lenses{{.TypeParamNames}}{
@@ -140,21 +162,23 @@ func Make{{.Name}}RefLenses{{.TypeParams}}() {{.Name}}RefLenses{{.TypeParamNames
 	// mandatory lenses
 {{- range .Fields}}
 {{- if .IsComparable}}
-	lens{{.Name}} := L.MakeLensStrict(
+	lens{{.Name}} := __lens.MakeLensStrictWithName(
 		func(s *{{$.Name}}{{$.TypeParamNames}}) {{.TypeName}} { return s.{{.Name}} },
 		func(s *{{$.Name}}{{$.TypeParamNames}}, v {{.TypeName}}) *{{$.Name}}{{$.TypeParamNames}} { s.{{.Name}} = v; return s },
+		"(*{{$.Name}}{{$.TypeParamNames}}).{{.Name}}",
 	)
 {{- else}}
-	lens{{.Name}} := L.MakeLensRef(
+	lens{{.Name}} := __lens.MakeLensRefWithName(
 		func(s *{{$.Name}}{{$.TypeParamNames}}) {{.TypeName}} { return s.{{.Name}} },
 		func(s *{{$.Name}}{{$.TypeParamNames}}, v {{.TypeName}}) *{{$.Name}}{{$.TypeParamNames}} { s.{{.Name}} = v; return s },
+		"(*{{$.Name}}{{$.TypeParamNames}}).{{.Name}}",
 	)
 {{- end}}
 {{- end}}
 	// optional lenses
 {{- range .Fields}}
 {{- if .IsComparable}}
-	lens{{.Name}}O := LO.FromIso[*{{$.Name}}{{$.TypeParamNames}}](IO.FromZero[{{.TypeName}}]())(lens{{.Name}})
+	lens{{.Name}}O := __lens_option.FromIso[*{{$.Name}}{{$.TypeParamNames}}](__iso_option.FromZero[{{.TypeName}}]())(lens{{.Name}})
 {{- end}}
 {{- end}}
 	return {{.Name}}RefLenses{{.TypeParamNames}}{
@@ -170,6 +194,47 @@ func Make{{.Name}}RefLenses{{.TypeParams}}() {{.Name}}RefLenses{{.TypeParamNames
 {{- end}}
 	}
 }
+
+// Make{{.Name}}Prisms creates a new {{.Name}}Prisms with prisms for all fields
+func Make{{.Name}}Prisms{{.TypeParams}}() {{.Name}}Prisms{{.TypeParamNames}} {
+{{- range .Fields}}
+{{- if .IsComparable}}
+	_fromNonZero{{.Name}} := __option.FromNonZero[{{.TypeName}}]()
+	_prism{{.Name}} := __prism.MakePrismWithName(
+		func(s {{$.Name}}{{$.TypeParamNames}}) __option.Option[{{.TypeName}}] { return _fromNonZero{{.Name}}(s.{{.Name}}) },
+		func(v {{.TypeName}}) {{$.Name}}{{$.TypeParamNames}} {
+			{{- if .IsEmbedded}}
+			var result {{$.Name}}{{$.TypeParamNames}}
+			result.{{.Name}} = v
+			return result
+			{{- else}}
+			return {{$.Name}}{{$.TypeParamNames}}{ {{.Name}}: v }
+			{{- end}}
+		},
+		"{{$.Name}}{{$.TypeParamNames}}.{{.Name}}",
+	)
+{{- else}}
+	_prism{{.Name}} := __prism.MakePrismWithName(
+		func(s {{$.Name}}{{$.TypeParamNames}}) __option.Option[{{.TypeName}}] { return __option.Some(s.{{.Name}}) },
+		func(v {{.TypeName}}) {{$.Name}}{{$.TypeParamNames}} {
+			{{- if .IsEmbedded}}
+			var result {{$.Name}}{{$.TypeParamNames}}
+			result.{{.Name}} = v
+			return result
+			{{- else}}
+			return {{$.Name}}{{$.TypeParamNames}}{ {{.Name}}: v }
+			{{- end}}
+		},
+		"{{$.Name}}{{$.TypeParamNames}}.{{.Name}}",
+	)
+{{- end}}
+{{- end}}
+	return {{.Name}}Prisms{{.TypeParamNames}} {
+{{- range .Fields}}
+		{{.Name}}: _prism{{.Name}},
+{{- end}}
+	}
+}
 `
 
 var (
@@ -439,7 +504,7 @@ func extractEmbeddedFields(embedType ast.Expr, fileImports map[string]string, fi
 		return results
 	}
 
-	if typeName == "" || typeIdent == nil {
+	if S.IsEmpty(typeName) || typeIdent == nil {
 		return results
 	}
 
@@ -494,6 +559,7 @@ func extractEmbeddedFields(embedType ast.Expr, fileImports map[string]string, fi
 						BaseType:     baseType,
 						IsOptional:   isOptional,
 						IsComparable: isComparable,
+						IsEmbedded:   true,
 					},
 					fieldType: field.Type,
 				})
@@ -695,7 +761,7 @@ func parseFile(filename string) ([]structInfo, string, error) {
 }
 
 // generateLensHelpers scans a directory for Go files and generates lens code
-func generateLensHelpers(dir, filename string, verbose bool) error {
+func generateLensHelpers(dir, filename string, verbose, includeTestFiles bool) error {
 	// Get absolute path
 	absDir, err := filepath.Abs(dir)
 	if err != nil {
@@ -716,21 +782,34 @@ func generateLensHelpers(dir, filename string, verbose bool) error {
 		log.Printf("Found %d Go files", len(files))
 	}
 
-	// Parse all files and collect structs
-	var allStructs []structInfo
+	// Parse all files and collect structs, separating test and non-test files
+	var regularStructs []structInfo
+	var testStructs []structInfo
 	var packageName string
 
 	for _, file := range files {
-		// Skip generated files and test files
-		if strings.HasSuffix(file, "_test.go") || strings.Contains(file, "gen.go") {
+		baseName := filepath.Base(file)
+
+		// Skip generated lens files (both regular and test)
+		if strings.HasPrefix(baseName, "gen_lens") && strings.HasSuffix(baseName, ".go") {
 			if verbose {
-				log.Printf("Skipping file: %s", filepath.Base(file))
+				log.Printf("Skipping generated lens file: %s", baseName)
+			}
+			continue
+		}
+
+		isTestFile := strings.HasSuffix(file, "_test.go")
+
+		// Skip test files unless includeTestFiles is true
+		if isTestFile && !includeTestFiles {
+			if verbose {
+				log.Printf("Skipping test file: %s", baseName)
 			}
 			continue
 		}
 
 		if verbose {
-			log.Printf("Parsing file: %s", filepath.Base(file))
+			log.Printf("Parsing file: %s", baseName)
 		}
 
 		structs, pkg, err := parseFile(file)
@@ -740,27 +819,52 @@ func generateLensHelpers(dir, filename string, verbose bool) error {
 		}
 
 		if verbose && len(structs) > 0 {
-			log.Printf("Found %d annotated struct(s) in %s", len(structs), filepath.Base(file))
+			log.Printf("Found %d annotated struct(s) in %s", len(structs), baseName)
 			for _, s := range structs {
 				log.Printf("  - %s (%d fields)", s.Name, len(s.Fields))
 			}
 		}
 
-		if packageName == "" {
+		if S.IsEmpty(packageName) {
 			packageName = pkg
 		}
 
-		allStructs = append(allStructs, structs...)
+		// Separate structs based on source file type
+		if isTestFile {
+			testStructs = append(testStructs, structs...)
+		} else {
+			regularStructs = append(regularStructs, structs...)
+		}
 	}
 
-	if len(allStructs) == 0 {
+	if len(regularStructs) == 0 && len(testStructs) == 0 {
 		log.Printf("No structs with %s annotation found in %s", lensAnnotation, absDir)
 		return nil
 	}
 
+	// Generate regular lens file if there are regular structs
+	if len(regularStructs) > 0 {
+		if err := generateLensFile(absDir, filename, packageName, regularStructs, verbose); err != nil {
+			return err
+		}
+	}
+
+	// Generate test lens file if there are test structs
+	if len(testStructs) > 0 {
+		testFilename := strings.TrimSuffix(filename, ".go") + "_test.go"
+		if err := generateLensFile(absDir, testFilename, packageName, testStructs, verbose); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// generateLensFile generates a lens file for the given structs
+func generateLensFile(absDir, filename, packageName string, structs []structInfo, verbose bool) error {
 	// Collect all unique imports from all structs
 	allImports := make(map[string]string) // import path -> alias
-	for _, s := range allStructs {
+	for _, s := range structs {
 		for importPath, alias := range s.Imports {
 			allImports[importPath] = alias
 		}
@@ -774,7 +878,7 @@ func generateLensHelpers(dir, filename string, verbose bool) error {
 	}
 	defer f.Close()
 
-	log.Printf("Generating lens code in [%s] for package [%s] with [%d] structs ...", outPath, packageName, len(allStructs))
+	log.Printf("Generating lens code in [%s] for package [%s] with [%d] structs ...", outPath, packageName, len(structs))
 
 	// Write header
 	writePackage(f, packageName)
@@ -782,10 +886,11 @@ func generateLensHelpers(dir, filename string, verbose bool) error {
 	// Write imports
 	f.WriteString("import (\n")
 	// Standard fp-go imports always needed
-	f.WriteString("\tL \"github.com/IBM/fp-go/v2/optics/lens\"\n")
-	f.WriteString("\tLO \"github.com/IBM/fp-go/v2/optics/lens/option\"\n")
-	//	f.WriteString("\tO \"github.com/IBM/fp-go/v2/option\"\n")
-	f.WriteString("\tIO \"github.com/IBM/fp-go/v2/optics/iso/option\"\n")
+	f.WriteString("\t__lens \"github.com/IBM/fp-go/v2/optics/lens\"\n")
+	f.WriteString("\t__option \"github.com/IBM/fp-go/v2/option\"\n")
+	f.WriteString("\t__prism \"github.com/IBM/fp-go/v2/optics/prism\"\n")
+	f.WriteString("\t__lens_option \"github.com/IBM/fp-go/v2/optics/lens/option\"\n")
+	f.WriteString("\t__iso_option \"github.com/IBM/fp-go/v2/optics/iso/option\"\n")
 
 	// Add additional imports collected from field types
 	for importPath, alias := range allImports {
@@ -795,7 +900,7 @@ func generateLensHelpers(dir, filename string, verbose bool) error {
 	f.WriteString(")\n")
 
 	// Generate lens code for each struct using templates
-	for _, s := range allStructs {
+	for _, s := range structs {
 		var buf bytes.Buffer
 
 		// Generate struct type
@@ -827,12 +932,14 @@ func LensCommand() *C.Command {
 			flagLensDir,
 			flagFilename,
 			flagVerbose,
+			flagIncludeTestFiles,
 		},
 		Action: func(ctx *C.Context) error {
 			return generateLensHelpers(
 				ctx.String(keyLensDir),
 				ctx.String(keyFilename),
 				ctx.Bool(keyVerbose),
+				ctx.Bool(keyIncludeTestFile),
 			)
 		},
 	}

v2/cli/lens_test.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 	"testing"
 
+	S "github.com/IBM/fp-go/v2/string"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -60,7 +61,7 @@ func TestHasLensAnnotation(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var doc *ast.CommentGroup
-			if tt.comment != "" {
+			if S.IsNonEmpty(tt.comment) {
 				doc = &ast.CommentGroup{
 					List: []*ast.Comment{
 						{Text: tt.comment},
@@ -289,7 +290,7 @@ func TestHasOmitEmpty(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			var tag *ast.BasicLit
-			if tt.tag != "" {
+			if S.IsNonEmpty(tt.tag) {
 				tag = &ast.BasicLit{
 					Value: tt.tag,
 				}
@@ -326,7 +327,7 @@ type Other struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -380,7 +381,7 @@ type Config struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -440,7 +441,7 @@ type TypeTest struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -514,16 +515,16 @@ func TestLensRefTemplatesWithComparable(t *testing.T) {
 	assert.Contains(t, constructorStr, "func MakeTestStructRefLenses() TestStructRefLenses")
 
 	// Name field - comparable, should use MakeLensStrict
-	assert.Contains(t, constructorStr, "lensName := L.MakeLensStrict(",
-		"comparable field Name should use MakeLensStrict in RefLenses")
+	assert.Contains(t, constructorStr, "lensName := __lens.MakeLensStrictWithName(",
+		"comparable field Name should use MakeLensStrictWithName in RefLenses")
 
 	// Age field - comparable, should use MakeLensStrict
-	assert.Contains(t, constructorStr, "lensAge := L.MakeLensStrict(",
-		"comparable field Age should use MakeLensStrict in RefLenses")
+	assert.Contains(t, constructorStr, "lensAge := __lens.MakeLensStrictWithName(",
+		"comparable field Age should use MakeLensStrictWithName in RefLenses")
 
 	// Data field - not comparable, should use MakeLensRef
-	assert.Contains(t, constructorStr, "lensData := L.MakeLensRef(",
-		"non-comparable field Data should use MakeLensRef in RefLenses")
+	assert.Contains(t, constructorStr, "lensData := __lens.MakeLensRefWithName(",
+		"non-comparable field Data should use MakeLensRefWithName in RefLenses")
 
 }
 
@@ -542,12 +543,12 @@ type TestStruct struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file exists
@@ -564,23 +565,23 @@ type TestStruct struct {
 	// Check for expected content in RefLenses
 	assert.Contains(t, contentStr, "MakeTestStructRefLenses")
 
-	// Name and Count are comparable, should use MakeLensStrict
-	assert.Contains(t, contentStr, "L.MakeLensStrict",
-		"comparable fields should use MakeLensStrict in RefLenses")
+	// Name and Count are comparable, should use MakeLensStrictWithName
+	assert.Contains(t, contentStr, "__lens.MakeLensStrictWithName",
+		"comparable fields should use MakeLensStrictWithName in RefLenses")
 
-	// Data is not comparable (slice), should use MakeLensRef
-	assert.Contains(t, contentStr, "L.MakeLensRef",
-		"non-comparable fields should use MakeLensRef in RefLenses")
+	// Data is not comparable (slice), should use MakeLensRefWithName
+	assert.Contains(t, contentStr, "__lens.MakeLensRefWithName",
+		"non-comparable fields should use MakeLensRefWithName in RefLenses")
 
 	// Verify the pattern appears for Name field (comparable)
-	namePattern := "lensName := L.MakeLensStrict("
+	namePattern := "lensName := __lens.MakeLensStrictWithName("
 	assert.Contains(t, contentStr, namePattern,
-		"Name field should use MakeLensStrict")
+		"Name field should use MakeLensStrictWithName")
 
 	// Verify the pattern appears for Data field (not comparable)
-	dataPattern := "lensData := L.MakeLensRef("
+	dataPattern := "lensData := __lens.MakeLensRefWithName("
 	assert.Contains(t, contentStr, dataPattern,
-		"Data field should use MakeLensRef")
+		"Data field should use MakeLensRefWithName")
 }
 
 func TestGenerateLensHelpers(t *testing.T) {
@@ -597,12 +598,12 @@ type TestStruct struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file exists
@@ -621,9 +622,9 @@ type TestStruct struct {
 	assert.Contains(t, contentStr, "Code generated by go generate")
 	assert.Contains(t, contentStr, "TestStructLenses")
 	assert.Contains(t, contentStr, "MakeTestStructLenses")
-	assert.Contains(t, contentStr, "L.Lens[TestStruct, string]")
-	assert.Contains(t, contentStr, "LO.LensO[TestStruct, *int]")
-	assert.Contains(t, contentStr, "IO.FromZero")
+	assert.Contains(t, contentStr, "__lens.Lens[TestStruct, string]")
+	assert.Contains(t, contentStr, "__lens_option.LensO[TestStruct, *int]")
+	assert.Contains(t, contentStr, "__iso_option.FromZero")
 }
 
 func TestGenerateLensHelpersNoAnnotations(t *testing.T) {
@@ -639,12 +640,12 @@ type TestStruct struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code (should not create file)
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file does not exist
@@ -669,10 +670,10 @@ func TestLensTemplates(t *testing.T) {
 
 	structStr := structBuf.String()
 	assert.Contains(t, structStr, "type TestStructLenses struct")
-	assert.Contains(t, structStr, "Name L.Lens[TestStruct, string]")
-	assert.Contains(t, structStr, "NameO LO.LensO[TestStruct, string]")
-	assert.Contains(t, structStr, "Value L.Lens[TestStruct, *int]")
-	assert.Contains(t, structStr, "ValueO LO.LensO[TestStruct, *int]")
+	assert.Contains(t, structStr, "Name __lens.Lens[TestStruct, string]")
+	assert.Contains(t, structStr, "NameO __lens_option.LensO[TestStruct, string]")
+	assert.Contains(t, structStr, "Value __lens.Lens[TestStruct, *int]")
+	assert.Contains(t, structStr, "ValueO __lens_option.LensO[TestStruct, *int]")
 
 	// Test constructor template
 	var constructorBuf bytes.Buffer
@@ -686,7 +687,7 @@ func TestLensTemplates(t *testing.T) {
 	assert.Contains(t, constructorStr, "NameO: lensNameO,")
 	assert.Contains(t, constructorStr, "Value: lensValue,")
 	assert.Contains(t, constructorStr, "ValueO: lensValueO,")
-	assert.Contains(t, constructorStr, "IO.FromZero")
+	assert.Contains(t, constructorStr, "__iso_option.FromZero")
 }
 
 func TestLensTemplatesWithOmitEmpty(t *testing.T) {
@@ -707,14 +708,14 @@ func TestLensTemplatesWithOmitEmpty(t *testing.T) {
 
 	structStr := structBuf.String()
 	assert.Contains(t, structStr, "type ConfigStructLenses struct")
-	assert.Contains(t, structStr, "Name L.Lens[ConfigStruct, string]")
-	assert.Contains(t, structStr, "NameO LO.LensO[ConfigStruct, string]")
-	assert.Contains(t, structStr, "Value L.Lens[ConfigStruct, string]")
-	assert.Contains(t, structStr, "ValueO LO.LensO[ConfigStruct, string]", "comparable non-pointer with omitempty should have optional lens")
-	assert.Contains(t, structStr, "Count L.Lens[ConfigStruct, int]")
-	assert.Contains(t, structStr, "CountO LO.LensO[ConfigStruct, int]", "comparable non-pointer with omitempty should have optional lens")
-	assert.Contains(t, structStr, "Pointer L.Lens[ConfigStruct, *string]")
-	assert.Contains(t, structStr, "PointerO LO.LensO[ConfigStruct, *string]")
+	assert.Contains(t, structStr, "Name __lens.Lens[ConfigStruct, string]")
+	assert.Contains(t, structStr, "NameO __lens_option.LensO[ConfigStruct, string]")
+	assert.Contains(t, structStr, "Value __lens.Lens[ConfigStruct, string]")
+	assert.Contains(t, structStr, "ValueO __lens_option.LensO[ConfigStruct, string]", "comparable non-pointer with omitempty should have optional lens")
+	assert.Contains(t, structStr, "Count __lens.Lens[ConfigStruct, int]")
+	assert.Contains(t, structStr, "CountO __lens_option.LensO[ConfigStruct, int]", "comparable non-pointer with omitempty should have optional lens")
+	assert.Contains(t, structStr, "Pointer __lens.Lens[ConfigStruct, *string]")
+	assert.Contains(t, structStr, "PointerO __lens_option.LensO[ConfigStruct, *string]")
 
 	// Test constructor template
 	var constructorBuf bytes.Buffer
@@ -723,9 +724,9 @@ func TestLensTemplatesWithOmitEmpty(t *testing.T) {
 
 	constructorStr := constructorBuf.String()
 	assert.Contains(t, constructorStr, "func MakeConfigStructLenses() ConfigStructLenses")
-	assert.Contains(t, constructorStr, "IO.FromZero[string]()")
-	assert.Contains(t, constructorStr, "IO.FromZero[int]()")
-	assert.Contains(t, constructorStr, "IO.FromZero[*string]()")
+	assert.Contains(t, constructorStr, "__iso_option.FromZero[string]()")
+	assert.Contains(t, constructorStr, "__iso_option.FromZero[int]()")
+	assert.Contains(t, constructorStr, "__iso_option.FromZero[*string]()")
 }
 
 func TestLensCommandFlags(t *testing.T) {
@@ -737,9 +738,9 @@ func TestLensCommandFlags(t *testing.T) {
 	assert.Contains(t, strings.ToLower(cmd.Description), "lenso", "Description should mention LensO for optional lenses")
 
 	// Check flags
-	assert.Len(t, cmd.Flags, 3)
+	assert.Len(t, cmd.Flags, 4)
 
-	var hasDir, hasFilename, hasVerbose bool
+	var hasDir, hasFilename, hasVerbose, hasIncludeTestFiles bool
 	for _, flag := range cmd.Flags {
 		switch flag.Names()[0] {
 		case "dir":
@@ -748,12 +749,15 @@ func TestLensCommandFlags(t *testing.T) {
 			hasFilename = true
 		case "verbose":
 			hasVerbose = true
+		case "include-test-files":
+			hasIncludeTestFiles = true
 		}
 	}
 
 	assert.True(t, hasDir, "should have dir flag")
 	assert.True(t, hasFilename, "should have filename flag")
 	assert.True(t, hasVerbose, "should have verbose flag")
+	assert.True(t, hasIncludeTestFiles, "should have include-test-files flag")
 }
 
 func TestParseFileWithEmbeddedStruct(t *testing.T) {
@@ -776,7 +780,7 @@ type Extended struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -824,12 +828,12 @@ type Person struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file exists
@@ -849,14 +853,14 @@ type Person struct {
 	assert.Contains(t, contentStr, "MakePersonLenses")
 
 	// Check that embedded fields are included
-	assert.Contains(t, contentStr, "Street L.Lens[Person, string]", "Should have lens for embedded Street field")
-	assert.Contains(t, contentStr, "City L.Lens[Person, string]", "Should have lens for embedded City field")
-	assert.Contains(t, contentStr, "Name L.Lens[Person, string]", "Should have lens for Name field")
-	assert.Contains(t, contentStr, "Age L.Lens[Person, int]", "Should have lens for Age field")
+	assert.Contains(t, contentStr, "Street __lens.Lens[Person, string]", "Should have lens for embedded Street field")
+	assert.Contains(t, contentStr, "City __lens.Lens[Person, string]", "Should have lens for embedded City field")
+	assert.Contains(t, contentStr, "Name __lens.Lens[Person, string]", "Should have lens for Name field")
+	assert.Contains(t, contentStr, "Age __lens.Lens[Person, int]", "Should have lens for Age field")
 
 	// Check that optional lenses are also generated for embedded fields
-	assert.Contains(t, contentStr, "StreetO LO.LensO[Person, string]")
-	assert.Contains(t, contentStr, "CityO LO.LensO[Person, string]")
+	assert.Contains(t, contentStr, "StreetO __lens_option.LensO[Person, string]")
+	assert.Contains(t, contentStr, "CityO __lens_option.LensO[Person, string]")
 }
 
 func TestParseFileWithPointerEmbeddedStruct(t *testing.T) {
@@ -880,7 +884,7 @@ type Document struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -922,7 +926,7 @@ type Container[T any] struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -960,7 +964,7 @@ type Pair[K comparable, V any] struct {
 }
 `
 
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Parse the file
@@ -998,12 +1002,12 @@ type Box[T any] struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file exists
@@ -1025,14 +1029,14 @@ type Box[T any] struct {
 	assert.Contains(t, contentStr, "func MakeBoxRefLenses[T any]() BoxRefLenses[T]", "Should have generic ref constructor")
 
 	// Check that fields use the generic type parameter
-	assert.Contains(t, contentStr, "Content L.Lens[Box[T], T]", "Should have lens for generic Content field")
-	assert.Contains(t, contentStr, "Label L.Lens[Box[T], string]", "Should have lens for Label field")
+	assert.Contains(t, contentStr, "Content __lens.Lens[Box[T], T]", "Should have lens for generic Content field")
+	assert.Contains(t, contentStr, "Label __lens.Lens[Box[T], string]", "Should have lens for Label field")
 
 	// Check optional lenses - only for comparable types
 	// T any is not comparable, so ContentO should NOT be generated
-	assert.NotContains(t, contentStr, "ContentO LO.LensO[Box[T], T]", "T any is not comparable, should not have optional lens")
+	assert.NotContains(t, contentStr, "ContentO __lens_option.LensO[Box[T], T]", "T any is not comparable, should not have optional lens")
 	// string is comparable, so LabelO should be generated
-	assert.Contains(t, contentStr, "LabelO LO.LensO[Box[T], string]", "string is comparable, should have optional lens")
+	assert.Contains(t, contentStr, "LabelO __lens_option.LensO[Box[T], string]", "string is comparable, should have optional lens")
 }
 
 func TestGenerateLensHelpersWithComparableTypeParam(t *testing.T) {
@@ -1049,12 +1053,12 @@ type ComparableBox[T comparable] struct {
 `
 
 	testFile := filepath.Join(tmpDir, "test.go")
-	err := os.WriteFile(testFile, []byte(testCode), 0644)
+	err := os.WriteFile(testFile, []byte(testCode), 0o644)
 	require.NoError(t, err)
 
 	// Generate lens code
 	outputFile := "gen.go"
-	err = generateLensHelpers(tmpDir, outputFile, false)
+	err = generateLensHelpers(tmpDir, outputFile, false, false)
 	require.NoError(t, err)
 
 	// Verify the generated file exists
@@ -1074,11 +1078,11 @@ type ComparableBox[T comparable] struct {
 	assert.Contains(t, contentStr, "type ComparableBoxRefLenses[T comparable] struct", "Should have generic ComparableBoxRefLenses type")
 
 	// Check that Key field (with comparable constraint) uses MakeLensStrict in RefLenses
-	assert.Contains(t, contentStr, "lensKey := L.MakeLensStrict(", "Key field with comparable constraint should use MakeLensStrict")
+	assert.Contains(t, contentStr, "lensKey := __lens.MakeLensStrictWithName(", "Key field with comparable constraint should use MakeLensStrictWithName")
 
 	// Check that Value field (string, always comparable) also uses MakeLensStrict
-	assert.Contains(t, contentStr, "lensValue := L.MakeLensStrict(", "Value field (string) should use MakeLensStrict")
+	assert.Contains(t, contentStr, "lensValue := __lens.MakeLensStrictWithName(", "Value field (string) should use MakeLensStrictWithName")
 
 	// Verify that MakeLensRef is NOT used (since both fields are comparable)
-	assert.NotContains(t, contentStr, "L.MakeLensRef(", "Should not use MakeLensRef when all fields are comparable")
+	assert.NotContains(t, contentStr, "__lens.MakeLensRefWithName(", "Should not use MakeLensRefWithName when all fields are comparable")
 }

v2/cli/monad.go

@@ -19,6 +19,8 @@ import (
 	"fmt"
 	"os"
 	"strings"
+
+	S "github.com/IBM/fp-go/v2/string"
 )
 
 // Deprecated:
@@ -176,7 +178,7 @@ func generateTraverseTuple1(
 			}
 			fmt.Fprintf(f, "F%d ~func(A%d) %s", j+1, j+1, hkt(fmt.Sprintf("T%d", j+1)))
 		}
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, ", %s", infix)
 		}
 		// types
@@ -209,7 +211,7 @@ func generateTraverseTuple1(
 		fmt.Fprintf(f, "    return A.TraverseTuple%d(\n", i)
 		// map
 		fmt.Fprintf(f, "      Map[")
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, "%s, T1,", infix)
 		} else {
 			fmt.Fprintf(f, "T1,")
@@ -231,7 +233,7 @@ func generateTraverseTuple1(
 				fmt.Fprintf(f, " ")
 			}
 			fmt.Fprintf(f, "%s", tuple)
-			if infix != "" {
+			if S.IsNonEmpty(infix) {
 				fmt.Fprintf(f, ", %s", infix)
 			}
 			fmt.Fprintf(f, ", T%d],\n", j+1)
@@ -256,11 +258,11 @@ func generateSequenceTuple1(
 
 		fmt.Fprintf(f, "\n// SequenceTuple%d converts a [Tuple%d] of [%s] into an [%s].\n", i, i, hkt("T"), hkt(fmt.Sprintf("Tuple%d", i)))
 		fmt.Fprintf(f, "func SequenceTuple%d[", i)
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, "%s", infix)
 		}
 		for j := 0; j < i; j++ {
-			if infix != "" || j > 0 {
+			if S.IsNonEmpty(infix) || j > 0 {
 				fmt.Fprintf(f, ", ")
 			}
 			fmt.Fprintf(f, "T%d", j+1)
@@ -276,7 +278,7 @@ func generateSequenceTuple1(
 		fmt.Fprintf(f, "  return A.SequenceTuple%d(\n", i)
 		// map
 		fmt.Fprintf(f, "    Map[")
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, "%s, T1,", infix)
 		} else {
 			fmt.Fprintf(f, "T1,")
@@ -298,7 +300,7 @@ func generateSequenceTuple1(
 				fmt.Fprintf(f, " ")
 			}
 			fmt.Fprintf(f, "%s", tuple)
-			if infix != "" {
+			if S.IsNonEmpty(infix) {
 				fmt.Fprintf(f, ", %s", infix)
 			}
 			fmt.Fprintf(f, ", T%d],\n", j+1)
@@ -319,11 +321,11 @@ func generateSequenceT1(
 
 		fmt.Fprintf(f, "\n// SequenceT%d converts %d parameters of [%s] into a [%s].\n", i, i, hkt("T"), hkt(fmt.Sprintf("Tuple%d", i)))
 		fmt.Fprintf(f, "func SequenceT%d[", i)
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, "%s", infix)
 		}
 		for j := 0; j < i; j++ {
-			if infix != "" || j > 0 {
+			if S.IsNonEmpty(infix) || j > 0 {
 				fmt.Fprintf(f, ", ")
 			}
 			fmt.Fprintf(f, "T%d", j+1)
@@ -339,7 +341,7 @@ func generateSequenceT1(
 		fmt.Fprintf(f, "  return A.SequenceT%d(\n", i)
 		// map
 		fmt.Fprintf(f, "    Map[")
-		if infix != "" {
+		if S.IsNonEmpty(infix) {
 			fmt.Fprintf(f, "%s, T1,", infix)
 		} else {
 			fmt.Fprintf(f, "T1,")
@@ -361,7 +363,7 @@ func generateSequenceT1(
 				fmt.Fprintf(f, " ")
 			}
 			fmt.Fprintf(f, "%s", tuple)
-			if infix != "" {
+			if S.IsNonEmpty(infix) {
 				fmt.Fprintf(f, ", %s", infix)
 			}
 			fmt.Fprintf(f, ", T%d],\n", j+1)

v2/consumer/consumer.go

@@ -0,0 +1,177 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package consumer
+
+// Local transforms a Consumer by preprocessing its input through a function.
+// This is the contravariant map operation for Consumers, analogous to reader.Local
+// but operating on the input side rather than the output side.
+//
+// Given a Consumer[R1] that consumes values of type R1, and a function f that
+// converts R2 to R1, Local creates a new Consumer[R2] that:
+//   1. Takes a value of type R2
+//   2. Applies f to convert it to R1
+//   3. Passes the result to the original Consumer[R1]
+//
+// This is particularly useful for adapting consumers to work with different input types,
+// similar to how reader.Local adapts readers to work with different environment types.
+//
+// Comparison with reader.Local:
+//   - reader.Local: Transforms the environment BEFORE passing it to a Reader (preprocessing input)
+//   - consumer.Local: Transforms the value BEFORE passing it to a Consumer (preprocessing input)
+//   - Both are contravariant operations on the input type
+//   - Reader produces output, Consumer performs side effects
+//
+// Type Parameters:
+//   - R2: The input type of the new Consumer (what you have)
+//   - R1: The input type of the original Consumer (what it expects)
+//
+// Parameters:
+//   - f: A function that converts R2 to R1 (preprocessing function)
+//
+// Returns:
+//   - An Operator that transforms Consumer[R1] into Consumer[R2]
+//
+// Example - Basic type adaptation:
+//
+//	// Consumer that logs integers
+//	logInt := func(x int) {
+//	    fmt.Printf("Value: %d\n", x)
+//	}
+//
+//	// Adapt it to consume strings by parsing them first
+//	parseToInt := func(s string) int {
+//	    n, _ := strconv.Atoi(s)
+//	    return n
+//	}
+//
+//	logString := consumer.Local(parseToInt)(logInt)
+//	logString("42") // Logs: "Value: 42"
+//
+// Example - Extracting fields from structs:
+//
+//	type User struct {
+//	    Name string
+//	    Age  int
+//	}
+//
+//	// Consumer that logs names
+//	logName := func(name string) {
+//	    fmt.Printf("Name: %s\n", name)
+//	}
+//
+//	// Adapt it to consume User structs
+//	extractName := func(u User) string {
+//	    return u.Name
+//	}
+//
+//	logUser := consumer.Local(extractName)(logName)
+//	logUser(User{Name: "Alice", Age: 30}) // Logs: "Name: Alice"
+//
+// Example - Simplifying complex types:
+//
+//	type DetailedConfig struct {
+//	    Host     string
+//	    Port     int
+//	    Timeout  time.Duration
+//	    MaxRetry int
+//	}
+//
+//	type SimpleConfig struct {
+//	    Host string
+//	    Port int
+//	}
+//
+//	// Consumer that logs simple configs
+//	logSimple := func(c SimpleConfig) {
+//	    fmt.Printf("Server: %s:%d\n", c.Host, c.Port)
+//	}
+//
+//	// Adapt it to consume detailed configs
+//	simplify := func(d DetailedConfig) SimpleConfig {
+//	    return SimpleConfig{Host: d.Host, Port: d.Port}
+//	}
+//
+//	logDetailed := consumer.Local(simplify)(logSimple)
+//	logDetailed(DetailedConfig{
+//	    Host:     "localhost",
+//	    Port:     8080,
+//	    Timeout:  time.Second,
+//	    MaxRetry: 3,
+//	}) // Logs: "Server: localhost:8080"
+//
+// Example - Composing multiple transformations:
+//
+//	type Response struct {
+//	    StatusCode int
+//	    Body       string
+//	}
+//
+//	// Consumer that logs status codes
+//	logStatus := func(code int) {
+//	    fmt.Printf("Status: %d\n", code)
+//	}
+//
+//	// Extract status code from response
+//	getStatus := func(r Response) int {
+//	    return r.StatusCode
+//	}
+//
+//	// Adapt to consume responses
+//	logResponse := consumer.Local(getStatus)(logStatus)
+//	logResponse(Response{StatusCode: 200, Body: "OK"}) // Logs: "Status: 200"
+//
+// Example - Using with multiple consumers:
+//
+//	type Event struct {
+//	    Type      string
+//	    Timestamp time.Time
+//	    Data      map[string]any
+//	}
+//
+//	// Consumers for different aspects
+//	logType := func(t string) { fmt.Printf("Type: %s\n", t) }
+//	logTime := func(t time.Time) { fmt.Printf("Time: %v\n", t) }
+//
+//	// Adapt them to consume events
+//	logEventType := consumer.Local(func(e Event) string { return e.Type })(logType)
+//	logEventTime := consumer.Local(func(e Event) time.Time { return e.Timestamp })(logTime)
+//
+//	event := Event{Type: "UserLogin", Timestamp: time.Now(), Data: nil}
+//	logEventType(event) // Logs: "Type: UserLogin"
+//	logEventTime(event) // Logs: "Time: ..."
+//
+// Use Cases:
+//   - Type adaptation: Convert between different input types
+//   - Field extraction: Extract specific fields from complex structures
+//   - Data transformation: Preprocess data before consumption
+//   - Interface adaptation: Adapt consumers to work with different interfaces
+//   - Logging pipelines: Transform data before logging
+//   - Event handling: Extract relevant data from events before processing
+//
+// Relationship to Reader:
+// Consumer is the dual of Reader in category theory:
+//   - Reader[R, A] = R -> A (produces output from environment)
+//   - Consumer[A] = A -> () (consumes input, produces side effects)
+//   - reader.Local transforms the environment before reading
+//   - consumer.Local transforms the input before consuming
+//   - Both are contravariant functors on their input type
+func Local[R2, R1 any](f func(R2) R1) Operator[R1, R2] {
+	return func(c Consumer[R1]) Consumer[R2] {
+		return func(r2 R2) {
+			c(f(r2))
+		}
+	}
+}

v2/consumer/consumer_test.go

@@ -0,0 +1,383 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package consumer
+
+import (
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLocal(t *testing.T) {
+	t.Run("basic type transformation", func(t *testing.T) {
+		var captured int
+		consumeInt := func(x int) {
+			captured = x
+		}
+
+		// Transform string to int before consuming
+		stringToInt := func(s string) int {
+			n, _ := strconv.Atoi(s)
+			return n
+		}
+
+		consumeString := Local(stringToInt)(consumeInt)
+		consumeString("42")
+
+		assert.Equal(t, 42, captured)
+	})
+
+	t.Run("field extraction from struct", func(t *testing.T) {
+		type User struct {
+			Name string
+			Age  int
+		}
+
+		var capturedName string
+		consumeName := func(name string) {
+			capturedName = name
+		}
+
+		extractName := func(u User) string {
+			return u.Name
+		}
+
+		consumeUser := Local(extractName)(consumeName)
+		consumeUser(User{Name: "Alice", Age: 30})
+
+		assert.Equal(t, "Alice", capturedName)
+	})
+
+	t.Run("simplifying complex types", func(t *testing.T) {
+		type DetailedConfig struct {
+			Host     string
+			Port     int
+			Timeout  time.Duration
+			MaxRetry int
+		}
+
+		type SimpleConfig struct {
+			Host string
+			Port int
+		}
+
+		var captured SimpleConfig
+		consumeSimple := func(c SimpleConfig) {
+			captured = c
+		}
+
+		simplify := func(d DetailedConfig) SimpleConfig {
+			return SimpleConfig{Host: d.Host, Port: d.Port}
+		}
+
+		consumeDetailed := Local(simplify)(consumeSimple)
+		consumeDetailed(DetailedConfig{
+			Host:     "localhost",
+			Port:     8080,
+			Timeout:  time.Second,
+			MaxRetry: 3,
+		})
+
+		assert.Equal(t, SimpleConfig{Host: "localhost", Port: 8080}, captured)
+	})
+
+	t.Run("multiple transformations", func(t *testing.T) {
+		type Response struct {
+			StatusCode int
+			Body       string
+		}
+
+		var capturedStatus int
+		consumeStatus := func(code int) {
+			capturedStatus = code
+		}
+
+		getStatus := func(r Response) int {
+			return r.StatusCode
+		}
+
+		consumeResponse := Local(getStatus)(consumeStatus)
+		consumeResponse(Response{StatusCode: 200, Body: "OK"})
+
+		assert.Equal(t, 200, capturedStatus)
+	})
+
+	t.Run("chaining Local transformations", func(t *testing.T) {
+		type Level3 struct{ Value int }
+		type Level2 struct{ L3 Level3 }
+		type Level1 struct{ L2 Level2 }
+
+		var captured int
+		consumeInt := func(x int) {
+			captured = x
+		}
+
+		// Chain multiple Local transformations
+		extract3 := func(l3 Level3) int { return l3.Value }
+		extract2 := func(l2 Level2) Level3 { return l2.L3 }
+		extract1 := func(l1 Level1) Level2 { return l1.L2 }
+
+		// Compose the transformations
+		consumeLevel3 := Local(extract3)(consumeInt)
+		consumeLevel2 := Local(extract2)(consumeLevel3)
+		consumeLevel1 := Local(extract1)(consumeLevel2)
+
+		consumeLevel1(Level1{L2: Level2{L3: Level3{Value: 42}}})
+
+		assert.Equal(t, 42, captured)
+	})
+
+	t.Run("identity transformation", func(t *testing.T) {
+		var captured string
+		consumeString := func(s string) {
+			captured = s
+		}
+
+		identity := function.Identity[string]
+
+		consumeIdentity := Local(identity)(consumeString)
+		consumeIdentity("test")
+
+		assert.Equal(t, "test", captured)
+	})
+
+	t.Run("transformation with calculation", func(t *testing.T) {
+		type Rectangle struct {
+			Width  int
+			Height int
+		}
+
+		var capturedArea int
+		consumeArea := func(area int) {
+			capturedArea = area
+		}
+
+		calculateArea := func(r Rectangle) int {
+			return r.Width * r.Height
+		}
+
+		consumeRectangle := Local(calculateArea)(consumeArea)
+		consumeRectangle(Rectangle{Width: 5, Height: 10})
+
+		assert.Equal(t, 50, capturedArea)
+	})
+
+	t.Run("multiple consumers with same transformation", func(t *testing.T) {
+		type Event struct {
+			Type      string
+			Timestamp time.Time
+		}
+
+		var capturedType string
+		var capturedTime time.Time
+
+		consumeType := func(t string) {
+			capturedType = t
+		}
+
+		consumeTime := func(t time.Time) {
+			capturedTime = t
+		}
+
+		extractType := func(e Event) string { return e.Type }
+		extractTime := func(e Event) time.Time { return e.Timestamp }
+
+		consumeEventType := Local(extractType)(consumeType)
+		consumeEventTime := Local(extractTime)(consumeTime)
+
+		now := time.Now()
+		event := Event{Type: "UserLogin", Timestamp: now}
+
+		consumeEventType(event)
+		consumeEventTime(event)
+
+		assert.Equal(t, "UserLogin", capturedType)
+		assert.Equal(t, now, capturedTime)
+	})
+
+	t.Run("transformation with slice", func(t *testing.T) {
+		var captured int
+		consumeLength := func(n int) {
+			captured = n
+		}
+
+		getLength := func(s []string) int {
+			return len(s)
+		}
+
+		consumeSlice := Local(getLength)(consumeLength)
+		consumeSlice([]string{"a", "b", "c"})
+
+		assert.Equal(t, 3, captured)
+	})
+
+	t.Run("transformation with map", func(t *testing.T) {
+		var captured int
+		consumeCount := func(n int) {
+			captured = n
+		}
+
+		getCount := func(m map[string]int) int {
+			return len(m)
+		}
+
+		consumeMap := Local(getCount)(consumeCount)
+		consumeMap(map[string]int{"a": 1, "b": 2, "c": 3})
+
+		assert.Equal(t, 3, captured)
+	})
+
+	t.Run("transformation with pointer", func(t *testing.T) {
+		var captured int
+		consumeInt := func(x int) {
+			captured = x
+		}
+
+		dereference := func(p *int) int {
+			if p == nil {
+				return 0
+			}
+			return *p
+		}
+
+		consumePointer := Local(dereference)(consumeInt)
+
+		value := 42
+		consumePointer(&value)
+		assert.Equal(t, 42, captured)
+
+		consumePointer(nil)
+		assert.Equal(t, 0, captured)
+	})
+
+	t.Run("transformation with custom type", func(t *testing.T) {
+		type MyType struct {
+			Value string
+		}
+
+		var captured string
+		consumeString := func(s string) {
+			captured = s
+		}
+
+		extractValue := func(m MyType) string {
+			return m.Value
+		}
+
+		consumeMyType := Local(extractValue)(consumeString)
+		consumeMyType(MyType{Value: "test"})
+
+		assert.Equal(t, "test", captured)
+	})
+
+	t.Run("accumulation through multiple calls", func(t *testing.T) {
+		var sum int
+		accumulate := func(x int) {
+			sum += x
+		}
+
+		double := func(x int) int {
+			return x * 2
+		}
+
+		accumulateDoubled := Local(double)(accumulate)
+
+		accumulateDoubled(1)
+		accumulateDoubled(2)
+		accumulateDoubled(3)
+
+		assert.Equal(t, 12, sum) // (1*2) + (2*2) + (3*2) = 2 + 4 + 6 = 12
+	})
+
+	t.Run("transformation with error handling", func(t *testing.T) {
+		type Result struct {
+			Value int
+			Error error
+		}
+
+		var captured int
+		consumeInt := func(x int) {
+			captured = x
+		}
+
+		extractValue := func(r Result) int {
+			if r.Error != nil {
+				return -1
+			}
+			return r.Value
+		}
+
+		consumeResult := Local(extractValue)(consumeInt)
+
+		consumeResult(Result{Value: 42, Error: nil})
+		assert.Equal(t, 42, captured)
+
+		consumeResult(Result{Value: 100, Error: assert.AnError})
+		assert.Equal(t, -1, captured)
+	})
+
+	t.Run("transformation preserves consumer behavior", func(t *testing.T) {
+		callCount := 0
+		consumer := func(x int) {
+			callCount++
+		}
+
+		transform := func(s string) int {
+			n, _ := strconv.Atoi(s)
+			return n
+		}
+
+		transformedConsumer := Local(transform)(consumer)
+
+		transformedConsumer("1")
+		transformedConsumer("2")
+		transformedConsumer("3")
+
+		assert.Equal(t, 3, callCount)
+	})
+
+	t.Run("comparison with reader.Local behavior", func(t *testing.T) {
+		// This test demonstrates the dual nature of Consumer and Reader
+		// Consumer: transforms input before consumption (contravariant)
+		// Reader: transforms environment before reading (also contravariant on input)
+
+		type DetailedEnv struct {
+			Value int
+			Extra string
+		}
+
+		type SimpleEnv struct {
+			Value int
+		}
+
+		var captured int
+		consumeSimple := func(e SimpleEnv) {
+			captured = e.Value
+		}
+
+		simplify := func(d DetailedEnv) SimpleEnv {
+			return SimpleEnv{Value: d.Value}
+		}
+
+		consumeDetailed := Local(simplify)(consumeSimple)
+		consumeDetailed(DetailedEnv{Value: 42, Extra: "ignored"})
+
+		assert.Equal(t, 42, captured)
+	})
+}

v2/consumer/types.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package consumer provides types and utilities for functions that consume values without returning results.
+//
+// A Consumer represents a side-effecting operation that accepts a value but produces no output.
+// This is useful for operations like logging, printing, updating state, or any action where
+// the return value is not needed.
+package consumer
+
+type (
+	// Consumer represents a function that accepts a value of type A and performs a side effect.
+	// It does not return any value, making it useful for operations where only the side effect matters,
+	// such as logging, printing, or updating external state.
+	//
+	// This is a fundamental concept in functional programming for handling side effects in a
+	// controlled manner. Consumers can be composed, chained, or used in higher-order functions
+	// to build complex side-effecting behaviors.
+	//
+	// Type Parameters:
+	//   - A: The type of value consumed by the function
+	//
+	// Example:
+	//
+	//	// A simple consumer that prints values
+	//	var printInt Consumer[int] = func(x int) {
+	//	    fmt.Println(x)
+	//	}
+	//	printInt(42) // Prints: 42
+	//
+	//	// A consumer that logs messages
+	//	var logger Consumer[string] = func(msg string) {
+	//	    log.Println(msg)
+	//	}
+	//	logger("Hello, World!") // Logs: Hello, World!
+	//
+	//	// Consumers can be used in functional pipelines
+	//	var saveToDatabase Consumer[User] = func(user User) {
+	//	    db.Save(user)
+	//	}
+	Consumer[A any] = func(A)
+
+	// Operator represents a function that transforms a Consumer[A] into a Consumer[B].
+	// This is useful for composing and adapting consumers to work with different types.
+	Operator[A, B any] = func(Consumer[A]) Consumer[B]
+)

v2/context/ioresult/ioeither.go

@@ -21,11 +21,38 @@ import (
 	"github.com/IBM/fp-go/v2/result"
 )
 
-// withContext wraps an existing IOEither and performs a context check for cancellation before delegating
+// WithContext wraps an IOResult and performs a context check for cancellation before executing.
+// This ensures that if the context is already cancelled, the computation short-circuits immediately
+// without executing the wrapped computation.
+//
+// This is useful for adding cancellation awareness to computations that might not check the context themselves.
+//
+// Type Parameters:
+//   - A: The type of the success value
+//
+// Parameters:
+//   - ctx: The context to check for cancellation
+//   - ma: The IOResult to wrap with context checking
+//
+// Returns:
+//   - An IOResult that checks for cancellation before executing
+//
+// Example:
+//
+//	computation := func() Result[string] {
+//	    // Long-running operation
+//	    return result.Of("done")
+//	}
+//
+//	ctx, cancel := context.WithCancel(context.Background())
+//	cancel() // Cancel immediately
+//
+//	wrapped := WithContext(ctx, computation)
+//	result := wrapped() // Returns Left with context.Canceled error
 func WithContext[A any](ctx context.Context, ma IOResult[A]) IOResult[A] {
 	return func() Result[A] {
-		if err := context.Cause(ctx); err != nil {
-			return result.Left[A](err)
+		if ctx.Err() != nil {
+			return result.Left[A](context.Cause(ctx))
 		}
 		return ma()
 	}

v2/context/ioresult/types.go

@@ -6,6 +6,11 @@ import (
 )
 
 type (
+	// IOResult represents a synchronous computation that may fail with an error.
+	// It's an alias for ioresult.IOResult[T].
 	IOResult[T any] = ioresult.IOResult[T]
-	Result[T any]   = result.Result[T]
+
+	// Result represents a computation that may fail with an error.
+	// It's an alias for result.Result[T].
+	Result[T any] = result.Result[T]
 )

v2/context/readerio/bracket.go

@@ -0,0 +1,75 @@
+package readerio
+
+import (
+	RIO "github.com/IBM/fp-go/v2/readerio"
+)
+
+// Bracket ensures that a resource is properly acquired, used, and released, even if an error occurs.
+// This implements the bracket pattern for safe resource management with [ReaderIO].
+//
+// The bracket pattern guarantees that:
+//   - The acquire action is executed first to obtain the resource
+//   - The use function is called with the acquired resource
+//   - The release function is always called with the resource and result, regardless of success or failure
+//   - The final result from the use function is returned
+//
+// This is particularly useful for managing resources like file handles, database connections,
+// or locks that must be cleaned up properly.
+//
+// Type Parameters:
+//   - A: The type of the acquired resource
+//   - B: The type of the result produced by the use function
+//   - ANY: The type returned by the release function (typically ignored)
+//
+// Parameters:
+//   - acquire: A ReaderIO that acquires the resource
+//   - use: A Kleisli arrow that uses the resource and produces a result
+//   - release: A function that releases the resource, receiving both the resource and the result
+//
+// Returns:
+//   - A ReaderIO[B] that safely manages the resource lifecycle
+//
+// Example:
+//
+//	// Acquire a file handle
+//	acquireFile := func(ctx context.Context) IO[*os.File] {
+//	    return func() *os.File {
+//	        f, _ := os.Open("data.txt")
+//	        return f
+//	    }
+//	}
+//
+//	// Use the file
+//	readFile := func(f *os.File) ReaderIO[string] {
+//	    return func(ctx context.Context) IO[string] {
+//	        return func() string {
+//	            data, _ := io.ReadAll(f)
+//	            return string(data)
+//	        }
+//	    }
+//	}
+//
+//	// Release the file
+//	closeFile := func(f *os.File, result string) ReaderIO[any] {
+//	    return func(ctx context.Context) IO[any] {
+//	        return func() any {
+//	            f.Close()
+//	            return nil
+//	        }
+//	    }
+//	}
+//
+//	// Safely read file with automatic cleanup
+//	safeRead := Bracket(acquireFile, readFile, closeFile)
+//	result := safeRead(context.Background())()
+//
+//go:inline
+func Bracket[
+	A, B, ANY any](
+
+	acquire ReaderIO[A],
+	use Kleisli[A, B],
+	release func(A, B) ReaderIO[ANY],
+) ReaderIO[B] {
+	return RIO.Bracket(acquire, use, release)
+}

v2/context/readerio/consumer.go

@@ -0,0 +1,65 @@
+package readerio
+
+import "github.com/IBM/fp-go/v2/io"
+
+// ChainConsumer chains a consumer function into a ReaderIO computation, discarding the original value.
+// This is useful for performing side effects (like logging or metrics) that consume a value
+// but don't produce a meaningful result.
+//
+// The consumer is executed for its side effects, and the computation returns an empty struct.
+//
+// Type Parameters:
+//   - A: The type of value to consume
+//
+// Parameters:
+//   - c: A consumer function that performs side effects on the value
+//
+// Returns:
+//   - An Operator that chains the consumer and returns struct{}
+//
+// Example:
+//
+//	logUser := func(u User) {
+//	    log.Printf("Processing user: %s", u.Name)
+//	}
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    ChainConsumer(logUser),
+//	)
+//
+//go:inline
+func ChainConsumer[A any](c Consumer[A]) Operator[A, struct{}] {
+	return ChainIOK(io.FromConsumerK(c))
+}
+
+// ChainFirstConsumer chains a consumer function into a ReaderIO computation, preserving the original value.
+// This is useful for performing side effects (like logging or metrics) while passing the value through unchanged.
+//
+// The consumer is executed for its side effects, but the original value is returned.
+//
+// Type Parameters:
+//   - A: The type of value to consume and return
+//
+// Parameters:
+//   - c: A consumer function that performs side effects on the value
+//
+// Returns:
+//   - An Operator that chains the consumer and returns the original value
+//
+// Example:
+//
+//	logUser := func(u User) {
+//	    log.Printf("User: %s", u.Name)
+//	}
+//
+//	pipeline := F.Pipe3(
+//	    fetchUser(123),
+//	    ChainFirstConsumer(logUser),  // Logs but passes user through
+//	    Map(func(u User) string { return u.Email }),
+//	)
+//
+//go:inline
+func ChainFirstConsumer[A any](c Consumer[A]) Operator[A, A] {
+	return ChainFirstIOK(io.FromConsumerK(c))
+}

v2/context/readerio/flip.go

@@ -0,0 +1,117 @@
+package readerio
+
+import (
+	"context"
+
+	"github.com/IBM/fp-go/v2/reader"
+	RIO "github.com/IBM/fp-go/v2/readerio"
+)
+
+// SequenceReader transforms a ReaderIO containing a Reader into a Reader containing a ReaderIO.
+// This "flips" the nested structure, allowing you to provide the Reader's environment first,
+// then get a ReaderIO that can be executed with a context.
+//
+// Type transformation:
+//
+//	From: ReaderIO[Reader[R, A]]
+//	      = func(context.Context) func() func(R) A
+//
+//	To:   Reader[R, ReaderIO[A]]
+//	      = func(R) func(context.Context) func() A
+//
+// This is useful for point-free style programming where you want to partially apply
+// the Reader's environment before dealing with the context.
+//
+// Type Parameters:
+//   - R: The environment type that the Reader depends on
+//   - A: The value type
+//
+// Parameters:
+//   - ma: A ReaderIO containing a Reader
+//
+// Returns:
+//   - A Reader that produces a ReaderIO when given an environment
+//
+// Example:
+//
+//	type Config struct {
+//	    Timeout int
+//	}
+//
+//	// A computation that produces a Reader
+//	getMultiplier := func(ctx context.Context) IO[func(Config) int] {
+//	    return func() func(Config) int {
+//	        return func(cfg Config) int {
+//	            return cfg.Timeout * 2
+//	        }
+//	    }
+//	}
+//
+//	// Sequence it to apply Config first
+//	sequenced := SequenceReader[Config, int](getMultiplier)
+//	cfg := Config{Timeout: 30}
+//	result := sequenced(cfg)(context.Background())() // Returns 60
+//
+//go:inline
+func SequenceReader[R, A any](ma ReaderIO[Reader[R, A]]) Reader[R, ReaderIO[A]] {
+	return RIO.SequenceReader(ma)
+}
+
+// TraverseReader applies a Reader-based transformation to a ReaderIO, introducing a new environment dependency.
+//
+// This function takes a Reader-based Kleisli arrow and returns a function that can transform
+// a ReaderIO. The result allows you to provide the Reader's environment (R) first, which then
+// produces a ReaderIO that depends on the context.
+//
+// Type transformation:
+//
+//	From: ReaderIO[A]
+//	      = func(context.Context) func() A
+//
+//	With: reader.Kleisli[R, A, B]
+//	      = func(A) func(R) B
+//
+//	To:   func(ReaderIO[A]) func(R) ReaderIO[B]
+//	      = func(ReaderIO[A]) func(R) func(context.Context) func() B
+//
+// This enables transforming values within a ReaderIO using environment-dependent logic.
+//
+// Type Parameters:
+//   - R: The environment type that the Reader depends on
+//   - A: The input value type
+//   - B: The output value type
+//
+// Parameters:
+//   - f: A Reader-based Kleisli arrow that transforms A to B using environment R
+//
+// Returns:
+//   - A function that takes a ReaderIO[A] and returns a function from R to ReaderIO[B]
+//
+// Example:
+//
+//	type Config struct {
+//	    Multiplier int
+//	}
+//
+//	// A Reader-based transformation
+//	multiply := func(x int) func(Config) int {
+//	    return func(cfg Config) int {
+//	        return x * cfg.Multiplier
+//	    }
+//	}
+//
+//	// Apply TraverseReader
+//	traversed := TraverseReader[Config, int, int](multiply)
+//	computation := Of(10)
+//	result := traversed(computation)
+//
+//	// Provide Config to get final result
+//	cfg := Config{Multiplier: 5}
+//	finalResult := result(cfg)(context.Background())() // Returns 50
+//
+//go:inline
+func TraverseReader[R, A, B any](
+	f reader.Kleisli[R, A, B],
+) func(ReaderIO[A]) Kleisli[R, B] {
+	return RIO.TraverseReader[context.Context](f)
+}

v2/context/readerio/logging.go

@@ -0,0 +1,91 @@
+package readerio
+
+import (
+	"context"
+	"log/slog"
+
+	"github.com/IBM/fp-go/v2/logging"
+)
+
+// SLogWithCallback creates a Kleisli arrow that logs a value with a custom logger and log level.
+// The value is logged and then passed through unchanged, making this useful for debugging
+// and monitoring values as they flow through a ReaderIO computation.
+//
+// Type Parameters:
+//   - A: The type of value to log and pass through
+//
+// Parameters:
+//   - logLevel: The slog.Level to use for logging (e.g., slog.LevelInfo, slog.LevelDebug)
+//   - cb: Callback function to retrieve the *slog.Logger from the context
+//   - message: A descriptive message to include in the log entry
+//
+// Returns:
+//   - A Kleisli arrow that logs the value and returns it unchanged
+//
+// Example:
+//
+//	getMyLogger := func(ctx context.Context) *slog.Logger {
+//	    if logger := ctx.Value("logger"); logger != nil {
+//	        return logger.(*slog.Logger)
+//	    }
+//	    return slog.Default()
+//	}
+//
+//	debugLog := SLogWithCallback[User](
+//	    slog.LevelDebug,
+//	    getMyLogger,
+//	    "Processing user",
+//	)
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    Chain(debugLog),
+//	)
+func SLogWithCallback[A any](
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	message string) Kleisli[A, A] {
+	return func(a A) ReaderIO[A] {
+		return func(ctx context.Context) IO[A] {
+			// logger
+			logger := cb(ctx)
+			return func() A {
+				logger.LogAttrs(ctx, logLevel, message, slog.Any("value", a))
+				return a
+			}
+		}
+	}
+}
+
+// SLog creates a Kleisli arrow that logs a value at Info level and passes it through unchanged.
+// This is a convenience wrapper around SLogWithCallback with standard settings.
+//
+// The value is logged with the provided message and then returned unchanged, making this
+// useful for debugging and monitoring values in a ReaderIO computation pipeline.
+//
+// Type Parameters:
+//   - A: The type of value to log and pass through
+//
+// Parameters:
+//   - message: A descriptive message to include in the log entry
+//
+// Returns:
+//   - A Kleisli arrow that logs the value at Info level and returns it unchanged
+//
+// Example:
+//
+//	pipeline := F.Pipe3(
+//	    fetchUser(123),
+//	    Chain(SLog[User]("Fetched user")),
+//	    Map(func(u User) string { return u.Name }),
+//	    Chain(SLog[string]("Extracted name")),
+//	)
+//
+//	result := pipeline(context.Background())()
+//	// Logs: "Fetched user" value={ID:123 Name:"Alice"}
+//	// Logs: "Extracted name" value="Alice"
+//
+//go:inline
+func SLog[A any](message string) Kleisli[A, A] {
+	return SLogWithCallback[A](slog.LevelInfo, logging.GetLoggerFromContext, message)
+}

v2/context/readerio/reader.go

@@ -17,6 +17,7 @@ package readerio
 
 import (
 	"context"
+	"time"
 
 	"github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/reader"
@@ -558,3 +559,211 @@ func TapReaderK[A, B any](f reader.Kleisli[context.Context, A, B]) Operator[A, A
 func Read[A any](r context.Context) func(ReaderIO[A]) IO[A] {
 	return RIO.Read[A](r)
 }
+
+// Local transforms the context.Context environment before passing it to a ReaderIO computation.
+//
+// This is the Reader's local operation, which allows you to modify the environment
+// for a specific computation without affecting the outer context. The transformation
+// function receives the current context and returns a new context along with a
+// cancel function. The cancel function is automatically called when the computation
+// completes (via defer), ensuring proper cleanup of resources.
+//
+// This is useful for:
+//   - Adding timeouts or deadlines to specific operations
+//   - Adding context values for nested computations
+//   - Creating isolated context scopes
+//   - Implementing context-based dependency injection
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIO
+//
+// Parameters:
+//   - f: A function that transforms the context and returns a cancel function
+//
+// Returns:
+//   - An Operator that runs the computation with the transformed context
+//
+// Example:
+//
+//	import F "github.com/IBM/fp-go/v2/function"
+//
+//	// Add a custom value to the context
+//	type key int
+//	const userKey key = 0
+//
+//	addUser := readerio.Local[string](func(ctx context.Context) (context.Context, context.CancelFunc) {
+//	    newCtx := context.WithValue(ctx, userKey, "Alice")
+//	    return newCtx, func() {} // No-op cancel
+//	})
+//
+//	getUser := readerio.FromReader(func(ctx context.Context) string {
+//	    if user := ctx.Value(userKey); user != nil {
+//	        return user.(string)
+//	    }
+//	    return "unknown"
+//	})
+//
+//	result := F.Pipe1(
+//	    getUser,
+//	    addUser,
+//	)
+//	user := result(context.Background())()  // Returns "Alice"
+//
+// Timeout Example:
+//
+//	// Add a 5-second timeout to a specific operation
+//	withTimeout := readerio.Local[Data](func(ctx context.Context) (context.Context, context.CancelFunc) {
+//	    return context.WithTimeout(ctx, 5*time.Second)
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    withTimeout,
+//	)
+func Local[A any](f func(context.Context) (context.Context, context.CancelFunc)) Operator[A, A] {
+	return func(rr ReaderIO[A]) ReaderIO[A] {
+		return func(ctx context.Context) IO[A] {
+			return func() A {
+				otherCtx, otherCancel := f(ctx)
+				defer otherCancel()
+				return rr(otherCtx)()
+			}
+		}
+	}
+}
+
+// WithTimeout adds a timeout to the context for a ReaderIO computation.
+//
+// This is a convenience wrapper around Local that uses context.WithTimeout.
+// The computation must complete within the specified duration, or it will be
+// cancelled. This is useful for ensuring operations don't run indefinitely
+// and for implementing timeout-based error handling.
+//
+// The timeout is relative to when the ReaderIO is executed, not when
+// WithTimeout is called. The cancel function is automatically called when
+// the computation completes, ensuring proper cleanup.
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIO
+//
+// Parameters:
+//   - timeout: The maximum duration for the computation
+//
+// Returns:
+//   - An Operator that runs the computation with a timeout
+//
+// Example:
+//
+//	import (
+//	    "time"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	)
+//
+//	// Fetch data with a 5-second timeout
+//	fetchData := readerio.FromReader(func(ctx context.Context) Data {
+//	    // Simulate slow operation
+//	    select {
+//	    case <-time.After(10 * time.Second):
+//	        return Data{Value: "slow"}
+//	    case <-ctx.Done():
+//	        return Data{}
+//	    }
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerio.WithTimeout[Data](5*time.Second),
+//	)
+//	data := result(context.Background())()  // Returns Data{} after 5s timeout
+//
+// Successful Example:
+//
+//	quickFetch := readerio.Of(Data{Value: "quick"})
+//	result := F.Pipe1(
+//	    quickFetch,
+//	    readerio.WithTimeout[Data](5*time.Second),
+//	)
+//	data := result(context.Background())()  // Returns Data{Value: "quick"}
+func WithTimeout[A any](timeout time.Duration) Operator[A, A] {
+	return Local[A](func(ctx context.Context) (context.Context, context.CancelFunc) {
+		return context.WithTimeout(ctx, timeout)
+	})
+}
+
+// WithDeadline adds an absolute deadline to the context for a ReaderIO computation.
+//
+// This is a convenience wrapper around Local that uses context.WithDeadline.
+// The computation must complete before the specified time, or it will be
+// cancelled. This is useful for coordinating operations that must finish
+// by a specific time, such as request deadlines or scheduled tasks.
+//
+// The deadline is an absolute time, unlike WithTimeout which uses a relative
+// duration. The cancel function is automatically called when the computation
+// completes, ensuring proper cleanup.
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIO
+//
+// Parameters:
+//   - deadline: The absolute time by which the computation must complete
+//
+// Returns:
+//   - An Operator that runs the computation with a deadline
+//
+// Example:
+//
+//	import (
+//	    "time"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	)
+//
+//	// Operation must complete by 3 PM
+//	deadline := time.Date(2024, 1, 1, 15, 0, 0, 0, time.UTC)
+//
+//	fetchData := readerio.FromReader(func(ctx context.Context) Data {
+//	    // Simulate operation
+//	    select {
+//	    case <-time.After(1 * time.Hour):
+//	        return Data{Value: "done"}
+//	    case <-ctx.Done():
+//	        return Data{}
+//	    }
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerio.WithDeadline[Data](deadline),
+//	)
+//	data := result(context.Background())()  // Returns Data{} if past deadline
+//
+// Combining with Parent Context:
+//
+//	// If parent context already has a deadline, the earlier one takes precedence
+//	parentCtx, cancel := context.WithDeadline(context.Background(), time.Now().Add(1*time.Hour))
+//	defer cancel()
+//
+//	laterDeadline := time.Now().Add(2 * time.Hour)
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerio.WithDeadline[Data](laterDeadline),
+//	)
+//	data := result(parentCtx)()  // Will use parent's 1-hour deadline
+func WithDeadline[A any](deadline time.Time) Operator[A, A] {
+	return Local[A](func(ctx context.Context) (context.Context, context.CancelFunc) {
+		return context.WithDeadline(ctx, deadline)
+	})
+}
+
+// Delay creates an operation that passes in the value after some delay
+//
+//go:inline
+func Delay[A any](delay time.Duration) Operator[A, A] {
+	return RIO.Delay[context.Context, A](delay)
+}
+
+// After creates an operation that passes after the given [time.Time]
+//
+//go:inline
+func After[R, E, A any](timestamp time.Time) Operator[A, A] {
+	return RIO.After[context.Context, A](timestamp)
+}

v2/context/readerio/rec.go

@@ -0,0 +1,86 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerio
+
+import (
+	"github.com/IBM/fp-go/v2/readerio"
+)
+
+// TailRec implements stack-safe tail recursion for the ReaderIO monad.
+//
+// This function enables recursive computations that depend on a [context.Context] and
+// perform side effects, without risking stack overflow. It uses an iterative loop to
+// execute the recursion, making it safe for deep or unbounded recursion.
+//
+// The function takes a Kleisli arrow that returns Trampoline[A, B]:
+//   - Bounce(A): Continue recursion with the new state A
+//   - Land(B): Terminate recursion and return the final result B
+//
+// Type Parameters:
+//   - A: The state type that changes during recursion
+//   - B: The final result type when recursion terminates
+//
+// Parameters:
+//   - f: A Kleisli arrow (A => ReaderIO[Trampoline[A, B]]) that controls recursion flow
+//
+// Returns:
+//   - A Kleisli arrow (A => ReaderIO[B]) that executes the recursion safely
+//
+// Example - Countdown:
+//
+//	countdownStep := func(n int) ReaderIO[tailrec.Trampoline[int, string]] {
+//	    return func(ctx context.Context) IO[tailrec.Trampoline[int, string]] {
+//	        return func() tailrec.Trampoline[int, string] {
+//	            if n <= 0 {
+//	                return tailrec.Land[int]("Done!")
+//	            }
+//	            return tailrec.Bounce[string](n - 1)
+//	        }
+//	    }
+//	}
+//
+//	countdown := TailRec(countdownStep)
+//	result := countdown(10)(context.Background())() // Returns "Done!"
+//
+// Example - Sum with context:
+//
+//	type SumState struct {
+//	    numbers []int
+//	    total   int
+//	}
+//
+//	sumStep := func(state SumState) ReaderIO[tailrec.Trampoline[SumState, int]] {
+//	    return func(ctx context.Context) IO[tailrec.Trampoline[SumState, int]] {
+//	        return func() tailrec.Trampoline[SumState, int] {
+//	            if len(state.numbers) == 0 {
+//	                return tailrec.Land[SumState](state.total)
+//	            }
+//	            return tailrec.Bounce[int](SumState{
+//	                numbers: state.numbers[1:],
+//	                total:   state.total + state.numbers[0],
+//	            })
+//	        }
+//	    }
+//	}
+//
+//	sum := TailRec(sumStep)
+//	result := sum(SumState{numbers: []int{1, 2, 3, 4, 5}})(context.Background())()
+//	// Returns 15, safe even for very large slices
+//
+//go:inline
+func TailRec[A, B any](f Kleisli[A, Trampoline[A, B]]) Kleisli[A, B] {
+	return readerio.TailRec(f)
+}

v2/context/readerio/retry.go

@@ -0,0 +1,106 @@
+// Copyright (c) 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerio
+
+import (
+	"github.com/IBM/fp-go/v2/retry"
+	RG "github.com/IBM/fp-go/v2/retry/generic"
+)
+
+// Retrying retries a ReaderIO computation according to a retry policy.
+//
+// This function implements a retry mechanism for operations that depend on a [context.Context]
+// and perform side effects (IO). The retry loop continues until one of the following occurs:
+//   - The action succeeds and the check function returns false (no retry needed)
+//   - The retry policy returns None (retry limit reached)
+//   - The check function returns false (indicating success or a non-retryable condition)
+//
+// Type Parameters:
+//   - A: The type of the value produced by the action
+//
+// Parameters:
+//
+//   - policy: A RetryPolicy that determines when and how long to wait between retries.
+//     The policy receives a RetryStatus on each iteration and returns an optional delay.
+//     If it returns None, retrying stops. Common policies include LimitRetries,
+//     ExponentialBackoff, and CapDelay from the retry package.
+//
+//   - action: A Kleisli arrow that takes a RetryStatus and returns a ReaderIO[A].
+//     This function is called on each retry attempt and receives information about the
+//     current retry state (iteration number, cumulative delay, etc.).
+//
+//   - check: A predicate function that examines the result A and returns true if the
+//     operation should be retried, or false if it should stop. This allows you to
+//     distinguish between retryable conditions and successful/permanent results.
+//
+// Returns:
+//   - A ReaderIO[A] that, when executed with a context, will perform the retry logic
+//     and return the final result.
+//
+// Example:
+//
+//	// Create a retry policy: exponential backoff with a cap, limited to 5 retries
+//	policy := M.Concat(
+//	    retry.LimitRetries(5),
+//	    retry.CapDelay(10*time.Second, retry.ExponentialBackoff(100*time.Millisecond)),
+//	)(retry.Monoid)
+//
+//	// Action that fetches data, with retry status information
+//	fetchData := func(status retry.RetryStatus) ReaderIO[string] {
+//	    return func(ctx context.Context) IO[string] {
+//	        return func() string {
+//	            // Simulate an operation that might fail
+//	            if status.IterNumber < 3 {
+//	                return ""  // Empty result indicates failure
+//	            }
+//	            return "success"
+//	        }
+//	    }
+//	}
+//
+//	// Check function: retry if result is empty
+//	shouldRetry := func(s string) bool {
+//	    return s == ""
+//	}
+//
+//	// Create the retrying computation
+//	retryingFetch := Retrying(policy, fetchData, shouldRetry)
+//
+//	// Execute
+//	ctx := context.Background()
+//	result := retryingFetch(ctx)() // Returns "success" after 3 attempts
+//
+//go:inline
+func Retrying[A any](
+	policy retry.RetryPolicy,
+	action Kleisli[retry.RetryStatus, A],
+	check Predicate[A],
+) ReaderIO[A] {
+	// get an implementation for the types
+	return RG.Retrying(
+		Chain[A, Trampoline[retry.RetryStatus, A]],
+		Map[retry.RetryStatus, Trampoline[retry.RetryStatus, A]],
+		Of[Trampoline[retry.RetryStatus, A]],
+		Of[retry.RetryStatus],
+		Delay[retry.RetryStatus],
+
+		TailRec,
+
+		policy,
+		action,
+		check,
+	)
+}

v2/context/readerio/type.go

@@ -18,10 +18,14 @@ package readerio
 import (
 	"context"
 
+	"github.com/IBM/fp-go/v2/consumer"
+	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/lazy"
+	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 	"github.com/IBM/fp-go/v2/readerio"
+	"github.com/IBM/fp-go/v2/tailrec"
 )
 
 type (
@@ -66,4 +70,12 @@ type (
 	//
 	// Operator[A, B] is equivalent to func(ReaderIO[A]) func(context.Context) func() B
 	Operator[A, B any] = Kleisli[ReaderIO[A], B]
+
+	Consumer[A any] = consumer.Consumer[A]
+
+	Either[E, A any] = either.Either[E, A]
+
+	Trampoline[B, L any] = tailrec.Trampoline[B, L]
+
+	Predicate[A any] = predicate.Predicate[A]
 )

v2/context/readerioresult/FLIP_POINTFREE.md

@@ -0,0 +1,682 @@
+# Sequence Functions and Point-Free Style Programming
+
+This document explains how the `Sequence*` functions in the `context/readerioresult` package enable point-free style programming and improve code composition.
+
+## Table of Contents
+
+1. [What is Point-Free Style?](#what-is-point-free-style)
+2. [The Problem: Nested Function Application](#the-problem-nested-function-application)
+3. [The Solution: Sequence Functions](#the-solution-sequence-functions)
+4. [How Sequence Enables Point-Free Style](#how-sequence-enables-point-free-style)
+5. [TraverseReader: Introducing Dependencies](#traversereader-introducing-dependencies)
+6. [Practical Benefits](#practical-benefits)
+7. [Examples](#examples)
+8. [Comparison: With and Without Sequence](#comparison-with-and-without-sequence)
+
+## What is Point-Free Style?
+
+Point-free style (also called tacit programming) is a programming paradigm where function definitions don't explicitly mention their arguments. Instead, functions are composed using combinators and higher-order functions.
+
+**Traditional style (with points):**
+```go
+func double(x int) int {
+    return x * 2
+}
+```
+
+**Point-free style (without points):**
+```go
+var double = N.Mul(2)
+```
+
+The key benefit is that point-free style emphasizes **what** the function does (its transformation) rather than **how** it manipulates data.
+
+## The Problem: Nested Function Application
+
+In functional programming with monadic types like `ReaderIOResult`, we often have nested structures where we need to apply parameters in a specific order. Consider:
+
+```go
+type ReaderIOResult[A any] = func(context.Context) func() Either[error, A]
+type Reader[R, A any] = func(R) A
+
+// A computation that produces a Reader
+type Computation = ReaderIOResult[Reader[Config, int]]
+// Expands to: func(context.Context) func() Either[error, func(Config) int]
+```
+
+To use this, we must apply parameters in this order:
+1. First, provide `context.Context`
+2. Then, execute the IO effect (call the function)
+3. Then, unwrap the `Either` to get the `Reader`
+4. Finally, provide the `Config`
+
+This creates several problems:
+
+### Problem 1: Awkward Parameter Order
+
+```go
+computation := getComputation()
+ctx := context.Background()
+cfg := Config{Value: 42}
+
+// Must apply in this specific order
+result := computation(ctx)()  // Get Either[error, Reader[Config, int]]
+if reader, err := either.Unwrap(result); err == nil {
+    value := reader(cfg)  // Finally apply Config
+    // use value
+}
+```
+
+The `Config` parameter, which is often known early and stable, must be provided last. This prevents partial application and reuse.
+
+### Problem 2: Cannot Partially Apply Dependencies
+
+```go
+// Want to do this: create a reusable computation with Config baked in
+// But can't because Config comes last!
+withConfig := computation(cfg)  // ❌ Doesn't work - cfg comes last, not first
+```
+
+### Problem 3: Breaks Point-Free Composition
+
+```go
+// Want to compose like this:
+var pipeline = F.Flow3(
+    getComputation,
+    applyConfig(cfg),  // ❌ Can't do this - Config comes last
+    processResult,
+)
+```
+
+## The Solution: Sequence Functions
+
+The `Sequence*` functions solve this by "flipping" or "sequencing" the nested structure, changing the order in which parameters are applied.
+
+### SequenceReader
+
+```go
+func SequenceReader[R, A any](
+    ma ReaderIOResult[Reader[R, A]]
+) Kleisli[R, A]
+```
+
+**Type transformation:**
+```
+From: func(context.Context) func() Either[error, func(R) A]
+To:   func(R) func(context.Context) func() Either[error, A]
+```
+
+Now `R` (the Reader's environment) comes **first**, before `context.Context`!
+
+### SequenceReaderIO
+
+```go
+func SequenceReaderIO[R, A any](
+    ma ReaderIOResult[ReaderIO[R, A]]
+) Kleisli[R, A]
+```
+
+**Type transformation:**
+```
+From: func(context.Context) func() Either[error, func(R) func() A]
+To:   func(R) func(context.Context) func() Either[error, A]
+```
+
+### SequenceReaderResult
+
+```go
+func SequenceReaderResult[R, A any](
+    ma ReaderIOResult[ReaderResult[R, A]]
+) Kleisli[R, A]
+```
+
+**Type transformation:**
+```
+From: func(context.Context) func() Either[error, func(R) Either[error, A]]
+To:   func(R) func(context.Context) func() Either[error, A]
+```
+
+## How Sequence Enables Point-Free Style
+
+### 1. Partial Application
+
+By moving the environment parameter first, we can partially apply it:
+
+```go
+type Config struct { Multiplier int }
+
+computation := getComputation()  // ReaderIOResult[Reader[Config, int]]
+sequenced := SequenceReader[Config, int](computation)
+
+// Partially apply Config
+cfg := Config{Multiplier: 5}
+withConfig := sequenced(cfg)  // ✅ Now we have ReaderIOResult[int]
+
+// Reuse with different contexts
+result1 := withConfig(ctx1)()
+result2 := withConfig(ctx2)()
+```
+
+### 2. Dependency Injection
+
+Inject dependencies early in the pipeline:
+
+```go
+type Database struct { ConnectionString string }
+
+makeQuery := func(ctx context.Context) func() Either[error, func(Database) string] {
+    // ... implementation
+}
+
+// Sequence to enable DI
+queryWithDB := SequenceReader[Database, string](makeQuery)
+
+// Inject database
+db := Database{ConnectionString: "localhost:5432"}
+query := queryWithDB(db)  // ✅ Database injected
+
+// Use query with any context
+result := query(context.Background())()
+```
+
+### 3. Point-Free Composition
+
+Build pipelines without mentioning intermediate values:
+
+```go
+var pipeline = F.Flow3(
+    getComputation,                    // ReaderIOResult[Reader[Config, int]]
+    SequenceReader[Config, int],       // func(Config) ReaderIOResult[int]
+    applyConfig(cfg),                  // ReaderIOResult[int]
+)
+
+// Or with partial application:
+var withConfig = F.Pipe1(
+    getComputation(),
+    SequenceReader[Config, int],
+)
+
+result := withConfig(cfg)(ctx)()
+```
+
+### 4. Reusable Computations
+
+Create specialized versions of generic computations:
+
+```go
+// Generic computation
+makeServiceInfo := func(ctx context.Context) func() Either[error, func(ServiceConfig) string] {
+    // ... implementation
+}
+
+sequenced := SequenceReader[ServiceConfig, string](makeServiceInfo)
+
+// Create specialized versions
+authService := sequenced(ServiceConfig{Name: "Auth", Version: "1.0"})
+userService := sequenced(ServiceConfig{Name: "User", Version: "2.0"})
+
+// Reuse across contexts
+authInfo := authService(ctx)()
+userInfo := userService(ctx)()
+```
+
+## TraverseReader: Introducing Dependencies
+
+While `SequenceReader` flips the parameter order of an existing nested structure, `TraverseReader` allows you to **introduce** a new Reader dependency into an existing computation.
+
+### Function Signature
+
+```go
+func TraverseReader[R, A, B any](
+    f reader.Kleisli[R, A, B],
+) func(ReaderIOResult[A]) Kleisli[R, B]
+```
+
+**Type transformation:**
+```
+Input:  ReaderIOResult[A] = func(context.Context) func() Either[error, A]
+With:   reader.Kleisli[R, A, B] = func(A) func(R) B
+Output: Kleisli[R, B] = func(R) func(context.Context) func() Either[error, B]
+```
+
+### What It Does
+
+`TraverseReader` takes:
+1. A Reader-based transformation `f: func(A) func(R) B` that depends on environment `R`
+2. Returns a function that transforms `ReaderIOResult[A]` into `Kleisli[R, B]`
+
+This allows you to:
+- Add environment dependencies to computations that don't have them yet
+- Transform values within a ReaderIOResult using environment-dependent logic
+- Build composable pipelines where transformations depend on configuration
+
+### Key Difference from SequenceReader
+
+- **SequenceReader**: Works with computations that **already contain** a Reader (`ReaderIOResult[Reader[R, A]]`)
+  - Flips the order so `R` comes first
+  - No transformation of the value itself
+
+- **TraverseReader**: Works with computations that **don't have** a Reader yet (`ReaderIOResult[A]`)
+  - Introduces a new Reader dependency via a transformation function
+  - Transforms `A` to `B` using environment `R`
+
+### Example: Adding Configuration to a Computation
+
+```go
+type Config struct {
+    Multiplier int
+    Prefix     string
+}
+
+// Original computation that just produces an int
+getValue := func(ctx context.Context) func() Either[error, int] {
+    return func() Either[error, int] {
+        return Right[error](10)
+    }
+}
+
+// A Reader-based transformation that depends on Config
+formatWithConfig := func(n int) func(Config) string {
+    return func(cfg Config) string {
+        result := n * cfg.Multiplier
+        return fmt.Sprintf("%s: %d", cfg.Prefix, result)
+    }
+}
+
+// Use TraverseReader to introduce Config dependency
+traversed := TraverseReader[Config, int, string](formatWithConfig)
+withConfig := traversed(getValue)
+
+// Now we can provide Config to get the final result
+cfg := Config{Multiplier: 5, Prefix: "Result"}
+ctx := context.Background()
+result := withConfig(cfg)(ctx)() // Returns Right("Result: 50")
+```
+
+### Point-Free Composition with TraverseReader
+
+```go
+// Build a pipeline that introduces dependencies at each stage
+var pipeline = F.Flow4(
+    loadValue,                              // ReaderIOResult[int]
+    TraverseReader(multiplyByConfig),       // Kleisli[Config, int]
+    applyConfig(cfg),                       // ReaderIOResult[int]
+    Chain(TraverseReader(formatWithStyle)), // Introduce another dependency
+)
+```
+
+### When to Use TraverseReader vs SequenceReader
+
+**Use SequenceReader when:**
+- Your computation already returns a Reader: `ReaderIOResult[Reader[R, A]]`
+- You just want to flip the parameter order
+- No transformation of the value is needed
+
+```go
+// Already have Reader[Config, int]
+computation := getComputation() // ReaderIOResult[Reader[Config, int]]
+sequenced := SequenceReader[Config, int](computation)
+result := sequenced(cfg)(ctx)()
+```
+
+**Use TraverseReader when:**
+- Your computation doesn't have a Reader yet: `ReaderIOResult[A]`
+- You want to transform the value using environment-dependent logic
+- You're introducing a new dependency into the pipeline
+
+```go
+// Have ReaderIOResult[int], want to add Config dependency
+computation := getValue() // ReaderIOResult[int]
+traversed := TraverseReader[Config, int, string](formatWithConfig)
+withDep := traversed(computation)
+result := withDep(cfg)(ctx)()
+```
+
+### Practical Example: Multi-Stage Processing
+
+```go
+type DatabaseConfig struct {
+    ConnectionString string
+    Timeout          time.Duration
+}
+
+type FormattingConfig struct {
+    DateFormat string
+    Timezone   string
+}
+
+// Stage 1: Load raw data (no dependencies yet)
+loadData := func(ctx context.Context) func() Either[error, RawData] {
+    // ... implementation
+}
+
+// Stage 2: Process with database config
+processWithDB := func(raw RawData) func(DatabaseConfig) ProcessedData {
+    return func(cfg DatabaseConfig) ProcessedData {
+        // Use cfg.ConnectionString, cfg.Timeout
+        return ProcessedData{/* ... */}
+    }
+}
+
+// Stage 3: Format with formatting config
+formatData := func(processed ProcessedData) func(FormattingConfig) string {
+    return func(cfg FormattingConfig) string {
+        // Use cfg.DateFormat, cfg.Timezone
+        return "formatted result"
+    }
+}
+
+// Build pipeline introducing dependencies at each stage
+var pipeline = F.Flow3(
+    loadData,
+    TraverseReader[DatabaseConfig, RawData, ProcessedData](processWithDB),
+    // Now we have Kleisli[DatabaseConfig, ProcessedData]
+    applyConfig(dbConfig),
+    // Now we have ReaderIOResult[ProcessedData]
+    TraverseReader[FormattingConfig, ProcessedData, string](formatData),
+    // Now we have Kleisli[FormattingConfig, string]
+)
+
+// Execute with both configs
+result := pipeline(fmtConfig)(ctx)()
+```
+
+### Combining TraverseReader and SequenceReader
+
+You can combine both functions in complex pipelines:
+
+```go
+// Start with nested Reader
+computation := getComputation() // ReaderIOResult[Reader[Config, User]]
+
+var pipeline = F.Flow4(
+    computation,
+    SequenceReader[Config, User],           // Flip to get Kleisli[Config, User]
+    applyConfig(cfg),                       // Apply config, get ReaderIOResult[User]
+    TraverseReader(enrichWithDatabase),     // Add database dependency
+    // Now have Kleisli[Database, EnrichedUser]
+)
+
+result := pipeline(db)(ctx)()
+```
+
+## Practical Benefits
+
+### 1. **Improved Testability**
+
+Inject test dependencies easily:
+
+```go
+// Production
+prodDB := Database{ConnectionString: "prod:5432"}
+prodQuery := queryWithDB(prodDB)
+
+// Testing
+testDB := Database{ConnectionString: "test:5432"}
+testQuery := queryWithDB(testDB)
+
+// Same computation, different dependencies
+```
+
+### 2. **Better Separation of Concerns**
+
+Separate configuration from execution:
+
+```go
+// Configuration phase (pure, no effects)
+cfg := loadConfig()
+computation := sequenced(cfg)
+
+// Execution phase (with effects)
+result := computation(ctx)()
+```
+
+### 3. **Enhanced Composability**
+
+Build complex pipelines from simple pieces:
+
+```go
+var processUser = F.Flow4(
+    loadUserConfig,           // ReaderIOResult[Reader[Database, User]]
+    SequenceReader,           // func(Database) ReaderIOResult[User]
+    applyDatabase(db),        // ReaderIOResult[User]
+    Chain(validateUser),      // ReaderIOResult[ValidatedUser]
+)
+```
+
+### 4. **Reduced Boilerplate**
+
+No need to manually thread parameters:
+
+```go
+// Without Sequence - manual threading
+func processWithConfig(cfg Config) ReaderIOResult[Result] {
+    return func(ctx context.Context) func() Either[error, Result] {
+        return func() Either[error, Result] {
+            comp := getComputation()(ctx)()
+            if reader, err := either.Unwrap(comp); err == nil {
+                value := reader(cfg)
+                // ... more processing
+            }
+            // ... error handling
+        }
+    }
+}
+
+// With Sequence - point-free
+var processWithConfig = F.Flow2(
+    getComputation,
+    SequenceReader[Config, Result],
+)
+```
+
+## Examples
+
+### Example 1: Database Query with Configuration
+
+```go
+type QueryConfig struct {
+    Timeout  time.Duration
+    MaxRows  int
+}
+
+type Database struct {
+    ConnectionString string
+}
+
+// Without Sequence
+func executeQueryOld(cfg QueryConfig, db Database) ReaderIOResult[[]Row] {
+    return func(ctx context.Context) func() Either[error, []Row] {
+        return func() Either[error, []Row] {
+            // Must manually handle all parameters
+            // ...
+        }
+    }
+}
+
+// With Sequence
+func makeQuery(ctx context.Context) func() Either[error, func(Database) []Row] {
+    return func() Either[error, func(Database) []Row] {
+        return Right[error](func(db Database) []Row {
+            // Implementation
+            return []Row{}
+        })
+    }
+}
+
+var executeQuery = F.Flow2(
+    makeQuery,
+    SequenceReader[Database, []Row],
+)
+
+// Usage
+db := Database{ConnectionString: "localhost:5432"}
+query := executeQuery(db)
+result := query(ctx)()
+```
+
+### Example 2: Multi-Service Architecture
+
+```go
+type ServiceRegistry struct {
+    AuthService  AuthService
+    UserService  UserService
+    EmailService EmailService
+}
+
+// Create computations that depend on services
+makeAuthCheck := func(ctx context.Context) func() Either[error, func(ServiceRegistry) bool] {
+    // ... implementation
+}
+
+makeSendEmail := func(ctx context.Context) func() Either[error, func(ServiceRegistry) error] {
+    // ... implementation
+}
+
+// Sequence them
+authCheck := SequenceReader[ServiceRegistry, bool](makeAuthCheck)
+sendEmail := SequenceReader[ServiceRegistry, error](makeSendEmail)
+
+// Inject services once
+registry := ServiceRegistry{ /* ... */ }
+checkAuth := authCheck(registry)
+sendMail := sendEmail(registry)
+
+// Use with different contexts
+if isAuth, _ := either.Unwrap(checkAuth(ctx1)()); isAuth {
+    sendMail(ctx2)()
+}
+```
+
+### Example 3: Configuration-Driven Pipeline
+
+```go
+type PipelineConfig struct {
+    Stage1Config Stage1Config
+    Stage2Config Stage2Config
+    Stage3Config Stage3Config
+}
+
+// Define stages
+stage1 := SequenceReader[Stage1Config, IntermediateResult1](makeStage1)
+stage2 := SequenceReader[Stage2Config, IntermediateResult2](makeStage2)
+stage3 := SequenceReader[Stage3Config, FinalResult](makeStage3)
+
+// Build pipeline with configuration
+func buildPipeline(cfg PipelineConfig) ReaderIOResult[FinalResult] {
+    return F.Pipe3(
+        stage1(cfg.Stage1Config),
+        Chain(func(r1 IntermediateResult1) ReaderIOResult[IntermediateResult2] {
+            return stage2(cfg.Stage2Config)
+        }),
+        Chain(func(r2 IntermediateResult2) ReaderIOResult[FinalResult] {
+            return stage3(cfg.Stage3Config)
+        }),
+    )
+}
+
+// Execute pipeline
+cfg := loadPipelineConfig()
+pipeline := buildPipeline(cfg)
+result := pipeline(ctx)()
+```
+
+## Comparison: With and Without Sequence
+
+### Without Sequence (Imperative Style)
+
+```go
+func processUser(userID string) ReaderIOResult[ProcessedUser] {
+    return func(ctx context.Context) func() Either[error, ProcessedUser] {
+        return func() Either[error, ProcessedUser] {
+            // Get database
+            dbComp := getDatabase()(ctx)()
+            if dbReader, err := either.Unwrap(dbComp); err != nil {
+                return Left[ProcessedUser](err)
+            }
+            db := dbReader(dbConfig)
+            
+            // Get user
+            userComp := getUser(userID)(ctx)()
+            if userReader, err := either.Unwrap(userComp); err != nil {
+                return Left[ProcessedUser](err)
+            }
+            user := userReader(db)
+            
+            // Process user
+            processComp := processUserData(user)(ctx)()
+            if processReader, err := either.Unwrap(processComp); err != nil {
+                return Left[ProcessedUser](err)
+            }
+            result := processReader(processingConfig)
+            
+            return Right[error](result)
+        }
+    }
+}
+```
+
+### With Sequence (Point-Free Style)
+
+```go
+var processUser = func(userID string) ReaderIOResult[ProcessedUser] {
+    return F.Pipe3(
+        getDatabase,
+        SequenceReader[DatabaseConfig, Database],
+        applyConfig(dbConfig),
+        Chain(func(db Database) ReaderIOResult[User] {
+            return F.Pipe2(
+                getUser(userID),
+                SequenceReader[Database, User],
+                applyDB(db),
+            )
+        }),
+        Chain(func(user User) ReaderIOResult[ProcessedUser] {
+            return F.Pipe2(
+                processUserData(user),
+                SequenceReader[ProcessingConfig, ProcessedUser],
+                applyConfig(processingConfig),
+            )
+        }),
+    )
+}
+```
+
+## Key Takeaways
+
+1. **Sequence functions flip parameter order** to enable partial application
+2. **Dependencies come first**, making them easy to inject and test
+3. **Point-free style** becomes natural and readable
+4. **Composition** is enhanced through proper parameter ordering
+5. **Reusability** increases as computations can be specialized early
+6. **Testability** improves through easy dependency injection
+7. **Separation of concerns** is clearer (configuration vs. execution)
+
+## When to Use Sequence
+
+Use `Sequence*` functions when:
+
+- ✅ You want to partially apply environment/configuration parameters
+- ✅ You're building reusable computations with injected dependencies
+- ✅ You need to test with different dependency implementations
+- ✅ You're composing complex pipelines in point-free style
+- ✅ You want to separate configuration from execution
+- ✅ You're working with nested Reader-like structures
+
+Don't use `Sequence*` when:
+
+- ❌ The original parameter order is already optimal
+- ❌ You're not doing any composition or partial application
+- ❌ The added abstraction doesn't provide value
+- ❌ The code is simpler without it
+
+## Conclusion
+
+The `Sequence*` functions are powerful tools for enabling point-free style programming in Go. By flipping the parameter order of nested monadic structures, they make it easy to:
+
+- Partially apply dependencies
+- Build composable pipelines
+- Improve testability
+- Write more declarative code
+
+While they add a layer of abstraction, the benefits in terms of code reusability, testability, and composability make them invaluable for functional programming in Go.

v2/context/readerioresult/bind.go

@@ -18,14 +18,13 @@ package readerioresult
 import (
 	"context"
 
+	"github.com/IBM/fp-go/v2/context/readerio"
 	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/apply"
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/ioeither"
 	"github.com/IBM/fp-go/v2/ioresult"
-	L "github.com/IBM/fp-go/v2/optics/lens"
 	"github.com/IBM/fp-go/v2/reader"
-	"github.com/IBM/fp-go/v2/readerio"
 	RIOR "github.com/IBM/fp-go/v2/readerioresult"
 	"github.com/IBM/fp-go/v2/result"
 )
@@ -96,7 +95,7 @@ func Bind[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f Kleisli[S1, T],
 ) Operator[S1, S2] {
-	return RIOR.Bind(setter, f)
+	return RIOR.Bind(setter, WithContextK(f))
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -128,6 +127,13 @@ func BindTo[S1, T any](
 	return RIOR.BindTo[context.Context](setter)
 }
 
+//go:inline
+func BindToP[S1, T any](
+	setter Prism[S1, T],
+) Operator[T, S1] {
+	return BindTo(setter.ReverseGet)
+}
+
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering
 // the context and the value concurrently (using Applicative rather than Monad).
 // This allows independent computations to be combined without one depending on the result of the other.
@@ -214,7 +220,7 @@ func ApS[S1, S2, T any](
 //
 //go:inline
 func ApSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa ReaderIOResult[T],
 ) Operator[S, S] {
 	return ApS(lens.Set, fa)
@@ -253,10 +259,10 @@ func ApSL[S, T any](
 //
 //go:inline
 func BindL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f Kleisli[T, T],
 ) Operator[S, S] {
-	return RIOR.BindL(lens, f)
+	return RIOR.BindL(lens, WithContextK(f))
 }
 
 // LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -289,8 +295,8 @@ func BindL[S, T any](
 //
 //go:inline
 func LetL[S, T any](
-	lens L.Lens[S, T],
-	f func(T) T,
+	lens Lens[S, T],
+	f Endomorphism[T],
 ) Operator[S, S] {
 	return RIOR.LetL[context.Context](lens, f)
 }
@@ -322,7 +328,7 @@ func LetL[S, T any](
 //
 //go:inline
 func LetToL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	b T,
 ) Operator[S, S] {
 	return RIOR.LetToL[context.Context](lens, b)
@@ -398,7 +404,7 @@ func BindReaderK[S1, S2, T any](
 //go:inline
 func BindReaderIOK[S1, S2, T any](
 	setter func(T) func(S1) S2,
-	f readerio.Kleisli[context.Context, S1, T],
+	f readerio.Kleisli[S1, T],
 ) Operator[S1, S2] {
 	return Bind(setter, F.Flow2(f, FromReaderIO[T]))
 }
@@ -443,7 +449,7 @@ func BindResultK[S1, S2, T any](
 //
 //go:inline
 func BindIOEitherKL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f ioresult.Kleisli[T, T],
 ) Operator[S, S] {
 	return BindL(lens, F.Flow2(f, FromIOEither[T]))
@@ -458,7 +464,7 @@ func BindIOEitherKL[S, T any](
 //
 //go:inline
 func BindIOResultKL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f ioresult.Kleisli[T, T],
 ) Operator[S, S] {
 	return BindL(lens, F.Flow2(f, FromIOEither[T]))
@@ -474,7 +480,7 @@ func BindIOResultKL[S, T any](
 //
 //go:inline
 func BindIOKL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f io.Kleisli[T, T],
 ) Operator[S, S] {
 	return BindL(lens, F.Flow2(f, FromIO[T]))
@@ -490,7 +496,7 @@ func BindIOKL[S, T any](
 //
 //go:inline
 func BindReaderKL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f reader.Kleisli[context.Context, T, T],
 ) Operator[S, S] {
 	return BindL(lens, F.Flow2(f, FromReader[T]))
@@ -506,8 +512,8 @@ func BindReaderKL[S, T any](
 //
 //go:inline
 func BindReaderIOKL[S, T any](
-	lens L.Lens[S, T],
-	f readerio.Kleisli[context.Context, T, T],
+	lens Lens[S, T],
+	f readerio.Kleisli[T, T],
 ) Operator[S, S] {
 	return BindL(lens, F.Flow2(f, FromReaderIO[T]))
 }
@@ -627,7 +633,7 @@ func ApResultS[S1, S2, T any](
 //
 //go:inline
 func ApIOEitherSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa IOResult[T],
 ) Operator[S, S] {
 	return F.Bind2nd(F.Flow2[ReaderIOResult[S], ioresult.Operator[S, S]], ioresult.ApSL(lens, fa))
@@ -642,7 +648,7 @@ func ApIOEitherSL[S, T any](
 //
 //go:inline
 func ApIOResultSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa IOResult[T],
 ) Operator[S, S] {
 	return F.Bind2nd(F.Flow2[ReaderIOResult[S], ioresult.Operator[S, S]], ioresult.ApSL(lens, fa))
@@ -657,7 +663,7 @@ func ApIOResultSL[S, T any](
 //
 //go:inline
 func ApIOSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa IO[T],
 ) Operator[S, S] {
 	return ApSL(lens, FromIO(fa))
@@ -672,7 +678,7 @@ func ApIOSL[S, T any](
 //
 //go:inline
 func ApReaderSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa Reader[context.Context, T],
 ) Operator[S, S] {
 	return ApSL(lens, FromReader(fa))
@@ -687,7 +693,7 @@ func ApReaderSL[S, T any](
 //
 //go:inline
 func ApReaderIOSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa ReaderIO[T],
 ) Operator[S, S] {
 	return ApSL(lens, FromReaderIO(fa))
@@ -702,7 +708,7 @@ func ApReaderIOSL[S, T any](
 //
 //go:inline
 func ApEitherSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa Result[T],
 ) Operator[S, S] {
 	return ApSL(lens, FromEither(fa))
@@ -717,7 +723,7 @@ func ApEitherSL[S, T any](
 //
 //go:inline
 func ApResultSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa Result[T],
 ) Operator[S, S] {
 	return ApSL(lens, FromResult(fa))

v2/context/readerioresult/bind_test.go

@@ -203,9 +203,7 @@ func TestApS_EmptyState(t *testing.T) {
 	result := res(t.Context())()
 	assert.True(t, E.IsRight(result))
 	emptyOpt := E.ToOption(result)
-	assert.True(t, O.IsSome(emptyOpt))
-	empty, _ := O.Unwrap(emptyOpt)
-	assert.Equal(t, Empty{}, empty)
+	assert.Equal(t, O.Of(Empty{}), emptyOpt)
 }
 
 func TestApS_ChainedWithBind(t *testing.T) {

v2/context/readerioresult/bracket.go

@@ -16,11 +16,14 @@
 package readerioresult
 
 import (
+	F "github.com/IBM/fp-go/v2/function"
 	RIOR "github.com/IBM/fp-go/v2/readerioresult"
 )
 
 // Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
 // whether the body action returns and error or not.
+//
+//go:inline
 func Bracket[
 	A, B, ANY any](
 
@@ -28,5 +31,5 @@ func Bracket[
 	use Kleisli[A, B],
 	release func(A, Either[B]) ReaderIOResult[ANY],
 ) ReaderIOResult[B] {
-	return RIOR.Bracket(acquire, use, release)
+	return RIOR.Bracket(acquire, F.Flow2(use, WithContext), release)
 }

v2/context/readerioresult/cancel.go

@@ -19,6 +19,7 @@ import (
 	"context"
 
 	CIOE "github.com/IBM/fp-go/v2/context/ioresult"
+	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/ioeither"
 )
 
@@ -34,9 +35,53 @@ import (
 // Returns a ReaderIOResult that checks for cancellation before executing.
 func WithContext[A any](ma ReaderIOResult[A]) ReaderIOResult[A] {
 	return func(ctx context.Context) IOEither[A] {
-		if err := context.Cause(ctx); err != nil {
-			return ioeither.Left[A](err)
+		if ctx.Err() != nil {
+			return ioeither.Left[A](context.Cause(ctx))
 		}
 		return CIOE.WithContext(ctx, ma(ctx))
 	}
 }
+
+// WithContextK wraps a Kleisli arrow with context cancellation checking.
+// This ensures that the computation checks for context cancellation before executing,
+// providing a convenient way to add cancellation awareness to Kleisli arrows.
+//
+// This is particularly useful when composing multiple Kleisli arrows where each step
+// should respect context cancellation.
+//
+// Type Parameters:
+//   - A: The input type of the Kleisli arrow
+//   - B: The output type of the Kleisli arrow
+//
+// Parameters:
+//   - f: The Kleisli arrow to wrap with context checking
+//
+// Returns:
+//   - A Kleisli arrow that checks for cancellation before executing
+//
+// Example:
+//
+//	fetchUser := func(id int) ReaderIOResult[User] {
+//	    return func(ctx context.Context) IOResult[User] {
+//	        return func() Result[User] {
+//	            // Long-running operation
+//	            return result.Of(User{ID: id})
+//	        }
+//	    }
+//	}
+//
+//	// Wrap with context checking
+//	safeFetch := WithContextK(fetchUser)
+//
+//	// If context is cancelled, returns immediately without executing fetchUser
+//	ctx, cancel := context.WithCancel(context.Background())
+//	cancel() // Cancel immediately
+//	result := safeFetch(123)(ctx)() // Returns context.Canceled error
+//
+//go:inline
+func WithContextK[A, B any](f Kleisli[A, B]) Kleisli[A, B] {
+	return F.Flow2(
+		f,
+		WithContext,
+	)
+}

v2/context/readerioresult/consumer.go

@@ -0,0 +1,63 @@
+package readerioresult
+
+import "github.com/IBM/fp-go/v2/io"
+
+// ChainConsumer chains a consumer function into a ReaderIOResult computation, discarding the original value.
+// This is useful for performing side effects (like logging or metrics) that consume a value
+// but don't produce a meaningful result. The computation continues with an empty struct.
+//
+// Type Parameters:
+//   - A: The type of value to consume
+//
+// Parameters:
+//   - c: A consumer function that performs side effects on the value
+//
+// Returns:
+//   - An Operator that chains the consumer and returns struct{}
+//
+// Example:
+//
+//	logUser := func(u User) {
+//	    log.Printf("Processing user: %s", u.Name)
+//	}
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    ChainConsumer(logUser),
+//	)
+//
+//go:inline
+func ChainConsumer[A any](c Consumer[A]) Operator[A, struct{}] {
+	return ChainIOK(io.FromConsumerK(c))
+}
+
+// ChainFirstConsumer chains a consumer function into a ReaderIOResult computation, preserving the original value.
+// This is useful for performing side effects (like logging or metrics) while passing the value through unchanged.
+//
+// The consumer is executed for its side effects, but the original value is returned.
+//
+// Type Parameters:
+//   - A: The type of value to consume and return
+//
+// Parameters:
+//   - c: A consumer function that performs side effects on the value
+//
+// Returns:
+//   - An Operator that chains the consumer and returns the original value
+//
+// Example:
+//
+//	logUser := func(u User) {
+//	    log.Printf("User: %s", u.Name)
+//	}
+//
+//	pipeline := F.Pipe3(
+//	    fetchUser(123),
+//	    ChainFirstConsumer(logUser),  // Logs but passes user through
+//	    Map(func(u User) string { return u.Email }),
+//	)
+//
+//go:inline
+func ChainFirstConsumer[A any](c Consumer[A]) Operator[A, A] {
+	return ChainFirstIOK(io.FromConsumerK(c))
+}

v2/context/readerioresult/file/file.go

@@ -44,11 +44,11 @@ var (
 )
 
 // Close closes an object
-func Close[C io.Closer](c C) RIOE.ReaderIOResult[any] {
+func Close[C io.Closer](c C) RIOE.ReaderIOResult[struct{}] {
 	return F.Pipe2(
 		c,
 		IOEF.Close[C],
-		RIOE.FromIOEither[any],
+		RIOE.FromIOEither[struct{}],
 	)
 }
 

v2/context/readerioresult/filter.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+
+	RIOR "github.com/IBM/fp-go/v2/readerioresult"
+)
+
+// FilterOrElse filters a ReaderIOResult value based on a predicate.
+// This is a convenience wrapper around readerioresult.FilterOrElse that fixes
+// the context type to context.Context.
+//
+// If the predicate returns true for the Right value, it passes through unchanged.
+// If the predicate returns false, it transforms the Right value into a Left (error) using onFalse.
+// Left values are passed through unchanged.
+//
+// Parameters:
+//   - pred: A predicate function that tests the Right value
+//   - onFalse: A function that converts the failing value into an error
+//
+// Returns:
+//   - An Operator that filters ReaderIOResult values based on the predicate
+//
+// Example:
+//
+//	// Validate that a number is positive
+//	isPositive := N.MoreThan(0)
+//	onNegative := func(n int) error { return fmt.Errorf("%d is not positive", n) }
+//
+//	filter := readerioresult.FilterOrElse(isPositive, onNegative)
+//	result := filter(readerioresult.Right(42))(context.Background())()
+//
+//go:inline
+func FilterOrElse[A any](pred Predicate[A], onFalse func(A) error) Operator[A, A] {
+	return RIOR.FilterOrElse[context.Context](pred, onFalse)
+}

v2/context/readerioresult/flip.go

@@ -0,0 +1,295 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+
+	"github.com/IBM/fp-go/v2/reader"
+	RIO "github.com/IBM/fp-go/v2/readerio"
+	RIOR "github.com/IBM/fp-go/v2/readerioresult"
+	RR "github.com/IBM/fp-go/v2/readerresult"
+)
+
+// SequenceReader transforms a ReaderIOResult containing a Reader into a function that
+// takes the Reader's environment first, then returns a ReaderIOResult.
+//
+// This function "flips" or "sequences" the nested structure, changing the order in which
+// parameters are applied. It's particularly useful for point-free style programming where
+// you want to partially apply the inner Reader's environment before dealing with the
+// outer context.
+//
+// Type transformation:
+//
+//	From: ReaderIOResult[Reader[R, A]]
+//	      = func(context.Context) func() Either[error, func(R) A]
+//
+//	To:   func(context.Context) func(R) IOResult[A]
+//	      = func(context.Context) func(R) func() Either[error, A]
+//
+// This allows you to:
+//  1. Provide the context.Context first
+//  2. Then provide the Reader's environment R
+//  3. Finally execute the IO effect to get Either[error, A]
+//
+// Point-free style benefits:
+//   - Enables partial application of the Reader environment
+//   - Facilitates composition of Reader-based computations
+//   - Allows building reusable computation pipelines
+//   - Supports dependency injection patterns where R represents dependencies
+//
+// Example:
+//
+//	type Config struct {
+//	    Timeout int
+//	}
+//
+//	// A computation that produces a Reader based on context
+//	func getMultiplier(ctx context.Context) func() Either[error, func(Config) int] {
+//	    return func() Either[error, func(Config) int] {
+//	        return Right[error](func(cfg Config) int {
+//	            return cfg.Timeout * 2
+//	        })
+//	    }
+//	}
+//
+//	// Sequence it to apply Config first
+//	sequenced := SequenceReader[Config, int](getMultiplier)
+//
+//	// Now we can partially apply the Config
+//	cfg := Config{Timeout: 30}
+//	ctx := context.Background()
+//	result := sequenced(ctx)(cfg)() // Returns Right(60)
+//
+// This is especially useful in point-free style when building computation pipelines:
+//
+//	var pipeline = F.Flow3(
+//	    loadConfig,           // ReaderIOResult[Reader[Database, Config]]
+//	    SequenceReader,       // func(context.Context) func(Database) IOResult[Config]
+//	    applyToDatabase(db),  // IOResult[Config]
+//	)
+//
+//go:inline
+func SequenceReader[R, A any](ma ReaderIOResult[Reader[R, A]]) Kleisli[R, A] {
+	return RIOR.SequenceReader(ma)
+}
+
+// SequenceReaderIO transforms a ReaderIOResult containing a ReaderIO into a function that
+// takes the ReaderIO's environment first, then returns a ReaderIOResult.
+//
+// This is similar to SequenceReader but works with ReaderIO, which represents a computation
+// that depends on an environment R and performs IO effects.
+//
+// Type transformation:
+//
+//	From: ReaderIOResult[ReaderIO[R, A]]
+//	      = func(context.Context) func() Either[error, func(R) func() A]
+//
+//	To:   func(context.Context) func(R) IOResult[A]
+//	      = func(context.Context) func(R) func() Either[error, A]
+//
+// The key difference from SequenceReader is that the inner computation (ReaderIO) already
+// performs IO effects, so the sequencing combines these effects properly.
+//
+// Point-free style benefits:
+//   - Enables composition of ReaderIO-based computations
+//   - Allows partial application of environment before IO execution
+//   - Facilitates building effect pipelines with dependency injection
+//   - Supports layered architecture where R represents service dependencies
+//
+// Example:
+//
+//	type Database struct {
+//	    ConnectionString string
+//	}
+//
+//	// A computation that produces a ReaderIO based on context
+//	func getQuery(ctx context.Context) func() Either[error, func(Database) func() string] {
+//	    return func() Either[error, func(Database) func() string] {
+//	        return Right[error](func(db Database) func() string {
+//	            return func() string {
+//	                // Perform actual IO here
+//	                return "Query result from " + db.ConnectionString
+//	            }
+//	        })
+//	    }
+//	}
+//
+//	// Sequence it to apply Database first
+//	sequenced := SequenceReaderIO[Database, string](getQuery)
+//
+//	// Partially apply the Database
+//	db := Database{ConnectionString: "localhost:5432"}
+//	ctx := context.Background()
+//	result := sequenced(ctx)(db)() // Executes IO and returns Right("Query result...")
+//
+// In point-free style, this enables clean composition:
+//
+//	var executeQuery = F.Flow3(
+//	    prepareQuery,         // ReaderIOResult[ReaderIO[Database, QueryResult]]
+//	    SequenceReaderIO,     // func(context.Context) func(Database) IOResult[QueryResult]
+//	    withDatabase(db),     // IOResult[QueryResult]
+//	)
+//
+//go:inline
+func SequenceReaderIO[R, A any](ma ReaderIOResult[RIO.ReaderIO[R, A]]) Kleisli[R, A] {
+	return RIOR.SequenceReaderIO(ma)
+}
+
+// SequenceReaderResult transforms a ReaderIOResult containing a ReaderResult into a function
+// that takes the ReaderResult's environment first, then returns a ReaderIOResult.
+//
+// This is similar to SequenceReader but works with ReaderResult, which represents a computation
+// that depends on an environment R and can fail with an error.
+//
+// Type transformation:
+//
+//	From: ReaderIOResult[ReaderResult[R, A]]
+//	      = func(context.Context) func() Either[error, func(R) Either[error, A]]
+//
+//	To:   func(context.Context) func(R) IOResult[A]
+//	      = func(context.Context) func(R) func() Either[error, A]
+//
+// The sequencing properly combines the error handling from both the outer ReaderIOResult
+// and the inner ReaderResult, ensuring that errors from either level are propagated correctly.
+//
+// Point-free style benefits:
+//   - Enables composition of error-handling computations with dependency injection
+//   - Allows partial application of dependencies before error handling
+//   - Facilitates building validation pipelines with environment dependencies
+//   - Supports service-oriented architectures with proper error propagation
+//
+// Example:
+//
+//	type Config struct {
+//	    MaxRetries int
+//	}
+//
+//	// A computation that produces a ReaderResult based on context
+//	func validateRetries(ctx context.Context) func() Either[error, func(Config) Either[error, int]] {
+//	    return func() Either[error, func(Config) Either[error, int]] {
+//	        return Right[error](func(cfg Config) Either[error, int] {
+//	            if cfg.MaxRetries < 0 {
+//	                return Left[int](errors.New("negative retries"))
+//	            }
+//	            return Right[error](cfg.MaxRetries)
+//	        })
+//	    }
+//	}
+//
+//	// Sequence it to apply Config first
+//	sequenced := SequenceReaderResult[Config, int](validateRetries)
+//
+//	// Partially apply the Config
+//	cfg := Config{MaxRetries: 3}
+//	ctx := context.Background()
+//	result := sequenced(ctx)(cfg)() // Returns Right(3)
+//
+//	// With invalid config
+//	badCfg := Config{MaxRetries: -1}
+//	badResult := sequenced(ctx)(badCfg)() // Returns Left(error("negative retries"))
+//
+// In point-free style, this enables validation pipelines:
+//
+//	var validateAndProcess = F.Flow4(
+//	    loadConfig,              // ReaderIOResult[ReaderResult[Config, Settings]]
+//	    SequenceReaderResult,    // func(context.Context) func(Config) IOResult[Settings]
+//	    applyConfig(cfg),        // IOResult[Settings]
+//	    Chain(processSettings),  // IOResult[Result]
+//	)
+//
+//go:inline
+func SequenceReaderResult[R, A any](ma ReaderIOResult[RR.ReaderResult[R, A]]) Kleisli[R, A] {
+	return RIOR.SequenceReaderEither(ma)
+}
+
+// TraverseReader transforms a ReaderIOResult computation by applying a Reader-based function,
+// effectively introducing a new environment dependency.
+//
+// This function takes a Reader-based transformation (Kleisli arrow) and returns a function that
+// can transform a ReaderIOResult. The result allows you to provide the Reader's environment (R)
+// first, which then produces a ReaderIOResult that depends on the context.
+//
+// Type transformation:
+//
+//	From: ReaderIOResult[A]
+//	      = func(context.Context) func() Either[error, A]
+//
+//	With: reader.Kleisli[R, A, B]
+//	      = func(A) func(R) B
+//
+//	To:   func(ReaderIOResult[A]) func(R) ReaderIOResult[B]
+//	      = func(ReaderIOResult[A]) func(R) func(context.Context) func() Either[error, B]
+//
+// This enables:
+//  1. Transforming values within a ReaderIOResult using environment-dependent logic
+//  2. Introducing new environment dependencies into existing computations
+//  3. Building composable pipelines where transformations depend on configuration or dependencies
+//  4. Point-free style composition with Reader-based transformations
+//
+// Type Parameters:
+//   - R: The environment type that the Reader depends on
+//   - A: The input value type
+//   - B: The output value type
+//
+// Parameters:
+//   - f: A Reader-based Kleisli arrow that transforms A to B using environment R
+//
+// Returns:
+//   - A function that takes a ReaderIOResult[A] and returns a Kleisli[R, B],
+//     which is func(R) ReaderIOResult[B]
+//
+// The function preserves error handling and IO effects while adding the Reader environment dependency.
+//
+// Example:
+//
+//	type Config struct {
+//	    Multiplier int
+//	}
+//
+//	// A Reader-based transformation that depends on Config
+//	multiply := func(x int) func(Config) int {
+//	    return func(cfg Config) int {
+//	        return x * cfg.Multiplier
+//	    }
+//	}
+//
+//	// Original computation that produces an int
+//	computation := Right[int](10)
+//
+//	// Apply TraverseReader to introduce Config dependency
+//	traversed := TraverseReader[Config, int, int](multiply)
+//	result := traversed(computation)
+//
+//	// Now we can provide the Config to get the final result
+//	cfg := Config{Multiplier: 5}
+//	ctx := context.Background()
+//	finalResult := result(cfg)(ctx)() // Returns Right(50)
+//
+// In point-free style, this enables clean composition:
+//
+//	var pipeline = F.Flow3(
+//	    loadValue,                    // ReaderIOResult[int]
+//	    TraverseReader(multiplyByConfig), // func(Config) ReaderIOResult[int]
+//	    applyConfig(cfg),             // ReaderIOResult[int]
+//	)
+//
+//go:inline
+func TraverseReader[R, A, B any](
+	f reader.Kleisli[R, A, B],
+) func(ReaderIOResult[A]) Kleisli[R, B] {
+	return RIOR.TraverseReader[context.Context](f)
+}

v2/context/readerioresult/flip_example_test.go

@@ -0,0 +1,333 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult_test
+
+import (
+	"context"
+	"fmt"
+
+	RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
+	"github.com/IBM/fp-go/v2/either"
+	F "github.com/IBM/fp-go/v2/function"
+)
+
+// Example_sequenceReader_basicUsage demonstrates the basic usage of SequenceReader
+// to flip the parameter order, enabling point-free style programming.
+func Example_sequenceReader_basicUsage() {
+	type Config struct {
+		Multiplier int
+	}
+
+	// A computation that produces a Reader based on context
+	getComputation := func(ctx context.Context) func() either.Either[error, func(Config) int] {
+		return func() either.Either[error, func(Config) int] {
+			// This could check context for cancellation, deadlines, etc.
+			return either.Right[error](func(cfg Config) int {
+				return cfg.Multiplier * 10
+			})
+		}
+	}
+
+	// Sequence it to flip the parameter order
+	// Now Config comes first, then context
+	sequenced := RIOE.SequenceReader(getComputation)
+
+	// Partially apply the Config - this is the key benefit for point-free style
+	cfg := Config{Multiplier: 5}
+	withConfig := sequenced(cfg)
+
+	// Now we have a ReaderIOResult[int] that can be used with any context
+	ctx := context.Background()
+	result := withConfig(ctx)()
+
+	if value, err := either.Unwrap(result); err == nil {
+		fmt.Println(value)
+	}
+	// Output: 50
+}
+
+// Example_sequenceReader_dependencyInjection demonstrates how SequenceReader
+// enables clean dependency injection patterns in point-free style.
+func Example_sequenceReader_dependencyInjection() {
+	// Define our dependencies
+	type Database struct {
+		ConnectionString string
+	}
+
+	type UserService struct {
+		db Database
+	}
+
+	// A function that creates a computation requiring a Database
+	makeQuery := func(ctx context.Context) func() either.Either[error, func(Database) string] {
+		return func() either.Either[error, func(Database) string] {
+			return either.Right[error](func(db Database) string {
+				return fmt.Sprintf("Querying %s", db.ConnectionString)
+			})
+		}
+	}
+
+	// Sequence to enable dependency injection
+	queryWithDB := RIOE.SequenceReader(makeQuery)
+
+	// Inject the database dependency
+	db := Database{ConnectionString: "localhost:5432"}
+	query := queryWithDB(db)
+
+	// Execute with context
+	ctx := context.Background()
+	result := query(ctx)()
+
+	if value, err := either.Unwrap(result); err == nil {
+		fmt.Println(value)
+	}
+	// Output: Querying localhost:5432
+}
+
+// Example_sequenceReader_pointFreeComposition demonstrates how SequenceReader
+// enables point-free style composition of computations.
+func Example_sequenceReader_pointFreeComposition() {
+	type Config struct {
+		BaseValue int
+	}
+
+	// Step 1: Create a computation that produces a Reader
+	step1 := func(ctx context.Context) func() either.Either[error, func(Config) int] {
+		return func() either.Either[error, func(Config) int] {
+			return either.Right[error](func(cfg Config) int {
+				return cfg.BaseValue * 2
+			})
+		}
+	}
+
+	// Step 2: Sequence it to enable partial application
+	sequenced := RIOE.SequenceReader(step1)
+
+	// Step 3: Build a pipeline using point-free style
+	// Partially apply the config
+	cfg := Config{BaseValue: 10}
+
+	// Create a reusable computation with the config baked in
+	computation := F.Pipe1(
+		sequenced(cfg),
+		RIOE.Map(func(x int) int { return x + 5 }),
+	)
+
+	// Execute the pipeline
+	ctx := context.Background()
+	result := computation(ctx)()
+
+	if value, err := either.Unwrap(result); err == nil {
+		fmt.Println(value)
+	}
+	// Output: 25
+}
+
+// Example_sequenceReader_multipleEnvironments demonstrates using SequenceReader
+// to work with multiple environment types in a clean, composable way.
+func Example_sequenceReader_multipleEnvironments() {
+	type DatabaseConfig struct {
+		Host string
+		Port int
+	}
+
+	type APIConfig struct {
+		Endpoint string
+		APIKey   string
+	}
+
+	// Function that needs DatabaseConfig
+	getDatabaseURL := func(ctx context.Context) func() either.Either[error, func(DatabaseConfig) string] {
+		return func() either.Either[error, func(DatabaseConfig) string] {
+			return either.Right[error](func(cfg DatabaseConfig) string {
+				return fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
+			})
+		}
+	}
+
+	// Function that needs APIConfig
+	getAPIURL := func(ctx context.Context) func() either.Either[error, func(APIConfig) string] {
+		return func() either.Either[error, func(APIConfig) string] {
+			return either.Right[error](func(cfg APIConfig) string {
+				return cfg.Endpoint
+			})
+		}
+	}
+
+	// Sequence both to enable partial application
+	withDBConfig := RIOE.SequenceReader(getDatabaseURL)
+	withAPIConfig := RIOE.SequenceReader(getAPIURL)
+
+	// Partially apply different configs
+	dbCfg := DatabaseConfig{Host: "localhost", Port: 5432}
+	apiCfg := APIConfig{Endpoint: "https://api.example.com", APIKey: "secret"}
+
+	dbQuery := withDBConfig(dbCfg)
+	apiQuery := withAPIConfig(apiCfg)
+
+	// Execute both with the same context
+	ctx := context.Background()
+
+	dbResult := dbQuery(ctx)()
+	apiResult := apiQuery(ctx)()
+
+	if dbURL, err := either.Unwrap(dbResult); err == nil {
+		fmt.Println("Database:", dbURL)
+	}
+	if apiURL, err := either.Unwrap(apiResult); err == nil {
+		fmt.Println("API:", apiURL)
+	}
+	// Output:
+	// Database: localhost:5432
+	// API: https://api.example.com
+}
+
+// Example_sequenceReaderResult_errorHandling demonstrates how SequenceReaderResult
+// enables point-free style with proper error handling at multiple levels.
+func Example_sequenceReaderResult_errorHandling() {
+	type ValidationConfig struct {
+		MinValue int
+		MaxValue int
+	}
+
+	// A computation that can fail at both outer and inner levels
+	makeValidator := func(ctx context.Context) func() either.Either[error, func(context.Context) either.Either[error, int]] {
+		return func() either.Either[error, func(context.Context) either.Either[error, int]] {
+			// Outer level: check context
+			if ctx.Err() != nil {
+				return either.Left[func(context.Context) either.Either[error, int]](ctx.Err())
+			}
+
+			// Return inner computation
+			return either.Right[error](func(innerCtx context.Context) either.Either[error, int] {
+				// Inner level: perform validation
+				value := 42
+				if value < 0 {
+					return either.Left[int](fmt.Errorf("value too small: %d", value))
+				}
+				if value > 100 {
+					return either.Left[int](fmt.Errorf("value too large: %d", value))
+				}
+				return either.Right[error](value)
+			})
+		}
+	}
+
+	// Sequence to enable point-free composition
+	sequenced := RIOE.SequenceReaderResult(makeValidator)
+
+	// Build a pipeline with error handling
+	ctx := context.Background()
+	pipeline := F.Pipe2(
+		sequenced(ctx),
+		RIOE.Map(func(x int) int { return x * 2 }),
+		RIOE.Chain(func(x int) RIOE.ReaderIOResult[string] {
+			return RIOE.Of(fmt.Sprintf("Result: %d", x))
+		}),
+	)
+
+	result := pipeline(ctx)()
+
+	if value, err := either.Unwrap(result); err == nil {
+		fmt.Println(value)
+	}
+	// Output: Result: 84
+}
+
+// Example_sequenceReader_partialApplication demonstrates the power of partial
+// application enabled by SequenceReader for building reusable computations.
+func Example_sequenceReader_partialApplication() {
+	type ServiceConfig struct {
+		ServiceName string
+		Version     string
+	}
+
+	// Create a computation factory
+	makeServiceInfo := func(ctx context.Context) func() either.Either[error, func(ServiceConfig) string] {
+		return func() either.Either[error, func(ServiceConfig) string] {
+			return either.Right[error](func(cfg ServiceConfig) string {
+				return fmt.Sprintf("%s v%s", cfg.ServiceName, cfg.Version)
+			})
+		}
+	}
+
+	// Sequence it
+	sequenced := RIOE.SequenceReader(makeServiceInfo)
+
+	// Create multiple service configurations
+	authConfig := ServiceConfig{ServiceName: "AuthService", Version: "1.0.0"}
+	userConfig := ServiceConfig{ServiceName: "UserService", Version: "2.1.0"}
+
+	// Partially apply each config to create specialized computations
+	getAuthInfo := sequenced(authConfig)
+	getUserInfo := sequenced(userConfig)
+
+	// These can now be reused across different contexts
+	ctx := context.Background()
+
+	authResult := getAuthInfo(ctx)()
+	userResult := getUserInfo(ctx)()
+
+	if auth, err := either.Unwrap(authResult); err == nil {
+		fmt.Println(auth)
+	}
+	if user, err := either.Unwrap(userResult); err == nil {
+		fmt.Println(user)
+	}
+	// Output:
+	// AuthService v1.0.0
+	// UserService v2.1.0
+}
+
+// Example_sequenceReader_testingBenefits demonstrates how SequenceReader
+// makes testing easier by allowing you to inject test dependencies.
+func Example_sequenceReader_testingBenefits() {
+	// Simple logger that collects messages
+	type SimpleLogger struct {
+		Messages []string
+	}
+
+	// A computation that depends on a logger (using the struct directly)
+	makeLoggingOperation := func(ctx context.Context) func() either.Either[error, func(*SimpleLogger) string] {
+		return func() either.Either[error, func(*SimpleLogger) string] {
+			return either.Right[error](func(logger *SimpleLogger) string {
+				logger.Messages = append(logger.Messages, "Operation started")
+				result := "Success"
+				logger.Messages = append(logger.Messages, fmt.Sprintf("Operation completed: %s", result))
+				return result
+			})
+		}
+	}
+
+	// Sequence to enable dependency injection
+	sequenced := RIOE.SequenceReader(makeLoggingOperation)
+
+	// Inject a test logger
+	testLogger := &SimpleLogger{Messages: []string{}}
+	operation := sequenced(testLogger)
+
+	// Execute
+	ctx := context.Background()
+	result := operation(ctx)()
+
+	if value, err := either.Unwrap(result); err == nil {
+		fmt.Println("Result:", value)
+		fmt.Println("Logs:", len(testLogger.Messages))
+	}
+	// Output:
+	// Result: Success
+	// Logs: 2
+}

v2/context/readerioresult/flip_test.go

@@ -0,0 +1,866 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/IBM/fp-go/v2/either"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSequenceReader(t *testing.T) {
+	t.Run("flips parameter order for simple types", func(t *testing.T) {
+		// Original: ReaderIOResult[Reader[string, int]]
+		// = func(context.Context) func() Either[error, func(string) int]
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				return either.Right[error](func(s string) int {
+					return 10 + len(s)
+				})
+			}
+		}
+
+		// Sequenced: func(string) func(context.Context) IOResult[int]
+		// The Reader environment (string) is now the first parameter
+		sequenced := SequenceReader(original)
+
+		ctx := context.Background()
+
+		// Test original
+		result1 := original(ctx)()
+		assert.True(t, either.IsRight(result1))
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1("hello")
+		assert.Equal(t, 15, value1)
+
+		// Test sequenced - note the flipped order: string first, then context
+		result2 := sequenced("hello")(ctx)()
+		assert.True(t, either.IsRight(result2))
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 15, value2)
+	})
+
+	t.Run("flips parameter order for struct types", func(t *testing.T) {
+		type Database struct {
+			ConnectionString string
+		}
+
+		// Original: ReaderIOResult[Reader[Database, string]]
+		query := func(ctx context.Context) func() Either[Reader[Database, string]] {
+			return func() Either[Reader[Database, string]] {
+				if ctx.Err() != nil {
+					return either.Left[Reader[Database, string]](ctx.Err())
+				}
+				return either.Right[error](func(db Database) string {
+					return fmt.Sprintf("Query on %s", db.ConnectionString)
+				})
+			}
+		}
+
+		db := Database{ConnectionString: "localhost:5432"}
+		ctx := context.Background()
+
+		expected := "Query on localhost:5432"
+
+		// Sequence it
+		sequenced := SequenceReader(query)
+
+		// Test original with valid inputs
+		result1 := query(ctx)()
+		assert.True(t, either.IsRight(result1))
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1(db)
+		assert.Equal(t, expected, value1)
+
+		// Test sequenced with valid inputs - Database first, then context
+		result2 := sequenced(db)(ctx)()
+		assert.True(t, either.IsRight(result2))
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, expected, value2)
+	})
+
+	t.Run("preserves outer error", func(t *testing.T) {
+		expectedError := errors.New("outer error")
+
+		// Original that fails at outer level
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				return either.Left[Reader[string, int]](expectedError)
+			}
+		}
+
+		ctx := context.Background()
+
+		// Test original with error
+		result1 := original(ctx)()
+		assert.True(t, either.IsLeft(result1))
+		_, err1 := either.Unwrap(result1)
+		assert.Equal(t, expectedError, err1)
+
+		// Test sequenced - the outer error is preserved
+		sequenced := SequenceReader(original)
+		result2 := sequenced("test")(ctx)()
+		assert.True(t, either.IsLeft(result2))
+		_, err2 := either.Unwrap(result2)
+		assert.Equal(t, expectedError, err2)
+	})
+
+	t.Run("preserves computation logic", func(t *testing.T) {
+		// Original function
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				return either.Right[error](func(s string) int {
+					return 3 * len(s)
+				})
+			}
+		}
+
+		ctx := context.Background()
+
+		// Sequence
+		sequenced := SequenceReader(original)
+
+		// Test that sequence produces correct results
+		result1 := original(ctx)()
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1("test")
+
+		result2 := sequenced("test")(ctx)()
+		value2, _ := either.Unwrap(result2)
+
+		assert.Equal(t, value1, value2)
+		assert.Equal(t, 12, value2) // 3 * 4
+	})
+
+	t.Run("works with zero values", func(t *testing.T) {
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				return either.Right[error](func(s string) int {
+					return len(s)
+				})
+			}
+		}
+
+		ctx := context.Background()
+		sequenced := SequenceReader(original)
+
+		// Test with zero values
+		result1 := original(ctx)()
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1("")
+		assert.Equal(t, 0, value1)
+
+		result2 := sequenced("")(ctx)()
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 0, value2)
+	})
+
+	t.Run("respects context cancellation", func(t *testing.T) {
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				if ctx.Err() != nil {
+					return either.Left[Reader[string, int]](ctx.Err())
+				}
+				return either.Right[error](func(s string) int {
+					return len(s)
+				})
+			}
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+
+		sequenced := SequenceReader(original)
+
+		result := sequenced("test")(ctx)()
+		assert.True(t, either.IsLeft(result))
+		_, err := either.Unwrap(result)
+		assert.Equal(t, context.Canceled, err)
+	})
+
+	t.Run("enables point-free style with partial application", func(t *testing.T) {
+		type Config struct {
+			Multiplier int
+		}
+
+		// Original computation
+		original := func(ctx context.Context) func() Either[Reader[Config, int]] {
+			return func() Either[Reader[Config, int]] {
+				return either.Right[error](func(cfg Config) int {
+					return cfg.Multiplier * 10
+				})
+			}
+		}
+
+		// Sequence to enable partial application
+		sequenced := SequenceReader(original)
+
+		// Partially apply the Config
+		cfg := Config{Multiplier: 5}
+		withConfig := sequenced(cfg)
+
+		// Now we have a ReaderIOResult[int] that can be used in different contexts
+		ctx1 := context.Background()
+		result1 := withConfig(ctx1)()
+		assert.True(t, either.IsRight(result1))
+		value1, _ := either.Unwrap(result1)
+		assert.Equal(t, 50, value1)
+
+		// Can reuse with different context
+		ctx2 := context.Background()
+		result2 := withConfig(ctx2)()
+		assert.True(t, either.IsRight(result2))
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 50, value2)
+	})
+}
+
+func TestSequenceReaderIO(t *testing.T) {
+	t.Run("flips parameter order for simple types", func(t *testing.T) {
+		// Original: ReaderIOResult[ReaderIO[int]]
+		// = func(context.Context) func() Either[error, func(context.Context) func() int]
+		original := func(ctx context.Context) func() Either[ReaderIO[int]] {
+			return func() Either[ReaderIO[int]] {
+				return either.Right[error](func(innerCtx context.Context) func() int {
+					return func() int {
+						return 20
+					}
+				})
+			}
+		}
+
+		ctx := context.Background()
+		sequenced := SequenceReaderIO(original)
+
+		// Test original
+		result1 := original(ctx)()
+		assert.True(t, either.IsRight(result1))
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1(ctx)()
+		assert.Equal(t, 20, value1)
+
+		// Test sequenced - context first, then context again for inner ReaderIO
+		result2 := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsRight(result2))
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 20, value2)
+	})
+
+	t.Run("preserves outer error", func(t *testing.T) {
+		expectedError := errors.New("outer error")
+
+		// Original that fails at outer level
+		original := func(ctx context.Context) func() Either[ReaderIO[int]] {
+			return func() Either[ReaderIO[int]] {
+				return either.Left[ReaderIO[int]](expectedError)
+			}
+		}
+
+		ctx := context.Background()
+
+		// Test original with error
+		result1 := original(ctx)()
+		assert.True(t, either.IsLeft(result1))
+		_, err1 := either.Unwrap(result1)
+		assert.Equal(t, expectedError, err1)
+
+		// Test sequenced - the outer error is preserved
+		sequenced := SequenceReaderIO(original)
+		result2 := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result2))
+		_, err2 := either.Unwrap(result2)
+		assert.Equal(t, expectedError, err2)
+	})
+
+	t.Run("respects context cancellation in outer context", func(t *testing.T) {
+		original := func(ctx context.Context) func() Either[ReaderIO[int]] {
+			return func() Either[ReaderIO[int]] {
+				if ctx.Err() != nil {
+					return either.Left[ReaderIO[int]](ctx.Err())
+				}
+				return either.Right[error](func(innerCtx context.Context) func() int {
+					return func() int {
+						return 20
+					}
+				})
+			}
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+
+		sequenced := SequenceReaderIO(original)
+
+		result := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result))
+		_, err := either.Unwrap(result)
+		assert.Equal(t, context.Canceled, err)
+	})
+}
+
+func TestSequenceReaderResult(t *testing.T) {
+	t.Run("flips parameter order for simple types", func(t *testing.T) {
+		// Original: ReaderIOResult[ReaderResult[int]]
+		// = func(context.Context) func() Either[error, func(context.Context) Either[error, int]]
+		original := func(ctx context.Context) func() Either[ReaderResult[int]] {
+			return func() Either[ReaderResult[int]] {
+				return either.Right[error](func(innerCtx context.Context) Either[int] {
+					return either.Right[error](20)
+				})
+			}
+		}
+
+		ctx := context.Background()
+		sequenced := SequenceReaderResult(original)
+
+		// Test original
+		result1 := original(ctx)()
+		assert.True(t, either.IsRight(result1))
+		innerFunc1, _ := either.Unwrap(result1)
+		innerResult1 := innerFunc1(ctx)
+		assert.True(t, either.IsRight(innerResult1))
+		value1, _ := either.Unwrap(innerResult1)
+		assert.Equal(t, 20, value1)
+
+		// Test sequenced
+		result2 := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsRight(result2))
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 20, value2)
+	})
+
+	t.Run("preserves outer error", func(t *testing.T) {
+		expectedError := errors.New("outer error")
+
+		// Original that fails at outer level
+		original := func(ctx context.Context) func() Either[ReaderResult[int]] {
+			return func() Either[ReaderResult[int]] {
+				return either.Left[ReaderResult[int]](expectedError)
+			}
+		}
+
+		ctx := context.Background()
+
+		// Test original with error
+		result1 := original(ctx)()
+		assert.True(t, either.IsLeft(result1))
+		_, err1 := either.Unwrap(result1)
+		assert.Equal(t, expectedError, err1)
+
+		// Test sequenced - the outer error is preserved
+		sequenced := SequenceReaderResult(original)
+		result2 := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result2))
+		_, err2 := either.Unwrap(result2)
+		assert.Equal(t, expectedError, err2)
+	})
+
+	t.Run("preserves inner error", func(t *testing.T) {
+		expectedError := errors.New("inner error")
+
+		// Original that fails at inner level
+		original := func(ctx context.Context) func() Either[ReaderResult[int]] {
+			return func() Either[ReaderResult[int]] {
+				return either.Right[error](func(innerCtx context.Context) Either[int] {
+					return either.Left[int](expectedError)
+				})
+			}
+		}
+
+		ctx := context.Background()
+
+		// Test original with inner error
+		result1 := original(ctx)()
+		assert.True(t, either.IsRight(result1))
+		innerFunc1, _ := either.Unwrap(result1)
+		innerResult1 := innerFunc1(ctx)
+		assert.True(t, either.IsLeft(innerResult1))
+		_, innerErr1 := either.Unwrap(innerResult1)
+		assert.Equal(t, expectedError, innerErr1)
+
+		// Test sequenced with inner error
+		sequenced := SequenceReaderResult(original)
+		result2 := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result2))
+		_, innerErr2 := either.Unwrap(result2)
+		assert.Equal(t, expectedError, innerErr2)
+	})
+
+	t.Run("handles errors at different levels", func(t *testing.T) {
+		// Original that can fail at both levels
+		makeOriginal := func(x int) ReaderIOResult[ReaderResult[int]] {
+			return func(ctx context.Context) func() Either[ReaderResult[int]] {
+				return func() Either[ReaderResult[int]] {
+					if x < -10 {
+						return either.Left[ReaderResult[int]](errors.New("outer: too negative"))
+					}
+					return either.Right[error](func(innerCtx context.Context) Either[int] {
+						if x < 0 {
+							return either.Left[int](errors.New("inner: negative value"))
+						}
+						return either.Right[error](x * 2)
+					})
+				}
+			}
+		}
+
+		ctx := context.Background()
+
+		// Test outer error
+		sequenced1 := SequenceReaderResult(makeOriginal(-20))
+		result1 := sequenced1(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result1))
+		_, err1 := either.Unwrap(result1)
+		assert.Contains(t, err1.Error(), "outer")
+
+		// Test inner error
+		sequenced2 := SequenceReaderResult(makeOriginal(-5))
+		result2 := sequenced2(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result2))
+		_, err2 := either.Unwrap(result2)
+		assert.Contains(t, err2.Error(), "inner")
+
+		// Test success
+		sequenced3 := SequenceReaderResult(makeOriginal(10))
+		result3 := sequenced3(ctx)(ctx)()
+		assert.True(t, either.IsRight(result3))
+		value3, _ := either.Unwrap(result3)
+		assert.Equal(t, 20, value3)
+	})
+
+	t.Run("respects context cancellation", func(t *testing.T) {
+		original := func(ctx context.Context) func() Either[ReaderResult[int]] {
+			return func() Either[ReaderResult[int]] {
+				if ctx.Err() != nil {
+					return either.Left[ReaderResult[int]](ctx.Err())
+				}
+				return either.Right[error](func(innerCtx context.Context) Either[int] {
+					if innerCtx.Err() != nil {
+						return either.Left[int](innerCtx.Err())
+					}
+					return either.Right[error](20)
+				})
+			}
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+
+		sequenced := SequenceReaderResult(original)
+
+		result := sequenced(ctx)(ctx)()
+		assert.True(t, either.IsLeft(result))
+		_, err := either.Unwrap(result)
+		assert.Equal(t, context.Canceled, err)
+	})
+}
+
+func TestSequenceEdgeCases(t *testing.T) {
+	t.Run("works with empty struct", func(t *testing.T) {
+		type Empty struct{}
+
+		original := func(ctx context.Context) func() Either[Reader[Empty, int]] {
+			return func() Either[Reader[Empty, int]] {
+				return either.Right[error](func(e Empty) int {
+					return 20
+				})
+			}
+		}
+
+		ctx := context.Background()
+		empty := Empty{}
+		sequenced := SequenceReader(original)
+
+		result1 := original(ctx)()
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1(empty)
+		assert.Equal(t, 20, value1)
+
+		result2 := sequenced(empty)(ctx)()
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 20, value2)
+	})
+
+	t.Run("works with pointer types", func(t *testing.T) {
+		type Data struct {
+			Value int
+		}
+
+		original := func(ctx context.Context) func() Either[Reader[*Data, int]] {
+			return func() Either[Reader[*Data, int]] {
+				return either.Right[error](func(d *Data) int {
+					if d == nil {
+						return 42
+					}
+					return 42 + d.Value
+				})
+			}
+		}
+
+		ctx := context.Background()
+		data := &Data{Value: 100}
+		sequenced := SequenceReader(original)
+
+		// Test with non-nil pointer
+		result1 := original(ctx)()
+		innerFunc1, _ := either.Unwrap(result1)
+		value1 := innerFunc1(data)
+		assert.Equal(t, 142, value1)
+
+		result2 := sequenced(data)(ctx)()
+		value2, _ := either.Unwrap(result2)
+		assert.Equal(t, 142, value2)
+
+		// Test with nil pointer
+		result3 := sequenced(nil)(ctx)()
+		value3, _ := either.Unwrap(result3)
+		assert.Equal(t, 42, value3)
+	})
+
+	t.Run("maintains referential transparency", func(t *testing.T) {
+		// The same inputs should always produce the same outputs
+		original := func(ctx context.Context) func() Either[Reader[string, int]] {
+			return func() Either[Reader[string, int]] {
+				return either.Right[error](func(s string) int {
+					return 10 + len(s)
+				})
+			}
+		}
+
+		ctx := context.Background()
+		sequenced := SequenceReader(original)
+
+		// Call multiple times with same inputs
+		for range 5 {
+			result1 := original(ctx)()
+			innerFunc1, _ := either.Unwrap(result1)
+			value1 := innerFunc1("hello")
+			assert.Equal(t, 15, value1)
+
+			result2 := sequenced("hello")(ctx)()
+			value2, _ := either.Unwrap(result2)
+			assert.Equal(t, 15, value2)
+		}
+	})
+}
+
+func TestTraverseReader(t *testing.T) {
+	t.Run("basic transformation with Reader dependency", func(t *testing.T) {
+		type Config struct {
+			Multiplier int
+		}
+
+		// Original computation
+		original := Right(10)
+
+		// Reader-based transformation
+		multiply := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x * cfg.Multiplier
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(multiply)
+		result := traversed(original)
+
+		// Provide Config and execute
+		cfg := Config{Multiplier: 5}
+		ctx := context.Background()
+		finalResult := result(cfg)(ctx)()
+
+		assert.True(t, either.IsRight(finalResult))
+		value, _ := either.Unwrap(finalResult)
+		assert.Equal(t, 50, value)
+	})
+
+	t.Run("preserves outer error", func(t *testing.T) {
+		type Config struct {
+			Multiplier int
+		}
+
+		expectedError := errors.New("computation failed")
+
+		// Original computation that fails
+		original := Left[int](expectedError)
+
+		// Reader-based transformation (won't be called)
+		multiply := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x * cfg.Multiplier
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(multiply)
+		result := traversed(original)
+
+		// Provide Config and execute
+		cfg := Config{Multiplier: 5}
+		ctx := context.Background()
+		finalResult := result(cfg)(ctx)()
+
+		assert.True(t, either.IsLeft(finalResult))
+		_, err := either.Unwrap(finalResult)
+		assert.Equal(t, expectedError, err)
+	})
+
+	t.Run("works with different types", func(t *testing.T) {
+		type Database struct {
+			Prefix string
+		}
+
+		// Original computation producing an int
+		original := Right(42)
+
+		// Reader-based transformation: int -> string using Database
+		format := func(x int) func(Database) string {
+			return func(db Database) string {
+				return fmt.Sprintf("%s:%d", db.Prefix, x)
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(format)
+		result := traversed(original)
+
+		// Provide Database and execute
+		db := Database{Prefix: "ID"}
+		ctx := context.Background()
+		finalResult := result(db)(ctx)()
+
+		assert.True(t, either.IsRight(finalResult))
+		value, _ := either.Unwrap(finalResult)
+		assert.Equal(t, "ID:42", value)
+	})
+
+	t.Run("works with struct environments", func(t *testing.T) {
+		type Settings struct {
+			Prefix string
+			Suffix string
+		}
+
+		// Original computation
+		original := Right("value")
+
+		// Reader-based transformation using Settings
+		decorate := func(s string) func(Settings) string {
+			return func(settings Settings) string {
+				return settings.Prefix + s + settings.Suffix
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(decorate)
+		result := traversed(original)
+
+		// Provide Settings and execute
+		settings := Settings{Prefix: "[", Suffix: "]"}
+		ctx := context.Background()
+		finalResult := result(settings)(ctx)()
+
+		assert.True(t, either.IsRight(finalResult))
+		value, _ := either.Unwrap(finalResult)
+		assert.Equal(t, "[value]", value)
+	})
+
+	t.Run("enables partial application", func(t *testing.T) {
+		type Config struct {
+			Factor int
+		}
+
+		// Original computation
+		original := Right(10)
+
+		// Reader-based transformation
+		scale := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x * cfg.Factor
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(scale)
+		result := traversed(original)
+
+		// Partially apply Config
+		cfg := Config{Factor: 3}
+		withConfig := result(cfg)
+
+		// Can now use with different contexts
+		ctx1 := context.Background()
+		finalResult1 := withConfig(ctx1)()
+		assert.True(t, either.IsRight(finalResult1))
+		value1, _ := either.Unwrap(finalResult1)
+		assert.Equal(t, 30, value1)
+
+		// Reuse with different context
+		ctx2 := context.Background()
+		finalResult2 := withConfig(ctx2)()
+		assert.True(t, either.IsRight(finalResult2))
+		value2, _ := either.Unwrap(finalResult2)
+		assert.Equal(t, 30, value2)
+	})
+
+	t.Run("respects context cancellation", func(t *testing.T) {
+		type Config struct {
+			Value int
+		}
+
+		// Original computation that checks context
+		original := func(ctx context.Context) func() Either[int] {
+			return func() Either[int] {
+				if ctx.Err() != nil {
+					return either.Left[int](ctx.Err())
+				}
+				return either.Right[error](10)
+			}
+		}
+
+		// Reader-based transformation
+		multiply := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x * cfg.Value
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(multiply)
+		result := traversed(original)
+
+		// Use canceled context
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+
+		cfg := Config{Value: 5}
+		finalResult := result(cfg)(ctx)()
+
+		assert.True(t, either.IsLeft(finalResult))
+		_, err := either.Unwrap(finalResult)
+		assert.Equal(t, context.Canceled, err)
+	})
+
+	t.Run("works with zero values", func(t *testing.T) {
+		type Config struct {
+			Offset int
+		}
+
+		// Original computation with zero value
+		original := Right(0)
+
+		// Reader-based transformation
+		add := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x + cfg.Offset
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(add)
+		result := traversed(original)
+
+		// Provide Config with zero offset
+		cfg := Config{Offset: 0}
+		ctx := context.Background()
+		finalResult := result(cfg)(ctx)()
+
+		assert.True(t, either.IsRight(finalResult))
+		value, _ := either.Unwrap(finalResult)
+		assert.Equal(t, 0, value)
+	})
+
+	t.Run("chains multiple transformations", func(t *testing.T) {
+		type Config struct {
+			Multiplier int
+		}
+
+		// Original computation
+		original := Right(5)
+
+		// First Reader-based transformation
+		multiply := func(x int) Reader[Config, int] {
+			return func(cfg Config) int {
+				return x * cfg.Multiplier
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(multiply)
+		result := traversed(original)
+
+		// Provide Config and execute
+		cfg := Config{Multiplier: 4}
+		ctx := context.Background()
+		finalResult := result(cfg)(ctx)()
+
+		assert.True(t, either.IsRight(finalResult))
+		value, _ := either.Unwrap(finalResult)
+		assert.Equal(t, 20, value) // 5 * 4 = 20
+	})
+
+	t.Run("works with complex Reader logic", func(t *testing.T) {
+		type ValidationRules struct {
+			MinValue int
+			MaxValue int
+		}
+
+		// Original computation
+		original := Right(50)
+
+		// Reader-based transformation with validation logic
+		validate := func(x int) func(ValidationRules) int {
+			return func(rules ValidationRules) int {
+				if x < rules.MinValue {
+					return rules.MinValue
+				}
+				if x > rules.MaxValue {
+					return rules.MaxValue
+				}
+				return x
+			}
+		}
+
+		// Apply TraverseReader
+		traversed := TraverseReader(validate)
+		result := traversed(original)
+
+		// Test with value within range
+		rules1 := ValidationRules{MinValue: 0, MaxValue: 100}
+		ctx := context.Background()
+		finalResult1 := result(rules1)(ctx)()
+		assert.True(t, either.IsRight(finalResult1))
+		value1, _ := either.Unwrap(finalResult1)
+		assert.Equal(t, 50, value1)
+
+		// Test with value above max
+		rules2 := ValidationRules{MinValue: 0, MaxValue: 30}
+		finalResult2 := result(rules2)(ctx)()
+		assert.True(t, either.IsRight(finalResult2))
+		value2, _ := either.Unwrap(finalResult2)
+		assert.Equal(t, 30, value2) // Clamped to max
+
+		// Test with value below min
+		rules3 := ValidationRules{MinValue: 60, MaxValue: 100}
+		finalResult3 := result(rules3)(ctx)()
+		assert.True(t, either.IsRight(finalResult3))
+		value3, _ := either.Unwrap(finalResult3)
+		assert.Equal(t, 60, value3) // Clamped to min
+	})
+}

v2/context/readerioresult/logging.go

@@ -0,0 +1,732 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package readerioresult provides logging utilities for ReaderIOResult computations.
+// It includes functions for entry/exit logging with timing, correlation IDs, and context management.
+package readerioresult
+
+import (
+	"context"
+	"log/slog"
+	"sync/atomic"
+	"time"
+
+	"github.com/IBM/fp-go/v2/context/readerio"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/logging"
+	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/reader"
+	"github.com/IBM/fp-go/v2/result"
+)
+
+type (
+	// loggingContextKeyType is the type used as a key for storing logging information in context.Context
+	loggingContextKeyType int
+
+	// LoggingID is a unique identifier assigned to each logged operation for correlation
+	LoggingID uint64
+
+	// loggingContext holds the logging state for a computation, including timing,
+	// correlation ID, logger instance, and whether logging is enabled.
+	loggingContext struct {
+		contextID LoggingID    // Unique identifier for this logged operation
+		startTime time.Time    // When the operation started (for duration calculation)
+		logger    *slog.Logger // The logger instance to use for this operation
+		isEnabled bool         // Whether logging is enabled for this operation
+	}
+)
+
+var (
+	// loggingContextKey is the singleton key used to store/retrieve logging data from context
+	loggingContextKey loggingContextKeyType
+
+	// loggingCounter is an atomic counter that generates unique LoggingIDs
+	loggingCounter atomic.Uint64
+
+	loggingContextValue = F.Bind2nd(context.Context.Value, any(loggingContextKey))
+
+	withLoggingContextValue = F.Bind2of3(context.WithValue)(any(loggingContextKey))
+
+	// getLoggingContext retrieves the logging information (start time and ID) from the context.
+	// It returns a Pair containing the start time and the logging ID.
+	// This function assumes the context contains logging information; it will panic if not present.
+	getLoggingContext = F.Flow3(
+		loggingContextValue,
+		option.ToType[loggingContext],
+		option.GetOrElse(getDefaultLoggingContext),
+	)
+)
+
+// getDefaultLoggingContext returns a default logging context with the global logger.
+// This is used when no logging context is found in the context.Context.
+func getDefaultLoggingContext() loggingContext {
+	return loggingContext{
+		logger: logging.GetLogger(),
+	}
+}
+
+// withLoggingContext creates an endomorphism that adds a logging context to a context.Context.
+// This is used internally to store logging state in the context for retrieval by nested operations.
+//
+// Parameters:
+//   - lctx: The logging context to store
+//
+// Returns:
+//   - An endomorphism that adds the logging context to a context.Context
+func withLoggingContext(lctx loggingContext) Endomorphism[context.Context] {
+	return F.Bind2nd(withLoggingContextValue, any(lctx))
+}
+
+// LogEntryExitF creates a customizable operator that wraps a ReaderIOResult computation with entry/exit callbacks.
+//
+// This is a more flexible version of LogEntryExit that allows you to provide custom callbacks for
+// entry and exit events. The onEntry callback receives the current context and can return a modified
+// context (e.g., with additional logging information). The onExit callback receives the computation
+// result and can perform custom logging, metrics collection, or cleanup.
+//
+// The function uses the bracket pattern to ensure that:
+//   - The onEntry callback is executed before the computation starts
+//   - The computation runs with the context returned by onEntry
+//   - The onExit callback is executed after the computation completes (success or failure)
+//   - The original result is preserved and returned unchanged
+//   - Cleanup happens even if the computation fails
+//
+// Type Parameters:
+//   - A: The success type of the ReaderIOResult
+//   - ANY: The return type of the onExit callback (typically any)
+//
+// Parameters:
+//   - onEntry: A ReaderIO that receives the current context and returns a (possibly modified) context.
+//     This is executed before the computation starts. Use this for logging entry, adding context values,
+//     starting timers, or initialization logic.
+//   - onExit: A Kleisli function that receives the Result[A] and returns a ReaderIO[ANY].
+//     This is executed after the computation completes, regardless of success or failure.
+//     Use this for logging exit, recording metrics, cleanup, or finalization logic.
+//
+// Returns:
+//   - An Operator that wraps the ReaderIOResult computation with the custom entry/exit callbacks
+//
+// Example with custom context modification:
+//
+//	type RequestID string
+//
+//	logOp := LogEntryExitF[User, any](
+//	    func(ctx context.Context) IO[context.Context] {
+//	        return func() context.Context {
+//	            reqID := RequestID(uuid.New().String())
+//	            log.Printf("[%s] Starting operation", reqID)
+//	            return context.WithValue(ctx, "requestID", reqID)
+//	        }
+//	    },
+//	    func(res Result[User]) ReaderIO[any] {
+//	        return func(ctx context.Context) IO[any] {
+//	            return func() any {
+//	                reqID := ctx.Value("requestID").(RequestID)
+//	                return F.Pipe1(
+//	                    res,
+//	                    result.Fold(
+//	                        func(err error) any {
+//	                            log.Printf("[%s] Operation failed: %v", reqID, err)
+//	                            return nil
+//	                        },
+//	                        func(_ User) any {
+//	                            log.Printf("[%s] Operation succeeded", reqID)
+//	                            return nil
+//	                        },
+//	                    ),
+//	                )
+//	            }
+//	        }
+//	    },
+//	)
+//
+//	wrapped := logOp(fetchUser(123))
+//
+// Example with metrics collection:
+//
+//	import "github.com/prometheus/client_golang/prometheus"
+//
+//	metricsOp := LogEntryExitF[Response, any](
+//	    func(ctx context.Context) IO[context.Context] {
+//	        return func() context.Context {
+//	            requestCount.WithLabelValues("api_call", "started").Inc()
+//	            return context.WithValue(ctx, "startTime", time.Now())
+//	        }
+//	    },
+//	    func(res Result[Response]) ReaderIO[any] {
+//	        return func(ctx context.Context) IO[any] {
+//	            return func() any {
+//	                startTime := ctx.Value("startTime").(time.Time)
+//	                duration := time.Since(startTime).Seconds()
+//
+//	                return F.Pipe1(
+//	                    res,
+//	                    result.Fold(
+//	                        func(err error) any {
+//	                            requestCount.WithLabelValues("api_call", "error").Inc()
+//	                            requestDuration.WithLabelValues("api_call", "error").Observe(duration)
+//	                            return nil
+//	                        },
+//	                        func(_ Response) any {
+//	                            requestCount.WithLabelValues("api_call", "success").Inc()
+//	                            requestDuration.WithLabelValues("api_call", "success").Observe(duration)
+//	                            return nil
+//	                        },
+//	                    ),
+//	                )
+//	            }
+//	        }
+//	    },
+//	)
+//
+// Use Cases:
+//   - Custom context modification: Adding request IDs, trace IDs, or other context values
+//   - Structured logging: Integration with zap, logrus, or other structured loggers
+//   - Metrics collection: Recording operation durations, success/failure rates
+//   - Distributed tracing: OpenTelemetry, Jaeger integration
+//   - Custom monitoring: Application-specific monitoring and alerting
+//
+// Note: LogEntryExit is implemented using LogEntryExitF with standard logging and context management.
+// Use LogEntryExitF when you need more control over the entry/exit behavior or context modification.
+func LogEntryExitF[A, ANY any](
+	onEntry ReaderIO[context.Context],
+	onExit readerio.Kleisli[Result[A], ANY],
+) Operator[A, A] {
+	bracket := F.Bind13of3(readerio.Bracket[context.Context, Result[A], ANY])(onEntry, func(newCtx context.Context, res Result[A]) ReaderIO[ANY] {
+		return readerio.FromIO(onExit(res)(newCtx)) // Get the exit callback for this result
+	})
+
+	return func(src ReaderIOResult[A]) ReaderIOResult[A] {
+		return bracket(F.Flow2(
+			src,
+			FromIOResult,
+		))
+	}
+}
+
+// onEntry creates a ReaderIO that handles the entry logging for an operation.
+// It generates a unique logging ID, captures the start time, and logs the entry message.
+// The logging context is stored in the context.Context for later retrieval.
+//
+// Parameters:
+//   - logLevel: The slog.Level to use for logging (e.g., slog.LevelInfo, slog.LevelDebug)
+//   - cb: Callback function to retrieve the logger from the context
+//   - nameAttr: The slog.Attr containing the operation name
+//
+// Returns:
+//   - A ReaderIO that prepares the context with logging information and logs the entry
+func onEntry(
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	nameAttr slog.Attr,
+) ReaderIO[context.Context] {
+
+	return func(ctx context.Context) IO[context.Context] {
+		// logger
+		logger := cb(ctx)
+
+		return func() context.Context {
+			// check if the logger is enabled
+			if logger.Enabled(ctx, logLevel) {
+				// Generate unique logging ID and capture start time
+				contextID := LoggingID(loggingCounter.Add(1))
+				startTime := time.Now()
+
+				newLogger := logger.With("ID", contextID)
+
+				// log using ID
+				newLogger.LogAttrs(ctx, logLevel, "[entering]", nameAttr)
+
+				withCtx := withLoggingContext(loggingContext{
+					contextID: contextID,
+					startTime: startTime,
+					logger:    newLogger,
+					isEnabled: true,
+				})
+				withLogger := logging.WithLogger(newLogger)
+
+				return withCtx(withLogger(ctx))
+			}
+			// logging disabled
+			withCtx := withLoggingContext(loggingContext{
+				logger:    logger,
+				isEnabled: false,
+			})
+			return withCtx(ctx)
+		}
+	}
+}
+
+// onExitAny creates a Kleisli function that handles exit logging for an operation.
+// It logs either success or error based on the Result, including the operation duration.
+// Only logs if logging was enabled during entry (checked via loggingContext.isEnabled).
+//
+// Parameters:
+//   - logLevel: The slog.Level to use for logging
+//   - nameAttr: The slog.Attr containing the operation name
+//
+// Returns:
+//   - A Kleisli function that logs the exit/error and returns nil
+func onExitAny(
+	logLevel slog.Level,
+	nameAttr slog.Attr,
+) readerio.Kleisli[Result[any], any] {
+	return func(res Result[any]) ReaderIO[any] {
+		return func(ctx context.Context) IO[any] {
+			value := getLoggingContext(ctx)
+
+			if value.isEnabled {
+
+				return func() any {
+					// Retrieve logging information from context
+					durationAttr := slog.Duration("duration", time.Since(value.startTime))
+
+					// Log error with ID and duration
+					onError := func(err error) any {
+						value.logger.LogAttrs(ctx, logLevel, "[throwing]",
+							nameAttr,
+							durationAttr,
+							slog.Any("error", err))
+						return nil
+					}
+
+					// Log success with ID and duration
+					onSuccess := func(_ any) any {
+						value.logger.LogAttrs(ctx, logLevel, "[exiting ]", nameAttr, durationAttr)
+						return nil
+					}
+
+					return F.Pipe1(
+						res,
+						result.Fold(onError, onSuccess),
+					)
+				}
+			}
+			// nothing to do
+			return io.Of[any](nil)
+		}
+	}
+}
+
+// LogEntryExitWithCallback creates an operator that logs entry and exit of a ReaderIOResult computation
+// using a custom logger callback and log level. This provides more control than LogEntryExit.
+//
+// This function allows you to:
+//   - Use a custom log level (Debug, Info, Warn, Error)
+//   - Retrieve the logger from the context using a custom callback
+//   - Control whether logging is enabled based on the logger's configuration
+//
+// Type Parameters:
+//   - A: The success type of the ReaderIOResult
+//
+// Parameters:
+//   - logLevel: The slog.Level to use for all log messages (entry, exit, error)
+//   - cb: Callback function to retrieve the *slog.Logger from the context
+//   - name: A descriptive name for the operation
+//
+// Returns:
+//   - An Operator that wraps the ReaderIOResult with customizable logging
+//
+// Example with custom log level:
+//
+//	// Log at debug level
+//	debugOp := LogEntryExitWithCallback[User](
+//	    slog.LevelDebug,
+//	    logging.GetLoggerFromContext,
+//	    "fetchUser",
+//	)
+//	result := debugOp(fetchUser(123))
+//
+// Example with custom logger callback:
+//
+//	type loggerKey int
+//	const myLoggerKey loggerKey = 0
+//
+//	getMyLogger := func(ctx context.Context) *slog.Logger {
+//	    if logger := ctx.Value(myLoggerKey); logger != nil {
+//	        return logger.(*slog.Logger)
+//	    }
+//	    return slog.Default()
+//	}
+//
+//	customOp := LogEntryExitWithCallback[Data](
+//	    slog.LevelInfo,
+//	    getMyLogger,
+//	    "processData",
+//	)
+func LogEntryExitWithCallback[A any](
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	name string) Operator[A, A] {
+
+	nameAttr := slog.String("name", name)
+
+	return LogEntryExitF(
+		onEntry(logLevel, cb, nameAttr),
+		F.Flow2(
+			result.MapTo[A, any](nil),
+			onExitAny(logLevel, nameAttr),
+		),
+	)
+}
+
+// LogEntryExit creates an operator that logs the entry and exit of a ReaderIOResult computation with timing and correlation IDs.
+//
+// This function wraps a ReaderIOResult computation with automatic logging that tracks:
+//   - Entry: Logs when the computation starts with "[entering <id>] <name>"
+//   - Exit: Logs when the computation completes successfully with "[exiting  <id>] <name> [duration]"
+//   - Error: Logs when the computation fails with "[throwing <id>] <name> [duration]: <error>"
+//
+// Each logged operation is assigned a unique LoggingID (a monotonically increasing counter) that
+// appears in all log messages for that operation. This ID enables correlation of entry and exit
+// logs, even when multiple operations are running concurrently or are interleaved.
+//
+// The logging information (start time and ID) is stored in the context and can be retrieved using
+// getLoggingContext or getLoggingID. This allows nested operations to access the parent operation's
+// logging information.
+//
+// Type Parameters:
+//   - A: The success type of the ReaderIOResult
+//
+// Parameters:
+//   - name: A descriptive name for the computation, used in log messages to identify the operation
+//
+// Returns:
+//   - An Operator that wraps the ReaderIOResult computation with entry/exit logging
+//
+// The function uses the bracket pattern to ensure that:
+//   - Entry is logged before the computation starts
+//   - A unique LoggingID is assigned and stored in the context
+//   - Exit/error is logged after the computation completes, regardless of success or failure
+//   - Timing is accurate, measuring from entry to exit
+//   - The original result is preserved and returned unchanged
+//
+// Log Format:
+//   - Entry:   "[entering <id>] <name>"
+//   - Success: "[exiting  <id>] <name> [<duration>s]"
+//   - Error:   "[throwing <id>] <name> [<duration>s]: <error>"
+//
+// Example with successful computation:
+//
+//	fetchUser := func(id int) ReaderIOResult[User] {
+//	    return Of(User{ID: id, Name: "Alice"})
+//	}
+//
+//	// Wrap with logging
+//	loggedFetch := LogEntryExit[User]("fetchUser")(fetchUser(123))
+//
+//	// Execute
+//	result := loggedFetch(context.Background())()
+//	// Logs:
+//	// [entering 1] fetchUser
+//	// [exiting  1] fetchUser [0.1s]
+//
+// Example with error:
+//
+//	failingOp := func() ReaderIOResult[string] {
+//	    return Left[string](errors.New("connection timeout"))
+//	}
+//
+//	logged := LogEntryExit[string]("failingOp")(failingOp())
+//	result := logged(context.Background())()
+//	// Logs:
+//	// [entering 2] failingOp
+//	// [throwing 2] failingOp [0.0s]: connection timeout
+//
+// Example with nested operations:
+//
+//	fetchOrders := func(userID int) ReaderIOResult[[]Order] {
+//	    return Of([]Order{{ID: 1}})
+//	}
+//
+//	pipeline := F.Pipe3(
+//	    fetchUser(123),
+//	    LogEntryExit[User]("fetchUser"),
+//	    Chain(func(user User) ReaderIOResult[[]Order] {
+//	        return fetchOrders(user.ID)
+//	    }),
+//	    LogEntryExit[[]Order]("fetchOrders"),
+//	)
+//
+//	result := pipeline(context.Background())()
+//	// Logs:
+//	// [entering 3] fetchUser
+//	// [exiting  3] fetchUser [0.1s]
+//	// [entering 4] fetchOrders
+//	// [exiting  4] fetchOrders [0.2s]
+//
+// Example with concurrent operations:
+//
+//	// Multiple operations can run concurrently, each with unique IDs
+//	op1 := LogEntryExit[Data]("operation1")(fetchData(1))
+//	op2 := LogEntryExit[Data]("operation2")(fetchData(2))
+//
+//	go op1(context.Background())()
+//	go op2(context.Background())()
+//	// Logs (order may vary):
+//	// [entering 5] operation1
+//	// [entering 6] operation2
+//	// [exiting  5] operation1 [0.1s]
+//	// [exiting  6] operation2 [0.2s]
+//	// The IDs allow correlation even when logs are interleaved
+//
+// Use Cases:
+//   - Debugging: Track execution flow through complex ReaderIOResult chains with correlation IDs
+//   - Performance monitoring: Identify slow operations with timing information
+//   - Production logging: Monitor critical operations with unique identifiers
+//   - Concurrent operations: Correlate logs from multiple concurrent operations
+//   - Nested operations: Track parent-child relationships in operation hierarchies
+//   - Troubleshooting: Quickly identify where errors occur and correlate with entry logs
+//
+//go:inline
+func LogEntryExit[A any](name string) Operator[A, A] {
+	return LogEntryExitWithCallback[A](slog.LevelInfo, logging.GetLoggerFromContext, name)
+}
+
+func curriedLog(
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	message string) func(slog.Attr) func(context.Context) func() struct{} {
+	return F.Curry2(func(a slog.Attr, ctx context.Context) func() struct{} {
+		logger := cb(ctx)
+		return func() struct{} {
+			logger.LogAttrs(ctx, logLevel, message, a)
+			return struct{}{}
+		}
+	})
+}
+
+// SLogWithCallback creates a Kleisli arrow that logs a Result value (success or error) with a custom logger and log level.
+//
+// This function logs both successful values and errors, making it useful for debugging and monitoring
+// Result values as they flow through a computation. Unlike TapSLog which only logs successful values,
+// SLogWithCallback logs the Result regardless of whether it contains a value or an error.
+//
+// The logged output includes:
+//   - For success: The message with the value as a structured "value" attribute
+//   - For error: The message with the error as a structured "error" attribute
+//
+// The Result is passed through unchanged after logging.
+//
+// Type Parameters:
+//   - A: The success type of the Result
+//
+// Parameters:
+//   - logLevel: The slog.Level to use for logging (e.g., slog.LevelInfo, slog.LevelDebug)
+//   - cb: Callback function to retrieve the *slog.Logger from the context
+//   - message: A descriptive message to include in the log entry
+//
+// Returns:
+//   - A Kleisli arrow that logs the Result (value or error) and returns it unchanged
+//
+// Example with custom log level:
+//
+//	debugLog := SLogWithCallback[User](
+//	    slog.LevelDebug,
+//	    logging.GetLoggerFromContext,
+//	    "User result",
+//	)
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    Chain(debugLog),
+//	    Map(func(u User) string { return u.Name }),
+//	)
+//
+// Example with custom logger:
+//
+//	type loggerKey int
+//	const myLoggerKey loggerKey = 0
+//
+//	getMyLogger := func(ctx context.Context) *slog.Logger {
+//	    if logger := ctx.Value(myLoggerKey); logger != nil {
+//	        return logger.(*slog.Logger)
+//	    }
+//	    return slog.Default()
+//	}
+//
+//	customLog := SLogWithCallback[Data](
+//	    slog.LevelWarn,
+//	    getMyLogger,
+//	    "Data processing result",
+//	)
+//
+// Use Cases:
+//   - Debugging: Log both successful and failed Results in a pipeline
+//   - Error tracking: Monitor error occurrences with custom log levels
+//   - Custom logging: Use application-specific loggers and log levels
+//   - Conditional logging: Enable/disable logging based on logger configuration
+func SLogWithCallback[A any](
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	message string) Kleisli[Result[A], A] {
+
+	return F.Pipe1(
+		F.Flow2(
+			// create the attribute to log depending on the condition
+			result.ToSLogAttr[A](),
+			// create an `IO` that logs the attribute
+			curriedLog(logLevel, cb, message),
+		),
+		// preserve the original context
+		reader.Chain(reader.Sequence(readerio.MapTo[struct{}, Result[A]])),
+	)
+}
+
+// SLog creates a Kleisli arrow that logs a Result value (success or error) with a message.
+//
+// This function logs both successful values and errors at Info level using the logger from the context.
+// It's a convenience wrapper around SLogWithCallback with standard settings.
+//
+// The logged output includes:
+//   - For success: The message with the value as a structured "value" attribute
+//   - For error: The message with the error as a structured "error" attribute
+//
+// The Result is passed through unchanged after logging, making this function transparent in the
+// computation pipeline.
+//
+// Type Parameters:
+//   - A: The success type of the Result
+//
+// Parameters:
+//   - message: A descriptive message to include in the log entry
+//
+// Returns:
+//   - A Kleisli arrow that logs the Result (value or error) and returns it unchanged
+//
+// Example with successful Result:
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    Chain(SLog[User]("Fetched user")),
+//	    Map(func(u User) string { return u.Name }),
+//	)
+//
+//	result := pipeline(context.Background())()
+//	// If successful, logs: "Fetched user" value={ID:123 Name:"Alice"}
+//	// If error, logs: "Fetched user" error="user not found"
+//
+// Example in error handling pipeline:
+//
+//	pipeline := F.Pipe3(
+//	    fetchData(id),
+//	    Chain(SLog[Data]("Data fetched")),
+//	    Chain(validateData),
+//	    Chain(SLog[Data]("Data validated")),
+//	    Chain(processData),
+//	)
+//
+//	// Logs each step, including errors:
+//	// "Data fetched" value={...} or error="..."
+//	// "Data validated" value={...} or error="..."
+//
+// Use Cases:
+//   - Debugging: Track both successful and failed Results in a pipeline
+//   - Error monitoring: Log errors as they occur in the computation
+//   - Flow tracking: See the progression of Results through a pipeline
+//   - Troubleshooting: Identify where errors are introduced or propagated
+//
+// Note: This function logs the Result itself (which may contain an error), not just successful values.
+// For logging only successful values, use TapSLog instead.
+//
+//go:inline
+func SLog[A any](message string) Kleisli[Result[A], A] {
+	return SLogWithCallback[A](slog.LevelInfo, logging.GetLoggerFromContext, message)
+}
+
+// TapSLog creates an operator that logs only successful values with a message and passes them through unchanged.
+//
+// This function is useful for debugging and monitoring values as they flow through a ReaderIOResult
+// computation chain. Unlike SLog which logs both successes and errors, TapSLog only logs when the
+// computation is successful. If the computation contains an error, no logging occurs and the error
+// is propagated unchanged.
+//
+// The logged output includes:
+//   - The provided message
+//   - The value being passed through (as a structured "value" attribute)
+//
+// Type Parameters:
+//   - A: The type of the value to log and pass through
+//
+// Parameters:
+//   - message: A descriptive message to include in the log entry
+//
+// Returns:
+//   - An Operator that logs successful values and returns them unchanged
+//
+// Example with simple value logging:
+//
+//	fetchUser := func(id int) ReaderIOResult[User] {
+//	    return Of(User{ID: id, Name: "Alice"})
+//	}
+//
+//	pipeline := F.Pipe2(
+//	    fetchUser(123),
+//	    TapSLog[User]("Fetched user"),
+//	    Map(func(u User) string { return u.Name }),
+//	)
+//
+//	result := pipeline(context.Background())()
+//	// Logs: "Fetched user" value={ID:123 Name:"Alice"}
+//	// Returns: result.Of("Alice")
+//
+// Example in a processing pipeline:
+//
+//	processOrder := F.Pipe4(
+//	    fetchOrder(orderId),
+//	    TapSLog[Order]("Order fetched"),
+//	    Chain(validateOrder),
+//	    TapSLog[Order]("Order validated"),
+//	    Chain(processPayment),
+//	    TapSLog[Payment]("Payment processed"),
+//	)
+//
+//	result := processOrder(context.Background())()
+//	// Logs each successful step with the intermediate values
+//	// If any step fails, subsequent TapSLog calls don't log
+//
+// Example with error handling:
+//
+//	pipeline := F.Pipe3(
+//	    fetchData(id),
+//	    TapSLog[Data]("Data fetched"),
+//	    Chain(func(d Data) ReaderIOResult[Result] {
+//	        if d.IsValid() {
+//	            return Of(processData(d))
+//	        }
+//	        return Left[Result](errors.New("invalid data"))
+//	    }),
+//	    TapSLog[Result]("Data processed"),
+//	)
+//
+//	// If fetchData succeeds: logs "Data fetched" with the data
+//	// If processing succeeds: logs "Data processed" with the result
+//	// If processing fails: "Data processed" is NOT logged (error propagates)
+//
+// Use Cases:
+//   - Debugging: Inspect intermediate successful values in a computation pipeline
+//   - Monitoring: Track successful data flow through complex operations
+//   - Troubleshooting: Identify where successful computations stop (last logged value before error)
+//   - Auditing: Log important successful values for compliance or security
+//   - Development: Understand data transformations during development
+//
+// Note: This function only logs successful values. Errors are silently propagated without logging.
+// For logging both successes and errors, use SLog instead.
+//
+//go:inline
+func TapSLog[A any](message string) Operator[A, A] {
+	return readerio.ChainFirst(SLog[A](message))
+}

v2/context/readerioresult/logging_test.go

@@ -0,0 +1,662 @@
+package readerioresult
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"log/slog"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/logging"
+	N "github.com/IBM/fp-go/v2/number"
+	"github.com/IBM/fp-go/v2/result"
+	S "github.com/IBM/fp-go/v2/string"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestLoggingContext tests basic nested logging with correlation IDs
+func TestLoggingContext(t *testing.T) {
+	data := F.Pipe2(
+		Of("Sample"),
+		LogEntryExit[string]("TestLoggingContext1"),
+		LogEntryExit[string]("TestLoggingContext2"),
+	)
+
+	assert.Equal(t, result.Of("Sample"), data(context.Background())())
+}
+
+// TestLogEntryExitSuccess tests successful operation logging
+func TestLogEntryExitSuccess(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	operation := F.Pipe1(
+		Of("success value"),
+		LogEntryExit[string]("TestOperation"),
+	)
+
+	res := operation(context.Background())()
+
+	assert.Equal(t, result.Of("success value"), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "[entering]")
+	assert.Contains(t, logOutput, "[exiting ]")
+	assert.Contains(t, logOutput, "TestOperation")
+	assert.Contains(t, logOutput, "ID=")
+	assert.Contains(t, logOutput, "duration=")
+}
+
+// TestLogEntryExitError tests error operation logging
+func TestLogEntryExitError(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	testErr := errors.New("test error")
+	operation := F.Pipe1(
+		Left[string](testErr),
+		LogEntryExit[string]("FailingOperation"),
+	)
+
+	res := operation(context.Background())()
+
+	assert.True(t, result.IsLeft(res))
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "[entering]")
+	assert.Contains(t, logOutput, "[throwing]")
+	assert.Contains(t, logOutput, "FailingOperation")
+	assert.Contains(t, logOutput, "test error")
+	assert.Contains(t, logOutput, "ID=")
+	assert.Contains(t, logOutput, "duration=")
+}
+
+// TestLogEntryExitNested tests nested operations with different IDs
+func TestLogEntryExitNested(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	innerOp := F.Pipe1(
+		Of("inner"),
+		LogEntryExit[string]("InnerOp"),
+	)
+
+	outerOp := F.Pipe2(
+		Of("outer"),
+		LogEntryExit[string]("OuterOp"),
+		Chain(func(s string) ReaderIOResult[string] {
+			return innerOp
+		}),
+	)
+
+	res := outerOp(context.Background())()
+
+	assert.True(t, result.IsRight(res))
+
+	logOutput := buf.String()
+	// Should have two different IDs
+	assert.Contains(t, logOutput, "OuterOp")
+	assert.Contains(t, logOutput, "InnerOp")
+
+	// Count entering and exiting logs
+	enterCount := strings.Count(logOutput, "[entering]")
+	exitCount := strings.Count(logOutput, "[exiting ]")
+	assert.Equal(t, 2, enterCount, "Should have 2 entering logs")
+	assert.Equal(t, 2, exitCount, "Should have 2 exiting logs")
+}
+
+// TestLogEntryExitWithCallback tests custom log level and callback
+func TestLogEntryExitWithCallback(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+	}))
+
+	customCallback := func(ctx context.Context) *slog.Logger {
+		return logger
+	}
+
+	operation := F.Pipe1(
+		Of(42),
+		LogEntryExitWithCallback[int](slog.LevelDebug, customCallback, "DebugOperation"),
+	)
+
+	res := operation(context.Background())()
+
+	assert.Equal(t, result.Of(42), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "[entering]")
+	assert.Contains(t, logOutput, "[exiting ]")
+	assert.Contains(t, logOutput, "DebugOperation")
+	assert.Contains(t, logOutput, "level=DEBUG")
+}
+
+// TestLogEntryExitDisabled tests that logging can be disabled
+func TestLogEntryExitDisabled(t *testing.T) {
+	var buf bytes.Buffer
+	// Create logger with level that disables info logs
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelError, // Only log errors
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	operation := F.Pipe1(
+		Of("value"),
+		LogEntryExit[string]("DisabledOperation"),
+	)
+
+	res := operation(context.Background())()
+
+	assert.True(t, result.IsRight(res))
+
+	// Should have no logs since level is ERROR
+	logOutput := buf.String()
+	assert.Empty(t, logOutput, "Should have no logs when logging is disabled")
+}
+
+// TestLogEntryExitF tests custom entry/exit callbacks
+func TestLogEntryExitF(t *testing.T) {
+	var entryCount, exitCount int
+
+	onEntry := func(ctx context.Context) IO[context.Context] {
+		return func() context.Context {
+			entryCount++
+			return ctx
+		}
+	}
+
+	onExit := func(res Result[string]) ReaderIO[any] {
+		return func(ctx context.Context) IO[any] {
+			return func() any {
+				exitCount++
+				return nil
+			}
+		}
+	}
+
+	operation := F.Pipe1(
+		Of("test"),
+		LogEntryExitF(onEntry, onExit),
+	)
+
+	res := operation(context.Background())()
+
+	assert.True(t, result.IsRight(res))
+	assert.Equal(t, 1, entryCount, "Entry callback should be called once")
+	assert.Equal(t, 1, exitCount, "Exit callback should be called once")
+}
+
+// TestLogEntryExitFWithError tests custom callbacks with error
+func TestLogEntryExitFWithError(t *testing.T) {
+	var entryCount, exitCount int
+	var capturedError error
+
+	onEntry := func(ctx context.Context) IO[context.Context] {
+		return func() context.Context {
+			entryCount++
+			return ctx
+		}
+	}
+
+	onExit := func(res Result[string]) ReaderIO[any] {
+		return func(ctx context.Context) IO[any] {
+			return func() any {
+				exitCount++
+				if result.IsLeft(res) {
+					_, capturedError = result.Unwrap(res)
+				}
+				return nil
+			}
+		}
+	}
+
+	testErr := errors.New("custom error")
+	operation := F.Pipe1(
+		Left[string](testErr),
+		LogEntryExitF(onEntry, onExit),
+	)
+
+	res := operation(context.Background())()
+
+	assert.True(t, result.IsLeft(res))
+	assert.Equal(t, 1, entryCount, "Entry callback should be called once")
+	assert.Equal(t, 1, exitCount, "Exit callback should be called once")
+	assert.Equal(t, testErr, capturedError, "Should capture the error")
+}
+
+// TestLoggingIDUniqueness tests that logging IDs are unique
+func TestLoggingIDUniqueness(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	// Run multiple operations
+	for i := range 5 {
+		op := F.Pipe1(
+			Of(i),
+			LogEntryExit[int]("Operation"),
+		)
+		op(context.Background())()
+	}
+
+	logOutput := buf.String()
+
+	// Extract all IDs and verify they're unique
+	lines := strings.Split(logOutput, "\n")
+	ids := make(map[string]bool)
+	for _, line := range lines {
+		if strings.Contains(line, "ID=") {
+			// Extract ID value
+			parts := strings.Split(line, "ID=")
+			if len(parts) > 1 {
+				idPart := strings.Fields(parts[1])[0]
+				ids[idPart] = true
+			}
+		}
+	}
+
+	// Should have 5 unique IDs (one per operation)
+	assert.GreaterOrEqual(t, len(ids), 5, "Should have at least 5 unique IDs")
+}
+
+// TestLogEntryExitWithContextLogger tests using logger from context
+func TestLogEntryExitWithContextLogger(t *testing.T) {
+	var buf bytes.Buffer
+	contextLogger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+
+	ctx := logging.WithLogger(contextLogger)(context.Background())
+
+	operation := F.Pipe1(
+		Of("context value"),
+		LogEntryExit[string]("ContextOperation"),
+	)
+
+	res := operation(ctx)()
+
+	assert.True(t, result.IsRight(res))
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "[entering]")
+	assert.Contains(t, logOutput, "[exiting ]")
+	assert.Contains(t, logOutput, "ContextOperation")
+}
+
+// TestLogEntryExitTiming tests that duration is captured
+func TestLogEntryExitTiming(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	// Operation with delay
+	slowOp := func(ctx context.Context) IOResult[string] {
+		return func() Result[string] {
+			time.Sleep(10 * time.Millisecond)
+			return result.Of("done")
+		}
+	}
+
+	operation := F.Pipe1(
+		slowOp,
+		LogEntryExit[string]("SlowOperation"),
+	)
+
+	res := operation(context.Background())()
+
+	assert.True(t, result.IsRight(res))
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "duration=")
+
+	// Verify duration is present in exit log
+	lines := strings.Split(logOutput, "\n")
+	var foundDuration bool
+	for _, line := range lines {
+		if strings.Contains(line, "[exiting ]") && strings.Contains(line, "duration=") {
+			foundDuration = true
+			break
+		}
+	}
+	assert.True(t, foundDuration, "Exit log should contain duration")
+}
+
+// TestLogEntryExitChainedOperations tests complex chained operations
+func TestLogEntryExitChainedOperations(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	step1 := F.Pipe1(
+		Of(1),
+		LogEntryExit[int]("Step1"),
+	)
+
+	step2 := F.Flow3(
+		N.Mul(2),
+		Of,
+		LogEntryExit[int]("Step2"),
+	)
+
+	step3 := F.Flow3(
+		strconv.Itoa,
+		Of,
+		LogEntryExit[string]("Step3"),
+	)
+
+	pipeline := F.Pipe1(
+		step1,
+		Chain(F.Flow2(
+			step2,
+			Chain(step3),
+		)),
+	)
+
+	res := pipeline(context.Background())()
+
+	assert.Equal(t, result.Of("2"), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Step1")
+	assert.Contains(t, logOutput, "Step2")
+	assert.Contains(t, logOutput, "Step3")
+
+	// Verify all steps completed
+	assert.Equal(t, 3, strings.Count(logOutput, "[entering]"))
+	assert.Equal(t, 3, strings.Count(logOutput, "[exiting ]"))
+}
+
+// TestTapSLog tests basic TapSLog functionality
+func TestTapSLog(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	operation := F.Pipe2(
+		Of(42),
+		TapSLog[int]("Processing value"),
+		Map(N.Mul(2)),
+	)
+
+	res := operation(context.Background())()
+
+	assert.Equal(t, result.Of(84), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Processing value")
+	assert.Contains(t, logOutput, "value=42")
+}
+
+// TestTapSLogInPipeline tests TapSLog in a multi-step pipeline
+func TestTapSLogInPipeline(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	step1 := F.Pipe2(
+		Of("hello"),
+		TapSLog[string]("Step 1: Initial value"),
+		Map(func(s string) string { return s + " world" }),
+	)
+
+	step2 := F.Pipe2(
+		step1,
+		TapSLog[string]("Step 2: After concatenation"),
+		Map(S.Size),
+	)
+
+	pipeline := F.Pipe1(
+		step2,
+		TapSLog[int]("Step 3: Final length"),
+	)
+
+	res := pipeline(context.Background())()
+
+	assert.Equal(t, result.Of(11), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Step 1: Initial value")
+	assert.Contains(t, logOutput, "value=hello")
+	assert.Contains(t, logOutput, "Step 2: After concatenation")
+	assert.Contains(t, logOutput, `value="hello world"`)
+	assert.Contains(t, logOutput, "Step 3: Final length")
+	assert.Contains(t, logOutput, "value=11")
+}
+
+// TestTapSLogWithError tests that TapSLog logs errors (via SLog)
+func TestTapSLogWithError(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	testErr := errors.New("computation failed")
+	pipeline := F.Pipe2(
+		Left[int](testErr),
+		TapSLog[int]("Error logged"),
+		Map(N.Mul(2)),
+	)
+
+	res := pipeline(context.Background())()
+
+	assert.True(t, result.IsLeft(res))
+
+	logOutput := buf.String()
+	// TapSLog uses SLog internally, which logs both successes and errors
+	assert.Contains(t, logOutput, "Error logged")
+	assert.Contains(t, logOutput, "error")
+	assert.Contains(t, logOutput, "computation failed")
+}
+
+// TestTapSLogWithStruct tests TapSLog with structured data
+func TestTapSLogWithStruct(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	type User struct {
+		ID   int
+		Name string
+	}
+
+	user := User{ID: 123, Name: "Alice"}
+	operation := F.Pipe2(
+		Of(user),
+		TapSLog[User]("User data"),
+		Map(func(u User) string { return u.Name }),
+	)
+
+	res := operation(context.Background())()
+
+	assert.Equal(t, result.Of("Alice"), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "User data")
+	assert.Contains(t, logOutput, "ID:123")
+	assert.Contains(t, logOutput, "Name:Alice")
+}
+
+// TestTapSLogDisabled tests that TapSLog respects logger level
+func TestTapSLogDisabled(t *testing.T) {
+	var buf bytes.Buffer
+	// Create logger with level that disables info logs
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelError, // Only log errors
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	operation := F.Pipe2(
+		Of(42),
+		TapSLog[int]("This should not be logged"),
+		Map(N.Mul(2)),
+	)
+
+	res := operation(context.Background())()
+
+	assert.Equal(t, result.Of(84), res)
+
+	// Should have no logs since level is ERROR
+	logOutput := buf.String()
+	assert.Empty(t, logOutput, "Should have no logs when logging is disabled")
+}
+
+// TestTapSLogWithContextLogger tests TapSLog using logger from context
+func TestTapSLogWithContextLogger(t *testing.T) {
+	var buf bytes.Buffer
+	contextLogger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+
+	ctx := logging.WithLogger(contextLogger)(context.Background())
+
+	operation := F.Pipe2(
+		Of("test value"),
+		TapSLog[string]("Context logger test"),
+		Map(S.Size),
+	)
+
+	res := operation(ctx)()
+
+	assert.Equal(t, result.Of(10), res)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Context logger test")
+	assert.Contains(t, logOutput, `value="test value"`)
+}
+
+// TestSLogLogsSuccessValue tests that SLog logs successful Result values
+func TestSLogLogsSuccessValue(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	// Create a Result and log it
+	res1 := result.Of(42)
+	logged := SLog[int]("Result value")(res1)(ctx)()
+
+	assert.Equal(t, result.Of(42), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Result value")
+	assert.Contains(t, logOutput, "value=42")
+}
+
+// TestSLogLogsErrorValue tests that SLog logs error Result values
+func TestSLogLogsErrorValue(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+	testErr := errors.New("test error")
+
+	// Create an error Result and log it
+	res1 := result.Left[int](testErr)
+	logged := SLog[int]("Result value")(res1)(ctx)()
+
+	assert.True(t, result.IsLeft(logged))
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Result value")
+	assert.Contains(t, logOutput, "error")
+	assert.Contains(t, logOutput, "test error")
+}
+
+// TestSLogWithCallbackCustomLevel tests SLogWithCallback with custom log level
+func TestSLogWithCallbackCustomLevel(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+	}))
+
+	customCallback := func(ctx context.Context) *slog.Logger {
+		return logger
+	}
+
+	ctx := context.Background()
+
+	// Create a Result and log it with custom callback
+	res1 := result.Of(42)
+	logged := SLogWithCallback[int](slog.LevelDebug, customCallback, "Debug result")(res1)(ctx)()
+
+	assert.Equal(t, result.Of(42), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Debug result")
+	assert.Contains(t, logOutput, "value=42")
+	assert.Contains(t, logOutput, "level=DEBUG")
+}
+
+// TestSLogWithCallbackLogsError tests SLogWithCallback logs errors
+func TestSLogWithCallbackLogsError(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelWarn,
+	}))
+
+	customCallback := func(ctx context.Context) *slog.Logger {
+		return logger
+	}
+
+	ctx := context.Background()
+	testErr := errors.New("warning error")
+
+	// Create an error Result and log it with custom callback
+	res1 := result.Left[int](testErr)
+	logged := SLogWithCallback[int](slog.LevelWarn, customCallback, "Warning result")(res1)(ctx)()
+
+	assert.True(t, result.IsLeft(logged))
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Warning result")
+	assert.Contains(t, logOutput, "error")
+	assert.Contains(t, logOutput, "warning error")
+	assert.Contains(t, logOutput, "level=WARN")
+}

v2/context/readerioresult/reader.go

@@ -19,6 +19,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/IBM/fp-go/v2/context/readerio"
 	"github.com/IBM/fp-go/v2/context/readerresult"
 	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/errors"
@@ -26,10 +27,11 @@ import (
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/ioeither"
 	"github.com/IBM/fp-go/v2/ioresult"
+	"github.com/IBM/fp-go/v2/option"
 	"github.com/IBM/fp-go/v2/reader"
-	"github.com/IBM/fp-go/v2/readerio"
 	RIOR "github.com/IBM/fp-go/v2/readerioresult"
 	"github.com/IBM/fp-go/v2/readeroption"
+	"github.com/IBM/fp-go/v2/result"
 )
 
 const (
@@ -150,7 +152,7 @@ func MapTo[A, B any](b B) Operator[A, B] {
 //
 //go:inline
 func MonadChain[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[B] {
-	return RIOR.MonadChain(ma, f)
+	return RIOR.MonadChain(ma, WithContextK(f))
 }
 
 // Chain sequences two [ReaderIOResult] computations, where the second depends on the result of the first.
@@ -163,7 +165,7 @@ func MonadChain[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[
 //
 //go:inline
 func Chain[A, B any](f Kleisli[A, B]) Operator[A, B] {
-	return RIOR.Chain(f)
+	return RIOR.Chain(WithContextK(f))
 }
 
 // MonadChainFirst sequences two [ReaderIOResult] computations but returns the result of the first.
@@ -177,12 +179,12 @@ func Chain[A, B any](f Kleisli[A, B]) Operator[A, B] {
 //
 //go:inline
 func MonadChainFirst[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[A] {
-	return RIOR.MonadChainFirst(ma, f)
+	return RIOR.MonadChainFirst(ma, WithContextK(f))
 }
 
 //go:inline
 func MonadTap[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[A] {
-	return RIOR.MonadTap(ma, f)
+	return RIOR.MonadTap(ma, WithContextK(f))
 }
 
 // ChainFirst sequences two [ReaderIOResult] computations but returns the result of the first.
@@ -195,12 +197,12 @@ func MonadTap[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[A]
 //
 //go:inline
 func ChainFirst[A, B any](f Kleisli[A, B]) Operator[A, A] {
-	return RIOR.ChainFirst(f)
+	return RIOR.ChainFirst(WithContextK(f))
 }
 
 //go:inline
 func Tap[A, B any](f Kleisli[A, B]) Operator[A, A] {
-	return RIOR.Tap(f)
+	return RIOR.Tap(WithContextK(f))
 }
 
 // Of creates a [ReaderIOResult] that always succeeds with the given value.
@@ -243,14 +245,14 @@ func MonadApPar[B, A any](fab ReaderIOResult[func(A) B], fa ReaderIOResult[A]) R
 
 	return func(ctx context.Context) IOResult[B] {
 		// quick check for cancellation
-		if err := context.Cause(ctx); err != nil {
-			return ioeither.Left[B](err)
+		if ctx.Err() != nil {
+			return ioeither.Left[B](context.Cause(ctx))
 		}
 
 		return func() Result[B] {
 			// quick check for cancellation
-			if err := context.Cause(ctx); err != nil {
-				return either.Left[B](err)
+			if ctx.Err() != nil {
+				return either.Left[B](context.Cause(ctx))
 			}
 
 			// create sub-contexts for fa and fab, so they can cancel one other
@@ -382,7 +384,7 @@ func Ask() ReaderIOResult[context.Context] {
 // Returns a new ReaderIOResult with the chained computation.
 //
 //go:inline
-func MonadChainEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) ReaderIOResult[B] {
+func MonadChainEitherK[A, B any](ma ReaderIOResult[A], f either.Kleisli[error, A, B]) ReaderIOResult[B] {
 	return RIOR.MonadChainEitherK(ma, f)
 }
 
@@ -395,7 +397,12 @@ func MonadChainEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) Read
 // Returns a function that chains the Either-returning function.
 //
 //go:inline
-func ChainEitherK[A, B any](f func(A) Either[B]) Operator[A, B] {
+func ChainEitherK[A, B any](f either.Kleisli[error, A, B]) Operator[A, B] {
+	return RIOR.ChainEitherK[context.Context](f)
+}
+
+//go:inline
+func ChainResultK[A, B any](f either.Kleisli[error, A, B]) Operator[A, B] {
 	return RIOR.ChainEitherK[context.Context](f)
 }
 
@@ -409,12 +416,12 @@ func ChainEitherK[A, B any](f func(A) Either[B]) Operator[A, B] {
 // Returns a ReaderIOResult with the original value if both computations succeed.
 //
 //go:inline
-func MonadChainFirstEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) ReaderIOResult[A] {
+func MonadChainFirstEitherK[A, B any](ma ReaderIOResult[A], f either.Kleisli[error, A, B]) ReaderIOResult[A] {
 	return RIOR.MonadChainFirstEitherK(ma, f)
 }
 
 //go:inline
-func MonadTapEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) ReaderIOResult[A] {
+func MonadTapEitherK[A, B any](ma ReaderIOResult[A], f either.Kleisli[error, A, B]) ReaderIOResult[A] {
 	return RIOR.MonadTapEitherK(ma, f)
 }
 
@@ -427,12 +434,12 @@ func MonadTapEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) Reader
 // Returns a function that chains the Either-returning function.
 //
 //go:inline
-func ChainFirstEitherK[A, B any](f func(A) Either[B]) Operator[A, A] {
+func ChainFirstEitherK[A, B any](f either.Kleisli[error, A, B]) Operator[A, A] {
 	return RIOR.ChainFirstEitherK[context.Context](f)
 }
 
 //go:inline
-func TapEitherK[A, B any](f func(A) Either[B]) Operator[A, A] {
+func TapEitherK[A, B any](f either.Kleisli[error, A, B]) Operator[A, A] {
 	return RIOR.TapEitherK[context.Context](f)
 }
 
@@ -445,7 +452,7 @@ func TapEitherK[A, B any](f func(A) Either[B]) Operator[A, A] {
 // Returns a function that chains Option-returning functions into ReaderIOResult.
 //
 //go:inline
-func ChainOptionK[A, B any](onNone func() error) func(func(A) Option[B]) Operator[A, B] {
+func ChainOptionK[A, B any](onNone func() error) func(option.Kleisli[A, B]) Operator[A, B] {
 	return RIOR.ChainOptionK[context.Context, A, B](onNone)
 }
 
@@ -527,7 +534,7 @@ func Never[A any]() ReaderIOResult[A] {
 // Returns a new ReaderIOResult with the chained IO computation.
 //
 //go:inline
-func MonadChainIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult[B] {
+func MonadChainIOK[A, B any](ma ReaderIOResult[A], f io.Kleisli[A, B]) ReaderIOResult[B] {
 	return RIOR.MonadChainIOK(ma, f)
 }
 
@@ -540,7 +547,7 @@ func MonadChainIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResu
 // Returns a function that chains the IO-returning function.
 //
 //go:inline
-func ChainIOK[A, B any](f func(A) IO[B]) Operator[A, B] {
+func ChainIOK[A, B any](f io.Kleisli[A, B]) Operator[A, B] {
 	return RIOR.ChainIOK[context.Context](f)
 }
 
@@ -554,12 +561,12 @@ func ChainIOK[A, B any](f func(A) IO[B]) Operator[A, B] {
 // Returns a ReaderIOResult with the original value after executing the IO.
 //
 //go:inline
-func MonadChainFirstIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult[A] {
+func MonadChainFirstIOK[A, B any](ma ReaderIOResult[A], f io.Kleisli[A, B]) ReaderIOResult[A] {
 	return RIOR.MonadChainFirstIOK(ma, f)
 }
 
 //go:inline
-func MonadTapIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult[A] {
+func MonadTapIOK[A, B any](ma ReaderIOResult[A], f io.Kleisli[A, B]) ReaderIOResult[A] {
 	return RIOR.MonadTapIOK(ma, f)
 }
 
@@ -572,12 +579,12 @@ func MonadTapIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult
 // Returns a function that chains the IO-returning function.
 //
 //go:inline
-func ChainFirstIOK[A, B any](f func(A) IO[B]) Operator[A, A] {
+func ChainFirstIOK[A, B any](f io.Kleisli[A, B]) Operator[A, A] {
 	return RIOR.ChainFirstIOK[context.Context](f)
 }
 
 //go:inline
-func TapIOK[A, B any](f func(A) IO[B]) Operator[A, A] {
+func TapIOK[A, B any](f io.Kleisli[A, B]) Operator[A, A] {
 	return RIOR.TapIOK[context.Context](f)
 }
 
@@ -590,7 +597,7 @@ func TapIOK[A, B any](f func(A) IO[B]) Operator[A, A] {
 // Returns a function that chains the IOResult-returning function.
 //
 //go:inline
-func ChainIOEitherK[A, B any](f func(A) IOResult[B]) Operator[A, B] {
+func ChainIOEitherK[A, B any](f ioresult.Kleisli[A, B]) Operator[A, B] {
 	return RIOR.ChainIOEitherK[context.Context](f)
 }
 
@@ -753,7 +760,7 @@ func Flap[B, A any](a A) Operator[func(A) B, B] {
 //
 //go:inline
 func Fold[A, B any](onLeft Kleisli[error, B], onRight Kleisli[A, B]) Operator[A, B] {
-	return RIOR.Fold(onLeft, onRight)
+	return RIOR.Fold(function.Flow2(onLeft, WithContext), function.Flow2(onRight, WithContext))
 }
 
 // GetOrElse extracts the value from a [ReaderIOResult], providing a default via a function if it fails.
@@ -765,7 +772,7 @@ func Fold[A, B any](onLeft Kleisli[error, B], onRight Kleisli[A, B]) Operator[A,
 // Returns a function that converts a ReaderIOResult to a ReaderIO.
 //
 //go:inline
-func GetOrElse[A any](onLeft func(error) ReaderIO[A]) func(ReaderIOResult[A]) ReaderIO[A] {
+func GetOrElse[A any](onLeft readerio.Kleisli[error, A]) func(ReaderIOResult[A]) ReaderIO[A] {
 	return RIOR.GetOrElse(onLeft)
 }
 
@@ -858,32 +865,32 @@ func TapReaderResultK[A, B any](f readerresult.Kleisli[A, B]) Operator[A, A] {
 }
 
 //go:inline
-func MonadChainReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[context.Context, A, B]) ReaderIOResult[B] {
+func MonadChainReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[A, B]) ReaderIOResult[B] {
 	return RIOR.MonadChainReaderIOK(ma, f)
 }
 
 //go:inline
-func ChainReaderIOK[A, B any](f readerio.Kleisli[context.Context, A, B]) Operator[A, B] {
+func ChainReaderIOK[A, B any](f readerio.Kleisli[A, B]) Operator[A, B] {
 	return RIOR.ChainReaderIOK(f)
 }
 
 //go:inline
-func MonadChainFirstReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[context.Context, A, B]) ReaderIOResult[A] {
+func MonadChainFirstReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[A, B]) ReaderIOResult[A] {
 	return RIOR.MonadChainFirstReaderIOK(ma, f)
 }
 
 //go:inline
-func MonadTapReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[context.Context, A, B]) ReaderIOResult[A] {
+func MonadTapReaderIOK[A, B any](ma ReaderIOResult[A], f readerio.Kleisli[A, B]) ReaderIOResult[A] {
 	return RIOR.MonadTapReaderIOK(ma, f)
 }
 
 //go:inline
-func ChainFirstReaderIOK[A, B any](f readerio.Kleisli[context.Context, A, B]) Operator[A, A] {
+func ChainFirstReaderIOK[A, B any](f readerio.Kleisli[A, B]) Operator[A, A] {
 	return RIOR.ChainFirstReaderIOK(f)
 }
 
 //go:inline
-func TapReaderIOK[A, B any](f readerio.Kleisli[context.Context, A, B]) Operator[A, A] {
+func TapReaderIOK[A, B any](f readerio.Kleisli[A, B]) Operator[A, A] {
 	return RIOR.TapReaderIOK(f)
 }
 
@@ -913,15 +920,15 @@ func Read[A any](r context.Context) func(ReaderIOResult[A]) IOResult[A] {
 //
 //go:inline
 func MonadChainLeft[A any](fa ReaderIOResult[A], f Kleisli[error, A]) ReaderIOResult[A] {
-	return RIOR.MonadChainLeft(fa, f)
+	return RIOR.MonadChainLeft(fa, WithContextK(f))
 }
 
 // ChainLeft is the curried version of [MonadChainLeft].
 // It returns a function that chains a computation on the left (error) side of a [ReaderIOResult].
 //
 //go:inline
-func ChainLeft[A any](f Kleisli[error, A]) func(ReaderIOResult[A]) ReaderIOResult[A] {
-	return RIOR.ChainLeft(f)
+func ChainLeft[A any](f Kleisli[error, A]) Operator[A, A] {
+	return RIOR.ChainLeft(WithContextK(f))
 }
 
 // MonadChainFirstLeft chains a computation on the left (error) side but always returns the original error.
@@ -934,12 +941,12 @@ func ChainLeft[A any](f Kleisli[error, A]) func(ReaderIOResult[A]) ReaderIOResul
 //
 //go:inline
 func MonadChainFirstLeft[A, B any](ma ReaderIOResult[A], f Kleisli[error, B]) ReaderIOResult[A] {
-	return RIOR.MonadChainFirstLeft(ma, f)
+	return RIOR.MonadChainFirstLeft(ma, WithContextK(f))
 }
 
 //go:inline
 func MonadTapLeft[A, B any](ma ReaderIOResult[A], f Kleisli[error, B]) ReaderIOResult[A] {
-	return RIOR.MonadTapLeft(ma, f)
+	return RIOR.MonadTapLeft(ma, WithContextK(f))
 }
 
 // ChainFirstLeft is the curried version of [MonadChainFirstLeft].
@@ -951,10 +958,212 @@ func MonadTapLeft[A, B any](ma ReaderIOResult[A], f Kleisli[error, B]) ReaderIOR
 //
 //go:inline
 func ChainFirstLeft[A, B any](f Kleisli[error, B]) Operator[A, A] {
-	return RIOR.ChainFirstLeft[A](f)
+	return RIOR.ChainFirstLeft[A](WithContextK(f))
 }
 
 //go:inline
 func TapLeft[A, B any](f Kleisli[error, B]) Operator[A, A] {
-	return RIOR.TapLeft[A](f)
+	return RIOR.TapLeft[A](WithContextK(f))
+}
+
+// Local transforms the context.Context environment before passing it to a ReaderIOResult computation.
+//
+// This is the Reader's local operation, which allows you to modify the environment
+// for a specific computation without affecting the outer context. The transformation
+// function receives the current context and returns a new context along with a
+// cancel function. The cancel function is automatically called when the computation
+// completes (via defer), ensuring proper cleanup of resources.
+//
+// The function checks for context cancellation before applying the transformation,
+// returning an error immediately if the context is already cancelled.
+//
+// This is useful for:
+//   - Adding timeouts or deadlines to specific operations
+//   - Adding context values for nested computations
+//   - Creating isolated context scopes
+//   - Implementing context-based dependency injection
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIOResult
+//
+// Parameters:
+//   - f: A function that transforms the context and returns a cancel function
+//
+// Returns:
+//   - An Operator that runs the computation with the transformed context
+//
+// Example:
+//
+//	import F "github.com/IBM/fp-go/v2/function"
+//
+//	// Add a custom value to the context
+//	type key int
+//	const userKey key = 0
+//
+//	addUser := readerioresult.Local[string](func(ctx context.Context) (context.Context, context.CancelFunc) {
+//	    newCtx := context.WithValue(ctx, userKey, "Alice")
+//	    return newCtx, func() {} // No-op cancel
+//	})
+//
+//	getUser := readerioresult.FromReader(func(ctx context.Context) string {
+//	    if user := ctx.Value(userKey); user != nil {
+//	        return user.(string)
+//	    }
+//	    return "unknown"
+//	})
+//
+//	result := F.Pipe1(
+//	    getUser,
+//	    addUser,
+//	)
+//	value, err := result(context.Background())()  // Returns ("Alice", nil)
+//
+// Timeout Example:
+//
+//	// Add a 5-second timeout to a specific operation
+//	withTimeout := readerioresult.Local[Data](func(ctx context.Context) (context.Context, context.CancelFunc) {
+//	    return context.WithTimeout(ctx, 5*time.Second)
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    withTimeout,
+//	)
+func Local[A any](f func(context.Context) (context.Context, context.CancelFunc)) Operator[A, A] {
+	return func(rr ReaderIOResult[A]) ReaderIOResult[A] {
+		return func(ctx context.Context) IOResult[A] {
+			return func() Result[A] {
+				if ctx.Err() != nil {
+					return result.Left[A](context.Cause(ctx))
+				}
+				otherCtx, otherCancel := f(ctx)
+				defer otherCancel()
+				return rr(otherCtx)()
+			}
+		}
+	}
+}
+
+// WithTimeout adds a timeout to the context for a ReaderIOResult computation.
+//
+// This is a convenience wrapper around Local that uses context.WithTimeout.
+// The computation must complete within the specified duration, or it will be
+// cancelled. This is useful for ensuring operations don't run indefinitely
+// and for implementing timeout-based error handling.
+//
+// The timeout is relative to when the ReaderIOResult is executed, not when
+// WithTimeout is called. The cancel function is automatically called when
+// the computation completes, ensuring proper cleanup. If the timeout expires,
+// the computation will receive a context.DeadlineExceeded error.
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIOResult
+//
+// Parameters:
+//   - timeout: The maximum duration for the computation
+//
+// Returns:
+//   - An Operator that runs the computation with a timeout
+//
+// Example:
+//
+//	import (
+//	    "time"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	)
+//
+//	// Fetch data with a 5-second timeout
+//	fetchData := readerioresult.FromReader(func(ctx context.Context) Data {
+//	    // Simulate slow operation
+//	    select {
+//	    case <-time.After(10 * time.Second):
+//	        return Data{Value: "slow"}
+//	    case <-ctx.Done():
+//	        return Data{}
+//	    }
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerioresult.WithTimeout[Data](5*time.Second),
+//	)
+//	value, err := result(context.Background())()  // Returns (Data{}, context.DeadlineExceeded) after 5s
+//
+// Successful Example:
+//
+//	quickFetch := readerioresult.Right(Data{Value: "quick"})
+//	result := F.Pipe1(
+//	    quickFetch,
+//	    readerioresult.WithTimeout[Data](5*time.Second),
+//	)
+//	value, err := result(context.Background())()  // Returns (Data{Value: "quick"}, nil)
+func WithTimeout[A any](timeout time.Duration) Operator[A, A] {
+	return Local[A](func(ctx context.Context) (context.Context, context.CancelFunc) {
+		return context.WithTimeout(ctx, timeout)
+	})
+}
+
+// WithDeadline adds an absolute deadline to the context for a ReaderIOResult computation.
+//
+// This is a convenience wrapper around Local that uses context.WithDeadline.
+// The computation must complete before the specified time, or it will be
+// cancelled. This is useful for coordinating operations that must finish
+// by a specific time, such as request deadlines or scheduled tasks.
+//
+// The deadline is an absolute time, unlike WithTimeout which uses a relative
+// duration. The cancel function is automatically called when the computation
+// completes, ensuring proper cleanup. If the deadline passes, the computation
+// will receive a context.DeadlineExceeded error.
+//
+// Type Parameters:
+//   - A: The value type of the ReaderIOResult
+//
+// Parameters:
+//   - deadline: The absolute time by which the computation must complete
+//
+// Returns:
+//   - An Operator that runs the computation with a deadline
+//
+// Example:
+//
+//	import (
+//	    "time"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	)
+//
+//	// Operation must complete by 3 PM
+//	deadline := time.Date(2024, 1, 1, 15, 0, 0, 0, time.UTC)
+//
+//	fetchData := readerioresult.FromReader(func(ctx context.Context) Data {
+//	    // Simulate operation
+//	    select {
+//	    case <-time.After(1 * time.Hour):
+//	        return Data{Value: "done"}
+//	    case <-ctx.Done():
+//	        return Data{}
+//	    }
+//	})
+//
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerioresult.WithDeadline[Data](deadline),
+//	)
+//	value, err := result(context.Background())()  // Returns (Data{}, context.DeadlineExceeded) if past deadline
+//
+// Combining with Parent Context:
+//
+//	// If parent context already has a deadline, the earlier one takes precedence
+//	parentCtx, cancel := context.WithDeadline(context.Background(), time.Now().Add(1*time.Hour))
+//	defer cancel()
+//
+//	laterDeadline := time.Now().Add(2 * time.Hour)
+//	result := F.Pipe1(
+//	    fetchData,
+//	    readerioresult.WithDeadline[Data](laterDeadline),
+//	)
+//	value, err := result(parentCtx)()  // Will use parent's 1-hour deadline
+func WithDeadline[A any](deadline time.Time) Operator[A, A] {
+	return Local[A](func(ctx context.Context) (context.Context, context.CancelFunc) {
+		return context.WithDeadline(ctx, deadline)
+	})
 }

v2/context/readerioresult/reader_extended_test.go

@@ -235,7 +235,7 @@ func TestApPar(t *testing.T) {
 func TestFromPredicate(t *testing.T) {
 	t.Run("Predicate true", func(t *testing.T) {
 		pred := FromPredicate(
-			func(x int) bool { return x > 0 },
+			N.MoreThan(0),
 			func(x int) error { return fmt.Errorf("value %d is not positive", x) },
 		)
 		result := pred(5)
@@ -244,7 +244,7 @@ func TestFromPredicate(t *testing.T) {
 
 	t.Run("Predicate false", func(t *testing.T) {
 		pred := FromPredicate(
-			func(x int) bool { return x > 0 },
+			N.MoreThan(0),
 			func(x int) error { return fmt.Errorf("value %d is not positive", x) },
 		)
 		result := pred(-5)
@@ -567,15 +567,13 @@ func TestMemoize(t *testing.T) {
 	res1 := computation(context.Background())()
 	assert.True(t, E.IsRight(res1))
 	val1 := E.ToOption(res1)
-	v1, _ := O.Unwrap(val1)
-	assert.Equal(t, 1, v1)
+	assert.Equal(t, O.Of(1), val1)
 
 	// Second execution should return cached value
 	res2 := computation(context.Background())()
 	assert.True(t, E.IsRight(res2))
 	val2 := E.ToOption(res2)
-	v2, _ := O.Unwrap(val2)
-	assert.Equal(t, 1, v2)
+	assert.Equal(t, O.Of(1), val2)
 
 	// Counter should only be incremented once
 	assert.Equal(t, 1, counter)
@@ -739,9 +737,7 @@ func TestTraverseArray(t *testing.T) {
 		res := result(context.Background())()
 		assert.True(t, E.IsRight(res))
 		arrOpt := E.ToOption(res)
-		assert.True(t, O.IsSome(arrOpt))
-		resultArr, _ := O.Unwrap(arrOpt)
-		assert.Equal(t, []int{2, 4, 6}, resultArr)
+		assert.Equal(t, O.Of([]int{2, 4, 6}), arrOpt)
 	})
 
 	t.Run("TraverseArray with error", func(t *testing.T) {
@@ -765,9 +761,7 @@ func TestSequenceArray(t *testing.T) {
 	res := result(context.Background())()
 	assert.True(t, E.IsRight(res))
 	arrOpt := E.ToOption(res)
-	assert.True(t, O.IsSome(arrOpt))
-	resultArr, _ := O.Unwrap(arrOpt)
-	assert.Equal(t, []int{1, 2, 3}, resultArr)
+	assert.Equal(t, O.Of([]int{1, 2, 3}), arrOpt)
 }
 
 func TestTraverseRecord(t *testing.T) {

v2/context/readerioresult/rec.go

@@ -0,0 +1,183 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	RIOR "github.com/IBM/fp-go/v2/readerioresult"
+)
+
+// TailRec implements stack-safe tail recursion for the context-aware ReaderIOResult monad.
+//
+// This function enables recursive computations that combine four powerful concepts:
+//   - Context awareness: Automatic cancellation checking via [context.Context]
+//   - Environment dependency (Reader aspect): Access to configuration, context, or dependencies
+//   - Side effects (IO aspect): Logging, file I/O, network calls, etc.
+//   - Error handling (Either aspect): Computations that can fail with an error
+//
+// The function uses an iterative loop to execute the recursion, making it safe for deep
+// or unbounded recursion without risking stack overflow. Additionally, it integrates
+// context cancellation checking through [WithContext], ensuring that recursive computations
+// can be cancelled gracefully.
+//
+// # How It Works
+//
+// TailRec takes a Kleisli arrow that returns Trampoline[A, B]:
+//   - Bounce(A): Continue recursion with the new state A
+//   - Land(B): Terminate recursion successfully and return the final result B
+//
+// The function wraps each iteration with [WithContext] to ensure context cancellation
+// is checked before each recursive step. If the context is cancelled, the recursion
+// terminates early with a context cancellation error.
+//
+// # Type Parameters
+//
+//   - A: The state type that changes during recursion
+//   - B: The final result type when recursion terminates successfully
+//
+// # Parameters
+//
+//   - f: A Kleisli arrow (A => ReaderIOResult[Trampoline[A, B]]) that:
+//   - Takes the current state A
+//   - Returns a ReaderIOResult that depends on [context.Context]
+//   - Can fail with error (Left in the outer Either)
+//   - Produces Trampoline[A, B] to control recursion flow (Right in the outer Either)
+//
+// # Returns
+//
+// A Kleisli arrow (A => ReaderIOResult[B]) that:
+//   - Takes an initial state A
+//   - Returns a ReaderIOResult that requires [context.Context]
+//   - Can fail with error or context cancellation
+//   - Produces the final result B after recursion completes
+//
+// # Context Cancellation
+//
+// Unlike the base [readerioresult.TailRec], this version automatically integrates
+// context cancellation checking:
+//   - Each recursive iteration checks if the context is cancelled
+//   - If cancelled, recursion terminates immediately with a cancellation error
+//   - This prevents runaway recursive computations in cancelled contexts
+//   - Enables responsive cancellation for long-running recursive operations
+//
+// # Use Cases
+//
+//  1. Cancellable recursive algorithms:
+//     - Tree traversals that can be cancelled mid-operation
+//     - Graph algorithms with timeout requirements
+//     - Recursive parsers that respect cancellation
+//
+//  2. Long-running recursive computations:
+//     - File system traversals with cancellation support
+//     - Network operations with timeout handling
+//     - Database operations with connection timeout awareness
+//
+//  3. Interactive recursive operations:
+//     - User-initiated operations that can be cancelled
+//     - Background tasks with cancellation support
+//     - Streaming operations with graceful shutdown
+//
+// # Example: Cancellable Countdown
+//
+//	countdownStep := func(n int) readerioresult.ReaderIOResult[tailrec.Trampoline[int, string]] {
+//	    return func(ctx context.Context) ioeither.IOEither[error, tailrec.Trampoline[int, string]] {
+//	        return func() either.Either[error, tailrec.Trampoline[int, string]] {
+//	            if n <= 0 {
+//	                return either.Right[error](tailrec.Land[int]("Done!"))
+//	            }
+//	            // Simulate some work
+//	            time.Sleep(100 * time.Millisecond)
+//	            return either.Right[error](tailrec.Bounce[string](n - 1))
+//	        }
+//	    }
+//	}
+//
+//	countdown := readerioresult.TailRec(countdownStep)
+//
+//	// With cancellation
+//	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
+//	defer cancel()
+//	result := countdown(10)(ctx)() // Will be cancelled after ~500ms
+//
+// # Example: Cancellable File Processing
+//
+//	type ProcessState struct {
+//	    files     []string
+//	    processed []string
+//	}
+//
+//	processStep := func(state ProcessState) readerioresult.ReaderIOResult[tailrec.Trampoline[ProcessState, []string]] {
+//	    return func(ctx context.Context) ioeither.IOEither[error, tailrec.Trampoline[ProcessState, []string]] {
+//	        return func() either.Either[error, tailrec.Trampoline[ProcessState, []string]] {
+//	            if len(state.files) == 0 {
+//	                return either.Right[error](tailrec.Land[ProcessState](state.processed))
+//	            }
+//
+//	            file := state.files[0]
+//	            // Process file (this could be cancelled via context)
+//	            if err := processFileWithContext(ctx, file); err != nil {
+//	                return either.Left[tailrec.Trampoline[ProcessState, []string]](err)
+//	            }
+//
+//	            return either.Right[error](tailrec.Bounce[[]string](ProcessState{
+//	                files:     state.files[1:],
+//	                processed: append(state.processed, file),
+//	            }))
+//	        }
+//	    }
+//	}
+//
+//	processFiles := readerioresult.TailRec(processStep)
+//	ctx, cancel := context.WithCancel(context.Background())
+//
+//	// Can be cancelled at any point during processing
+//	go func() {
+//	    time.Sleep(2 * time.Second)
+//	    cancel() // Cancel after 2 seconds
+//	}()
+//
+//	result := processFiles(ProcessState{files: manyFiles})(ctx)()
+//
+// # Stack Safety
+//
+// The iterative implementation ensures that even deeply recursive computations
+// (thousands or millions of iterations) will not cause stack overflow, while
+// still respecting context cancellation:
+//
+//	// Safe for very large inputs with cancellation support
+//	largeCountdown := readerioresult.TailRec(countdownStep)
+//	ctx := context.Background()
+//	result := largeCountdown(1000000)(ctx)() // Safe, no stack overflow
+//
+// # Performance Considerations
+//
+//   - Each iteration includes context cancellation checking overhead
+//   - Context checking happens before each recursive step
+//   - For performance-critical code, consider the cancellation checking cost
+//   - The [WithContext] wrapper adds minimal overhead for cancellation safety
+//
+// # See Also
+//
+//   - [readerioresult.TailRec]: Base tail recursion without automatic context checking
+//   - [WithContext]: Context cancellation wrapper used internally
+//   - [Chain]: For sequencing ReaderIOResult computations
+//   - [Ask]: For accessing the context
+//   - [Left]/[Right]: For creating error/success values
+//
+//go:inline
+func TailRec[A, B any](f Kleisli[A, Trampoline[A, B]]) Kleisli[A, B] {
+	return RIOR.TailRec(F.Flow2(f, WithContext))
+}

v2/context/readerioresult/rec_test.go

@@ -0,0 +1,434 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	A "github.com/IBM/fp-go/v2/array"
+	E "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/tailrec"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTailRec_BasicRecursion(t *testing.T) {
+	// Test basic countdown recursion
+	countdownStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(5)(context.Background())()
+
+	assert.Equal(t, E.Of[error]("Done!"), result)
+}
+
+func TestTailRec_FactorialRecursion(t *testing.T) {
+	// Test factorial computation using tail recursion
+	type FactorialState struct {
+		n   int
+		acc int
+	}
+
+	factorialStep := func(state FactorialState) ReaderIOResult[Trampoline[FactorialState, int]] {
+		return func(ctx context.Context) IOEither[Trampoline[FactorialState, int]] {
+			return func() Either[Trampoline[FactorialState, int]] {
+				if state.n <= 1 {
+					return E.Right[error](tailrec.Land[FactorialState](state.acc))
+				}
+				return E.Right[error](tailrec.Bounce[int](FactorialState{
+					n:   state.n - 1,
+					acc: state.acc * state.n,
+				}))
+			}
+		}
+	}
+
+	factorial := TailRec(factorialStep)
+	result := factorial(FactorialState{n: 5, acc: 1})(context.Background())()
+
+	assert.Equal(t, E.Of[error](120), result) // 5! = 120
+}
+
+func TestTailRec_ErrorHandling(t *testing.T) {
+	// Test that errors are properly propagated
+	testErr := errors.New("computation error")
+
+	errorStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				if n == 3 {
+					return E.Left[Trampoline[int, string]](testErr)
+				}
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	errorRecursion := TailRec(errorStep)
+	result := errorRecursion(5)(context.Background())()
+
+	assert.True(t, E.IsLeft(result))
+	err := E.ToError(result)
+	assert.Equal(t, testErr, err)
+}
+
+func TestTailRec_ContextCancellation(t *testing.T) {
+	// Test that recursion gets cancelled early when context is canceled
+	var iterationCount int32
+
+	slowStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				atomic.AddInt32(&iterationCount, 1)
+
+				// Simulate some work
+				time.Sleep(50 * time.Millisecond)
+
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	slowRecursion := TailRec(slowStep)
+
+	// Create a context that will be cancelled after 100ms
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	start := time.Now()
+	result := slowRecursion(10)(ctx)()
+	elapsed := time.Since(start)
+
+	// Should be cancelled and return an error
+	assert.True(t, E.IsLeft(result))
+
+	// Should complete quickly due to cancellation (much less than 10 * 50ms = 500ms)
+	assert.Less(t, elapsed, 200*time.Millisecond)
+
+	// Should have executed only a few iterations before cancellation
+	iterations := atomic.LoadInt32(&iterationCount)
+	assert.Less(t, iterations, int32(5), "Should have been cancelled before completing all iterations")
+}
+
+func TestTailRec_ImmediateCancellation(t *testing.T) {
+	// Test with an already cancelled context
+	countdownStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+
+	// Create an already cancelled context
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	result := countdown(5)(ctx)()
+
+	// Should immediately return a cancellation error
+	assert.True(t, E.IsLeft(result))
+	err := E.ToError(result)
+	assert.Equal(t, context.Canceled, err)
+}
+
+func TestTailRec_StackSafety(t *testing.T) {
+	// Test that deep recursion doesn't cause stack overflow
+	const largeN = 10000
+
+	countdownStep := func(n int) ReaderIOResult[Trampoline[int, int]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, int]] {
+			return func() Either[Trampoline[int, int]] {
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int](0))
+				}
+				return E.Right[error](tailrec.Bounce[int](n - 1))
+			}
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(largeN)(context.Background())()
+
+	assert.Equal(t, E.Of[error](0), result)
+}
+
+func TestTailRec_StackSafetyWithCancellation(t *testing.T) {
+	// Test stack safety with cancellation after many iterations
+	const largeN = 100000
+	var iterationCount int32
+
+	countdownStep := func(n int) ReaderIOResult[Trampoline[int, int]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, int]] {
+			return func() Either[Trampoline[int, int]] {
+				atomic.AddInt32(&iterationCount, 1)
+
+				// Add a small delay every 1000 iterations to make cancellation more likely
+				if n%1000 == 0 {
+					time.Sleep(1 * time.Millisecond)
+				}
+
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int](0))
+				}
+				return E.Right[error](tailrec.Bounce[int](n - 1))
+			}
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+
+	// Cancel after 50ms to allow some iterations but not all
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+
+	result := countdown(largeN)(ctx)()
+
+	// Should be cancelled (or completed if very fast)
+	// The key is that it doesn't cause a stack overflow
+	iterations := atomic.LoadInt32(&iterationCount)
+	assert.Greater(t, iterations, int32(0))
+
+	// If it was cancelled, verify it didn't complete all iterations
+	if E.IsLeft(result) {
+		assert.Less(t, iterations, int32(largeN))
+	}
+}
+
+func TestTailRec_ComplexState(t *testing.T) {
+	// Test with more complex state management
+	type ProcessState struct {
+		items     []string
+		processed []string
+		errors    []error
+	}
+
+	processStep := func(state ProcessState) ReaderIOResult[Trampoline[ProcessState, []string]] {
+		return func(ctx context.Context) IOEither[Trampoline[ProcessState, []string]] {
+			return func() Either[Trampoline[ProcessState, []string]] {
+				if A.IsEmpty(state.items) {
+					return E.Right[error](tailrec.Land[ProcessState](state.processed))
+				}
+
+				item := state.items[0]
+
+				// Simulate processing that might fail for certain items
+				if item == "error-item" {
+					return E.Left[Trampoline[ProcessState, []string]](
+						fmt.Errorf("failed to process item: %s", item))
+				}
+
+				return E.Right[error](tailrec.Bounce[[]string](ProcessState{
+					items:     state.items[1:],
+					processed: append(state.processed, item),
+					errors:    state.errors,
+				}))
+			}
+		}
+	}
+
+	processItems := TailRec(processStep)
+
+	t.Run("successful processing", func(t *testing.T) {
+		initialState := ProcessState{
+			items:     []string{"item1", "item2", "item3"},
+			processed: []string{},
+			errors:    []error{},
+		}
+
+		result := processItems(initialState)(context.Background())()
+
+		assert.Equal(t, E.Of[error]([]string{"item1", "item2", "item3"}), result)
+	})
+
+	t.Run("processing with error", func(t *testing.T) {
+		initialState := ProcessState{
+			items:     []string{"item1", "error-item", "item3"},
+			processed: []string{},
+			errors:    []error{},
+		}
+
+		result := processItems(initialState)(context.Background())()
+
+		assert.True(t, E.IsLeft(result))
+		err := E.ToError(result)
+		assert.Contains(t, err.Error(), "failed to process item: error-item")
+	})
+}
+
+func TestTailRec_CancellationDuringProcessing(t *testing.T) {
+	// Test cancellation during a realistic processing scenario
+	type FileProcessState struct {
+		files     []string
+		processed int
+	}
+
+	var processedCount int32
+
+	processFileStep := func(state FileProcessState) ReaderIOResult[Trampoline[FileProcessState, int]] {
+		return func(ctx context.Context) IOEither[Trampoline[FileProcessState, int]] {
+			return func() Either[Trampoline[FileProcessState, int]] {
+				if A.IsEmpty(state.files) {
+					return E.Right[error](tailrec.Land[FileProcessState](state.processed))
+				}
+
+				// Simulate file processing time
+				time.Sleep(20 * time.Millisecond)
+				atomic.AddInt32(&processedCount, 1)
+
+				return E.Right[error](tailrec.Bounce[int](FileProcessState{
+					files:     state.files[1:],
+					processed: state.processed + 1,
+				}))
+			}
+		}
+	}
+
+	processFiles := TailRec(processFileStep)
+
+	// Create many files to process
+	files := make([]string, 20)
+	for i := range files {
+		files[i] = fmt.Sprintf("file%d.txt", i)
+	}
+
+	initialState := FileProcessState{
+		files:     files,
+		processed: 0,
+	}
+
+	// Cancel after 100ms (should allow ~5 files to be processed)
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+
+	start := time.Now()
+	result := processFiles(initialState)(ctx)()
+	elapsed := time.Since(start)
+
+	// Should be cancelled
+	assert.True(t, E.IsLeft(result))
+
+	// Should complete quickly due to cancellation
+	assert.Less(t, elapsed, 150*time.Millisecond)
+
+	// Should have processed some but not all files
+	processed := atomic.LoadInt32(&processedCount)
+	assert.Greater(t, processed, int32(0))
+	assert.Less(t, processed, int32(20))
+}
+
+func TestTailRec_ZeroIterations(t *testing.T) {
+	// Test case where recursion terminates immediately
+	immediateStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				return E.Right[error](tailrec.Land[int]("immediate"))
+			}
+		}
+	}
+
+	immediate := TailRec(immediateStep)
+	result := immediate(100)(context.Background())()
+
+	assert.Equal(t, E.Of[error]("immediate"), result)
+}
+
+func TestTailRec_ContextWithDeadline(t *testing.T) {
+	// Test with context deadline
+	var iterationCount int32
+
+	slowStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				atomic.AddInt32(&iterationCount, 1)
+				time.Sleep(30 * time.Millisecond)
+
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	slowRecursion := TailRec(slowStep)
+
+	// Set deadline 80ms from now
+	ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(80*time.Millisecond))
+	defer cancel()
+
+	result := slowRecursion(10)(ctx)()
+
+	// Should be cancelled due to deadline
+	assert.True(t, E.IsLeft(result))
+
+	// Should have executed only a few iterations
+	iterations := atomic.LoadInt32(&iterationCount)
+	assert.Greater(t, iterations, int32(0))
+	assert.Less(t, iterations, int32(5))
+}
+
+func TestTailRec_ContextWithValue(t *testing.T) {
+	// Test that context values are preserved through recursion
+	type contextKey string
+	const testKey contextKey = "test"
+
+	valueStep := func(n int) ReaderIOResult[Trampoline[int, string]] {
+		return func(ctx context.Context) IOEither[Trampoline[int, string]] {
+			return func() Either[Trampoline[int, string]] {
+				value := ctx.Value(testKey)
+				require.NotNil(t, value)
+				assert.Equal(t, "test-value", value.(string))
+
+				if n <= 0 {
+					return E.Right[error](tailrec.Land[int]("Done!"))
+				}
+				return E.Right[error](tailrec.Bounce[string](n - 1))
+			}
+		}
+	}
+
+	valueRecursion := TailRec(valueStep)
+	ctx := context.WithValue(context.Background(), testKey, "test-value")
+	result := valueRecursion(3)(ctx)()
+
+	assert.Equal(t, E.Of[error]("Done!"), result)
+}

v2/context/readerioresult/resource.go

@@ -16,7 +16,11 @@
 package readerioresult
 
 import (
+	"context"
+	"io"
+
 	RIOR "github.com/IBM/fp-go/v2/readerioresult"
+	"github.com/IBM/fp-go/v2/result"
 )
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource.
@@ -55,3 +59,111 @@ import (
 func WithResource[A, R, ANY any](onCreate ReaderIOResult[R], onRelease Kleisli[R, ANY]) Kleisli[Kleisli[R, A], A] {
 	return RIOR.WithResource[A](onCreate, onRelease)
 }
+
+// onClose is a helper function that creates a ReaderIOResult for closing an io.Closer resource.
+// It safely calls the Close() method and handles any errors that may occur during closing.
+//
+// Type Parameters:
+//   - A: Must implement io.Closer interface
+//
+// Parameters:
+//   - a: The resource to close
+//
+// Returns:
+//   - ReaderIOResult[any]: A computation that closes the resource and returns nil on success
+//
+// The function ignores the context parameter since closing operations typically don't need context.
+// Any error from Close() is captured and returned as a Result error.
+func onClose[A io.Closer](a A) ReaderIOResult[any] {
+	return func(_ context.Context) IOResult[any] {
+		return func() Result[any] {
+			return result.TryCatchError[any](nil, a.Close())
+		}
+	}
+}
+
+// WithCloser creates a resource management function specifically for io.Closer resources.
+// This is a specialized version of WithResource that automatically handles closing of resources
+// that implement the io.Closer interface.
+//
+// The function ensures that:
+//   - The resource is created using the onCreate function
+//   - The resource is automatically closed when the operation completes (success or failure)
+//   - Any errors during closing are properly handled
+//   - The resource is closed even if the main operation fails or the context is canceled
+//
+// Type Parameters:
+//   - B: The type of value returned by the resource-using function
+//   - A: The type of resource that implements io.Closer
+//
+// Parameters:
+//   - onCreate: ReaderIOResult that creates the io.Closer resource
+//
+// Returns:
+//   - A function that takes a resource-using function and returns a ReaderIOResult[B]
+//
+// Example with file operations:
+//
+//	openFile := func(filename string) ReaderIOResult[*os.File] {
+//	    return TryCatch(func(ctx context.Context) func() (*os.File, error) {
+//	        return func() (*os.File, error) {
+//	            return os.Open(filename)
+//	        }
+//	    })
+//	}
+//
+//	fileReader := WithCloser(openFile("data.txt"))
+//	result := fileReader(func(f *os.File) ReaderIOResult[string] {
+//	    return TryCatch(func(ctx context.Context) func() (string, error) {
+//	        return func() (string, error) {
+//	            data, err := io.ReadAll(f)
+//	            return string(data), err
+//	        }
+//	    })
+//	})
+//
+// Example with HTTP response:
+//
+//	httpGet := func(url string) ReaderIOResult[*http.Response] {
+//	    return TryCatch(func(ctx context.Context) func() (*http.Response, error) {
+//	        return func() (*http.Response, error) {
+//	            return http.Get(url)
+//	        }
+//	    })
+//	}
+//
+//	responseReader := WithCloser(httpGet("https://api.example.com/data"))
+//	result := responseReader(func(resp *http.Response) ReaderIOResult[[]byte] {
+//	    return TryCatch(func(ctx context.Context) func() ([]byte, error) {
+//	        return func() ([]byte, error) {
+//	            return io.ReadAll(resp.Body)
+//	        }
+//	    })
+//	})
+//
+// Example with database connection:
+//
+//	openDB := func(dsn string) ReaderIOResult[*sql.DB] {
+//	    return TryCatch(func(ctx context.Context) func() (*sql.DB, error) {
+//	        return func() (*sql.DB, error) {
+//	            return sql.Open("postgres", dsn)
+//	        }
+//	    })
+//	}
+//
+//	dbQuery := WithCloser(openDB("postgres://..."))
+//	result := dbQuery(func(db *sql.DB) ReaderIOResult[[]User] {
+//	    return TryCatch(func(ctx context.Context) func() ([]User, error) {
+//	        return func() ([]User, error) {
+//	            rows, err := db.QueryContext(ctx, "SELECT * FROM users")
+//	            if err != nil {
+//	                return nil, err
+//	            }
+//	            defer rows.Close()
+//	            return scanUsers(rows)
+//	        }
+//	    })
+//	})
+func WithCloser[B any, A io.Closer](onCreate ReaderIOResult[A]) Kleisli[Kleisli[A, B], B] {
+	return WithResource[B](onCreate, onClose[A])
+}

v2/context/readerioresult/retry.go

@@ -0,0 +1,181 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache LicensVersion 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+	"time"
+
+	RIO "github.com/IBM/fp-go/v2/context/readerio"
+	R "github.com/IBM/fp-go/v2/retry"
+	RG "github.com/IBM/fp-go/v2/retry/generic"
+)
+
+// Retrying retries a ReaderIOResult computation according to a retry policy with context awareness.
+//
+// This function implements a retry mechanism for operations that depend on a [context.Context],
+// perform side effects (IO), and can fail (Result). It respects context cancellation, meaning
+// that if the context is cancelled during retry delays, the operation will stop immediately
+// and return the cancellation error.
+//
+// The retry loop will continue until one of the following occurs:
+//   - The action succeeds and the check function returns false (no retry needed)
+//   - The retry policy returns None (retry limit reached)
+//   - The check function returns false (indicating success or a non-retryable failure)
+//   - The context is cancelled (returns context.Canceled or context.DeadlineExceeded)
+//
+// Parameters:
+//
+//   - policy: A RetryPolicy that determines when and how long to wait between retries.
+//     The policy receives a RetryStatus on each iteration and returns an optional delay.
+//     If it returns None, retrying stops. Common policies include LimitRetries,
+//     ExponentialBackoff, and CapDelay from the retry package.
+//
+//   - action: A Kleisli arrow that takes a RetryStatus and returns a ReaderIOResult[A].
+//     This function is called on each retry attempt and receives information about the
+//     current retry state (iteration number, cumulative delay, etc.). The action depends
+//     on a context.Context and produces a Result[A]. The context passed to the action
+//     will be the same context used for retry delays, so cancellation is properly propagated.
+//
+//   - check: A predicate function that examines the Result[A] and returns true if the
+//     operation should be retried, or false if it should stop. This allows you to
+//     distinguish between retryable failures (e.g., network timeouts) and permanent
+//     failures (e.g., invalid input). Note that context cancellation errors will
+//     automatically stop retrying regardless of this function's return value.
+//
+// Returns:
+//
+//	A ReaderIOResult[A] that, when executed with a context, will perform the retry
+//	logic with context cancellation support and return the final result.
+//
+// Type Parameters:
+//   - A: The type of the success value
+//
+// Context Cancellation:
+//
+// The retry mechanism respects context cancellation in two ways:
+//  1. During retry delays: If the context is cancelled while waiting between retries,
+//     the operation stops immediately and returns the context error.
+//  2. During action execution: If the action itself checks the context and returns
+//     an error due to cancellation, the retry loop will stop (assuming the check
+//     function doesn't force a retry on context errors).
+//
+// Example:
+//
+//	// Create a retry policy: exponential backoff with a cap, limited to 5 retries
+//	policy := M.Concat(
+//	    retry.LimitRetries(5),
+//	    retry.CapDelay(10*time.Second, retry.ExponentialBackoff(100*time.Millisecond)),
+//	)(retry.Monoid)
+//
+//	// Action that fetches data, with retry status information
+//	fetchData := func(status retry.RetryStatus) ReaderIOResult[string] {
+//	    return func(ctx context.Context) IOResult[string] {
+//	        return func() Result[string] {
+//	            // Check if context is cancelled
+//	            if ctx.Err() != nil {
+//	                return result.Left[string](ctx.Err())
+//	            }
+//	            // Simulate an HTTP request that might fail
+//	            if status.IterNumber < 3 {
+//	                return result.Left[string](fmt.Errorf("temporary error"))
+//	            }
+//	            return result.Of("success")
+//	        }
+//	    }
+//	}
+//
+//	// Check function: retry on any error except context cancellation
+//	shouldRetry := func(r Result[string]) bool {
+//	    return result.IsLeft(r) && !errors.Is(result.GetLeft(r), context.Canceled)
+//	}
+//
+//	// Create the retrying computation
+//	retryingFetch := Retrying(policy, fetchData, shouldRetry)
+//
+//	// Execute with a cancellable context
+//	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+//	defer cancel()
+//	ioResult := retryingFetch(ctx)
+//	finalResult := ioResult()
+//
+// See also:
+//   - retry.RetryPolicy for available retry policies
+//   - retry.RetryStatus for information passed to the action
+//   - context.Context for context cancellation semantics
+//
+//go:inline
+func Retrying[A any](
+	policy R.RetryPolicy,
+	action Kleisli[R.RetryStatus, A],
+	check Predicate[Result[A]],
+) ReaderIOResult[A] {
+
+	// delayWithCancel implements a context-aware delay mechanism for retry operations.
+	// It creates a timeout context that will be cancelled when either:
+	//   1. The delay duration expires (normal case), or
+	//   2. The parent context is cancelled (early termination)
+	//
+	// The function waits on timeoutCtx.Done(), which will be signaled in either case:
+	//   - If the delay expires, timeoutCtx is cancelled by the timeout
+	//   - If the parent ctx is cancelled, timeoutCtx inherits the cancellation
+	//
+	// After the wait completes, we dispatch to the next action by calling ri(ctx)().
+	// This works correctly because the action is wrapped in WithContextK, which handles
+	// context cancellation by checking ctx.Err() and returning an appropriate error
+	// (context.Canceled or context.DeadlineExceeded) when the context is cancelled.
+	//
+	// This design ensures that:
+	//   - Retry delays respect context cancellation and terminate immediately
+	//   - The cancellation error propagates correctly through the retry chain
+	//   - No unnecessary delays occur when the context is already cancelled
+	delayWithCancel := func(delay time.Duration) RIO.Operator[R.RetryStatus, R.RetryStatus] {
+		return func(ri ReaderIO[R.RetryStatus]) ReaderIO[R.RetryStatus] {
+			return func(ctx context.Context) IO[R.RetryStatus] {
+				return func() R.RetryStatus {
+					// Create a timeout context that will be cancelled when either:
+					// - The delay duration expires, or
+					// - The parent context is cancelled
+					timeoutCtx, cancelTimeout := context.WithTimeout(ctx, delay)
+					defer cancelTimeout()
+
+					// Wait for either the timeout or parent context cancellation
+					<-timeoutCtx.Done()
+
+					// Dispatch to the next action with the original context.
+					// WithContextK will handle context cancellation correctly.
+					return ri(ctx)()
+				}
+			}
+		}
+	}
+
+	// get an implementation for the types
+	return RG.Retrying(
+		RIO.Chain[Result[A], Trampoline[R.RetryStatus, Result[A]]],
+		RIO.Map[R.RetryStatus, Trampoline[R.RetryStatus, Result[A]]],
+		RIO.Of[Trampoline[R.RetryStatus, Result[A]]],
+		RIO.Of[R.RetryStatus],
+		delayWithCancel,
+
+		RIO.TailRec,
+
+		policy,
+		WithContextK(action),
+		check,
+	)
+
+}

v2/context/readerioresult/retry_test.go

@@ -0,0 +1,511 @@
+// Copyright (c) 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerioresult
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/IBM/fp-go/v2/result"
+	R "github.com/IBM/fp-go/v2/retry"
+	"github.com/stretchr/testify/assert"
+)
+
+// Helper function to create a test retry policy
+func testRetryPolicy() R.RetryPolicy {
+	return R.Monoid.Concat(
+		R.LimitRetries(5),
+		R.CapDelay(1*time.Second, R.ExponentialBackoff(10*time.Millisecond)),
+	)
+}
+
+// TestRetrying_SuccessOnFirstAttempt tests that Retrying succeeds immediately
+// when the action succeeds on the first attempt.
+func TestRetrying_SuccessOnFirstAttempt(t *testing.T) {
+	policy := testRetryPolicy()
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				return result.Of("success")
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+
+	assert.Equal(t, result.Of("success"), res)
+}
+
+// TestRetrying_SuccessAfterRetries tests that Retrying eventually succeeds
+// after a few failed attempts.
+func TestRetrying_SuccessAfterRetries(t *testing.T) {
+	policy := testRetryPolicy()
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				// Fail on first 3 attempts, succeed on 4th
+				if status.IterNumber < 3 {
+					return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+				}
+				return result.Of(fmt.Sprintf("success on attempt %d", status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+
+	assert.Equal(t, result.Of("success on attempt 3"), res)
+}
+
+// TestRetrying_ExhaustsRetries tests that Retrying stops after the retry limit
+// is reached and returns the last error.
+func TestRetrying_ExhaustsRetries(t *testing.T) {
+	policy := R.LimitRetries(3)
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+
+	assert.True(t, result.IsLeft(res))
+	assert.Equal(t, result.Left[string](fmt.Errorf("attempt 3 failed")), res)
+}
+
+// TestRetrying_ActionChecksContextCancellation tests that actions can check
+// the context and return early if it's cancelled.
+func TestRetrying_ActionChecksContextCancellation(t *testing.T) {
+	policy := R.LimitRetries(10)
+
+	attemptCount := 0
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				attemptCount++
+
+				// Check context at the start of the action
+				if ctx.Err() != nil {
+					return result.Left[string](ctx.Err())
+				}
+
+				// Simulate work that might take time
+				time.Sleep(10 * time.Millisecond)
+
+				// Check context again after work
+				if ctx.Err() != nil {
+					return result.Left[string](ctx.Err())
+				}
+
+				// Always fail to trigger retries
+				return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		// Don't retry on context errors
+		val, err := result.Unwrap(r)
+		_ = val
+		if err != nil && (errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)) {
+			return false
+		}
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+
+	// Create a context that we'll cancel after a short time
+	ctx, cancel := context.WithCancel(t.Context())
+
+	// Start the retry operation in a goroutine
+	resultChan := make(chan Result[string], 1)
+	go func() {
+		res := retrying(ctx)()
+		resultChan <- res
+	}()
+
+	// Cancel the context after allowing a couple attempts
+	time.Sleep(50 * time.Millisecond)
+	cancel()
+
+	// Wait for the result
+	res := <-resultChan
+
+	// Should have stopped due to context cancellation
+	assert.True(t, result.IsLeft(res))
+
+	// Should have stopped early (not all 10 attempts)
+	assert.Less(t, attemptCount, 10, "Should stop retrying when action detects context cancellation")
+
+	// The error should be related to context cancellation or an early attempt
+	val, err := result.Unwrap(res)
+	_ = val
+	assert.Error(t, err)
+}
+
+// TestRetrying_ContextCancelledBeforeStart tests that if the context is already
+// cancelled before starting, the operation fails immediately.
+func TestRetrying_ContextCancelledBeforeStart(t *testing.T) {
+	policy := testRetryPolicy()
+
+	attemptCount := 0
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				attemptCount++
+				// Check context before doing work
+				if ctx.Err() != nil {
+					return result.Left[string](ctx.Err())
+				}
+				return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		// Don't retry on context errors
+		val, err := result.Unwrap(r)
+		_ = val
+		if err != nil && errors.Is(err, context.Canceled) {
+			return false
+		}
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+
+	// Create an already-cancelled context
+	ctx, cancel := context.WithCancel(t.Context())
+	cancel()
+
+	res := retrying(ctx)()
+
+	assert.True(t, result.IsLeft(res))
+	val, err := result.Unwrap(res)
+	_ = val
+	assert.True(t, errors.Is(err, context.Canceled))
+
+	// Should have attempted at most once
+	assert.LessOrEqual(t, attemptCount, 1)
+}
+
+// TestRetrying_ContextTimeoutInAction tests that actions respect context deadlines.
+func TestRetrying_ContextTimeoutInAction(t *testing.T) {
+	policy := R.LimitRetries(10)
+
+	attemptCount := 0
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				attemptCount++
+
+				// Check context before doing work
+				if ctx.Err() != nil {
+					return result.Left[string](ctx.Err())
+				}
+
+				// Simulate some work
+				time.Sleep(50 * time.Millisecond)
+
+				// Check context after work
+				if ctx.Err() != nil {
+					return result.Left[string](ctx.Err())
+				}
+
+				// Always fail to trigger retries
+				return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		// Don't retry on context errors
+		val, err := result.Unwrap(r)
+		_ = val
+		if err != nil && (errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded)) {
+			return false
+		}
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+
+	// Create a context with a short timeout
+	ctx, cancel := context.WithTimeout(t.Context(), 150*time.Millisecond)
+	defer cancel()
+
+	startTime := time.Now()
+	res := retrying(ctx)()
+	elapsed := time.Since(startTime)
+
+	assert.True(t, result.IsLeft(res))
+
+	// Should have stopped before completing all 10 retries
+	assert.Less(t, attemptCount, 10, "Should stop retrying when action detects context timeout")
+
+	// Should have stopped around the timeout duration
+	assert.Less(t, elapsed, 500*time.Millisecond, "Should stop soon after timeout")
+}
+
+// TestRetrying_CheckFunctionStopsRetry tests that the check function can
+// stop retrying even when errors occur.
+func TestRetrying_CheckFunctionStopsRetry(t *testing.T) {
+	policy := testRetryPolicy()
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				if status.IterNumber == 0 {
+					return result.Left[string](fmt.Errorf("retryable error"))
+				}
+				return result.Left[string](fmt.Errorf("permanent error"))
+			}
+		}
+	}
+
+	// Only retry on "retryable error"
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r) && result.Fold(
+			func(err error) bool { return err.Error() == "retryable error" },
+			func(string) bool { return false },
+		)(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+
+	assert.Equal(t, result.Left[string](fmt.Errorf("permanent error")), res)
+}
+
+// TestRetrying_ExponentialBackoff tests that exponential backoff is applied.
+func TestRetrying_ExponentialBackoff(t *testing.T) {
+	// Use a policy with measurable delays
+	policy := R.Monoid.Concat(
+		R.LimitRetries(3),
+		R.ExponentialBackoff(50*time.Millisecond),
+	)
+
+	startTime := time.Now()
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				if status.IterNumber < 2 {
+					return result.Left[string](fmt.Errorf("retry"))
+				}
+				return result.Of("success")
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+	elapsed := time.Since(startTime)
+
+	assert.Equal(t, result.Of("success"), res)
+	// With exponential backoff starting at 50ms:
+	// Iteration 0: no delay
+	// Iteration 1: 50ms delay
+	// Iteration 2: 100ms delay
+	// Total should be at least 150ms
+	assert.GreaterOrEqual(t, elapsed, 150*time.Millisecond)
+}
+
+// TestRetrying_ContextValuePropagation tests that context values are properly
+// propagated through the retry mechanism.
+func TestRetrying_ContextValuePropagation(t *testing.T) {
+	policy := R.LimitRetries(2)
+
+	type contextKey string
+	const requestIDKey contextKey = "requestID"
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				// Extract value from context
+				requestID, ok := ctx.Value(requestIDKey).(string)
+				if !ok {
+					return result.Left[string](fmt.Errorf("missing request ID"))
+				}
+
+				if status.IterNumber < 1 {
+					return result.Left[string](fmt.Errorf("retry needed"))
+				}
+
+				return result.Of(fmt.Sprintf("processed request %s", requestID))
+			}
+		}
+	}
+
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+
+	// Create context with a value
+	ctx := context.WithValue(t.Context(), requestIDKey, "12345")
+
+	res := retrying(ctx)()
+
+	assert.Equal(t, result.Of("processed request 12345"), res)
+}
+
+// TestRetrying_RetryStatusProgression tests that the RetryStatus is properly
+// updated on each iteration.
+func TestRetrying_RetryStatusProgression(t *testing.T) {
+	policy := testRetryPolicy()
+
+	var iterations []uint
+
+	action := func(status R.RetryStatus) ReaderIOResult[int] {
+		return func(ctx context.Context) IOResult[int] {
+			return func() Result[int] {
+				iterations = append(iterations, status.IterNumber)
+				if status.IterNumber < 3 {
+					return result.Left[int](fmt.Errorf("retry"))
+				}
+				return result.Of(int(status.IterNumber))
+			}
+		}
+	}
+
+	check := func(r Result[int]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+	ctx := t.Context()
+
+	res := retrying(ctx)()
+
+	assert.Equal(t, result.Of(3), res)
+	// Should have attempted iterations 0, 1, 2, 3
+	assert.Equal(t, []uint{0, 1, 2, 3}, iterations)
+}
+
+// TestRetrying_ContextCancelledDuringDelay tests that the retry operation
+// stops immediately when the context is cancelled during a retry delay,
+// even if there are still retries remaining according to the policy.
+func TestRetrying_ContextCancelledDuringDelay(t *testing.T) {
+	// Use a policy with significant delays to ensure we can cancel during the delay
+	policy := R.Monoid.Concat(
+		R.LimitRetries(10),
+		R.ConstantDelay(200*time.Millisecond),
+	)
+
+	attemptCount := 0
+
+	action := func(status R.RetryStatus) ReaderIOResult[string] {
+		return func(ctx context.Context) IOResult[string] {
+			return func() Result[string] {
+				attemptCount++
+				// Always fail to trigger retries
+				return result.Left[string](fmt.Errorf("attempt %d failed", status.IterNumber))
+			}
+		}
+	}
+
+	// Always retry on errors (don't check for context cancellation in check function)
+	check := func(r Result[string]) bool {
+		return result.IsLeft(r)
+	}
+
+	retrying := Retrying(policy, action, check)
+
+	// Create a context that we'll cancel during the retry delay
+	ctx, cancel := context.WithCancel(t.Context())
+
+	// Start the retry operation in a goroutine
+	resultChan := make(chan Result[string], 1)
+	startTime := time.Now()
+	go func() {
+		res := retrying(ctx)()
+		resultChan <- res
+	}()
+
+	// Wait for the first attempt to complete and the delay to start
+	time.Sleep(50 * time.Millisecond)
+
+	// Cancel the context during the retry delay
+	cancel()
+
+	// Wait for the result
+	res := <-resultChan
+	elapsed := time.Since(startTime)
+
+	// Should have stopped due to context cancellation
+	assert.True(t, result.IsLeft(res))
+
+	// Should have attempted only once or twice (not all 10 attempts)
+	// because the context was cancelled during the delay
+	assert.LessOrEqual(t, attemptCount, 2, "Should stop retrying when context is cancelled during delay")
+
+	// Should have stopped quickly after cancellation, not waiting for all delays
+	// With 10 retries and 200ms delays, it would take ~2 seconds without cancellation
+	// With cancellation during first delay, it should complete in well under 500ms
+	assert.Less(t, elapsed, 500*time.Millisecond, "Should stop immediately when context is cancelled during delay")
+
+	// When context is cancelled during the delay, the retry mechanism
+	// detects the cancellation and returns a context error
+	val, err := result.Unwrap(res)
+	_ = val
+	assert.Error(t, err)
+	// The error should be a context cancellation error since cancellation
+	// happened during the delay between retries
+	assert.True(t, errors.Is(err, context.Canceled), "Should return context.Canceled when cancelled during delay")
+}

v2/context/readerioresult/traverse.go

@@ -18,6 +18,7 @@ package readerioresult
 import (
 	"github.com/IBM/fp-go/v2/array"
 	"github.com/IBM/fp-go/v2/function"
+	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/record"
 )
 
@@ -34,7 +35,7 @@ func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
 		Map[[]B, func(B) []B],
 		Ap[[]B, B],
 
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -78,7 +79,7 @@ func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, ma
 		Map[map[K]B, func(B) map[K]B],
 		Ap[map[K]B, B],
 
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -123,7 +124,7 @@ func MonadTraverseArraySeq[A, B any](as []A, f Kleisli[A, B]) ReaderIOResult[[]B
 		Map[[]B, func(B) []B],
 		ApSeq[[]B, B],
 		as,
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -139,7 +140,7 @@ func TraverseArraySeq[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
 		Of[[]B],
 		Map[[]B, func(B) []B],
 		ApSeq[[]B, B],
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -171,7 +172,7 @@ func MonadTraverseRecordSeq[K comparable, A, B any](as map[K]A, f Kleisli[A, B])
 		Map[map[K]B, func(B) map[K]B],
 		ApSeq[map[K]B, B],
 		as,
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -182,7 +183,7 @@ func TraverseRecordSeq[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A,
 		Map[map[K]B, func(B) map[K]B],
 		ApSeq[map[K]B, B],
 
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -216,7 +217,7 @@ func MonadTraverseArrayPar[A, B any](as []A, f Kleisli[A, B]) ReaderIOResult[[]B
 		Map[[]B, func(B) []B],
 		ApPar[[]B, B],
 		as,
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -232,7 +233,7 @@ func TraverseArrayPar[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
 		Of[[]B],
 		Map[[]B, func(B) []B],
 		ApPar[[]B, B],
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -264,7 +265,7 @@ func TraverseRecordPar[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A,
 		Map[map[K]B, func(B) map[K]B],
 		ApPar[map[K]B, B],
 
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 
@@ -286,7 +287,7 @@ func MonadTraverseRecordPar[K comparable, A, B any](as map[K]A, f Kleisli[A, B])
 		Map[map[K]B, func(B) map[K]B],
 		ApPar[map[K]B, B],
 		as,
-		f,
+		F.Flow2(f, WithContext),
 	)
 }
 

v2/context/readerioresult/type.go

@@ -18,19 +18,25 @@ package readerioresult
 import (
 	"context"
 
+	"github.com/IBM/fp-go/v2/consumer"
 	"github.com/IBM/fp-go/v2/context/ioresult"
 	"github.com/IBM/fp-go/v2/context/readerresult"
 	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/endomorphism"
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/ioeither"
 	"github.com/IBM/fp-go/v2/lazy"
+	"github.com/IBM/fp-go/v2/optics/lens"
+	"github.com/IBM/fp-go/v2/optics/prism"
 	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 	"github.com/IBM/fp-go/v2/readereither"
 	"github.com/IBM/fp-go/v2/readerio"
 	RIOR "github.com/IBM/fp-go/v2/readerioresult"
 	"github.com/IBM/fp-go/v2/readeroption"
 	"github.com/IBM/fp-go/v2/result"
+	"github.com/IBM/fp-go/v2/tailrec"
 )
 
 type (
@@ -126,4 +132,15 @@ type (
 	ReaderResult[A any]       = readerresult.ReaderResult[A]
 	ReaderEither[R, E, A any] = readereither.ReaderEither[R, E, A]
 	ReaderOption[R, A any]    = readeroption.ReaderOption[R, A]
+
+	Endomorphism[A any] = endomorphism.Endomorphism[A]
+
+	Consumer[A any] = consumer.Consumer[A]
+
+	Prism[S, T any] = prism.Prism[S, T]
+	Lens[S, T any]  = lens.Lens[S, T]
+
+	Trampoline[B, L any] = tailrec.Trampoline[B, L]
+
+	Predicate[A any] = predicate.Predicate[A]
 )

v2/context/readerresult/array.go

@@ -15,11 +15,14 @@
 
 package readerresult
 
-import "github.com/IBM/fp-go/v2/readereither"
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/readereither"
+)
 
 // TraverseArray transforms an array
 func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
-	return readereither.TraverseArray(f)
+	return readereither.TraverseArray(F.Flow2(f, WithContext))
 }
 
 // TraverseArrayWithIndex transforms an array

v2/context/readerresult/bind.go

@@ -17,7 +17,6 @@ package readerresult
 
 import (
 	F "github.com/IBM/fp-go/v2/function"
-	L "github.com/IBM/fp-go/v2/optics/lens"
 	G "github.com/IBM/fp-go/v2/readereither/generic"
 )
 
@@ -31,16 +30,26 @@ import (
 //	    TenantID string
 //	}
 //	result := readereither.Do(State{})
+//
+//go:inline
 func Do[S any](
 	empty S,
 ) ReaderResult[S] {
 	return G.Do[ReaderResult[S]](empty)
 }
 
-// Bind attaches the result of a computation to a context [S1] to produce a context [S2].
+// Bind attaches the result of an EFFECTFUL computation to a context [S1] to produce a context [S2].
 // This enables sequential composition where each step can depend on the results of previous steps
 // and access the context.Context from the environment.
 //
+// IMPORTANT: Bind is for EFFECTFUL FUNCTIONS that depend on context.Context.
+// The function parameter takes state and returns a ReaderResult[T], which is effectful because
+// it depends on context.Context (can be cancelled, has deadlines, carries values).
+//
+// For PURE FUNCTIONS (side-effect free), use:
+//   - BindResultK: For pure functions with errors (State -> (Value, error))
+//   - Let: For pure functions without errors (State -> Value)
+//
 // The setter function takes the result of the computation and returns a function that
 // updates the context from S1 to S2.
 //
@@ -78,14 +87,27 @@ func Do[S any](
 //	        },
 //	    ),
 //	)
+//
+//go:inline
 func Bind[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f Kleisli[S1, T],
 ) Kleisli[ReaderResult[S1], S2] {
-	return G.Bind[ReaderResult[S1], ReaderResult[S2]](setter, f)
+	return G.Bind[ReaderResult[S1], ReaderResult[S2]](setter, F.Flow2(f, WithContext))
 }
 
-// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+// Let attaches the result of a PURE computation to a context [S1] to produce a context [S2].
+//
+// IMPORTANT: Let is for PURE FUNCTIONS (side-effect free) that don't depend on context.Context.
+// The function parameter takes state and returns a value directly, with no errors or effects.
+//
+// For EFFECTFUL FUNCTIONS (that need context.Context), use:
+//   - Bind: For effectful ReaderResult computations (State -> ReaderResult[Value])
+//
+// For PURE FUNCTIONS with error handling, use:
+//   - BindResultK: For pure functions with errors (State -> (Value, error))
+//
+//go:inline
 func Let[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) T,
@@ -93,7 +115,10 @@ func Let[S1, S2, T any](
 	return G.Let[ReaderResult[S1], ReaderResult[S2]](setter, f)
 }
 
-// LetTo attaches the a value to a context [S1] to produce a context [S2]
+// LetTo attaches a constant value to a context [S1] to produce a context [S2].
+// This is a PURE operation (side-effect free) that simply sets a field to a constant value.
+//
+//go:inline
 func LetTo[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	b T,
@@ -102,15 +127,27 @@ func LetTo[S1, S2, T any](
 }
 
 // BindTo initializes a new state [S1] from a value [T]
+//
+//go:inline
 func BindTo[S1, T any](
 	setter func(T) S1,
-) Kleisli[ReaderResult[T], S1] {
+) Operator[T, S1] {
 	return G.BindTo[ReaderResult[S1], ReaderResult[T]](setter)
 }
 
+//go:inline
+func BindToP[S1, T any](
+	setter Prism[S1, T],
+) Operator[T, S1] {
+	return BindTo(setter.ReverseGet)
+}
+
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering
 // the context and the value concurrently (using Applicative rather than Monad).
-// This allows independent computations to be combined without one depending on the result of the other.
+// This allows independent EFFECTFUL computations to be combined without one depending on the result of the other.
+//
+// IMPORTANT: ApS is for EFFECTFUL FUNCTIONS that depend on context.Context.
+// The ReaderResult parameter is effectful because it depends on context.Context.
 //
 // Unlike Bind, which sequences operations, ApS can be used when operations are independent
 // and can conceptually run in parallel.
@@ -145,6 +182,8 @@ func BindTo[S1, T any](
 //	        getTenantID,
 //	    ),
 //	)
+//
+//go:inline
 func ApS[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	fa ReaderResult[T],
@@ -183,17 +222,24 @@ func ApS[S1, S2, T any](
 //	    readereither.Do(Person{Name: "Alice", Age: 25}),
 //	    readereither.ApSL(ageLens, getAge),
 //	)
+//
+//go:inline
 func ApSL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	fa ReaderResult[T],
 ) Kleisli[ReaderResult[S], S] {
 	return ApS(lens.Set, fa)
 }
 
 // BindL is a variant of Bind that uses a lens to focus on a specific field in the state.
-// It combines the lens-based field access with monadic composition, allowing you to:
+// It combines the lens-based field access with monadic composition for EFFECTFUL computations.
+//
+// IMPORTANT: BindL is for EFFECTFUL FUNCTIONS that depend on context.Context.
+// The function parameter returns a ReaderResult, which is effectful.
+//
+// It allows you to:
 // 1. Extract a field value using the lens
-// 2. Use that value in a computation that may fail
+// 2. Use that value in an effectful computation that may fail
 // 3. Update the field with the result
 //
 // Parameters:
@@ -227,15 +273,20 @@ func ApSL[S, T any](
 //	    readereither.Of[error](Counter{Value: 42}),
 //	    readereither.BindL(valueLens, increment),
 //	)
+//
+//go:inline
 func BindL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	f Kleisli[T, T],
 ) Kleisli[ReaderResult[S], S] {
-	return Bind(lens.Set, F.Flow2(lens.Get, f))
+	return Bind(lens.Set, F.Flow2(lens.Get, F.Flow2(f, WithContext)))
 }
 
 // LetL is a variant of Let that uses a lens to focus on a specific field in the state.
-// It applies a pure transformation to the focused field without any effects.
+// It applies a PURE transformation to the focused field without any effects.
+//
+// IMPORTANT: LetL is for PURE FUNCTIONS (side-effect free) that don't depend on context.Context.
+// The function parameter is a pure endomorphism (T -> T) with no errors or effects.
 //
 // Parameters:
 //   - lens: A lens that focuses on a field of type T within state S
@@ -262,15 +313,17 @@ func BindL[S, T any](
 //	    readereither.LetL(valueLens, double),
 //	)
 //	// result when executed will be Right(Counter{Value: 42})
+//
+//go:inline
 func LetL[S, T any](
-	lens L.Lens[S, T],
-	f func(T) T,
+	lens Lens[S, T],
+	f Endomorphism[T],
 ) Kleisli[ReaderResult[S], S] {
 	return Let(lens.Set, F.Flow2(lens.Get, f))
 }
 
 // LetToL is a variant of LetTo that uses a lens to focus on a specific field in the state.
-// It sets the focused field to a constant value.
+// It sets the focused field to a constant value. This is a PURE operation (side-effect free).
 //
 // Parameters:
 //   - lens: A lens that focuses on a field of type T within state S
@@ -296,8 +349,10 @@ func LetL[S, T any](
 //	    readereither.LetToL(debugLens, false),
 //	)
 //	// result when executed will be Right(Config{Debug: false, Timeout: 30})
+//
+//go:inline
 func LetToL[S, T any](
-	lens L.Lens[S, T],
+	lens Lens[S, T],
 	b T,
 ) Kleisli[ReaderResult[S], S] {
 	return LetTo(lens.Set, b)

v2/context/readerresult/cancel.go

@@ -19,14 +19,23 @@ import (
 	"context"
 
 	E "github.com/IBM/fp-go/v2/either"
+	F "github.com/IBM/fp-go/v2/function"
 )
 
 // withContext wraps an existing ReaderResult and performs a context check for cancellation before deletating
 func WithContext[A any](ma ReaderResult[A]) ReaderResult[A] {
 	return func(ctx context.Context) E.Either[error, A] {
-		if err := context.Cause(ctx); err != nil {
-			return E.Left[A](err)
+		if ctx.Err() != nil {
+			return E.Left[A](context.Cause(ctx))
 		}
 		return ma(ctx)
 	}
 }
+
+//go:inline
+func WithContextK[A, B any](f Kleisli[A, B]) Kleisli[A, B] {
+	return F.Flow2(
+		f,
+		WithContext,
+	)
+}

v2/context/readerresult/filter.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"context"
+
+	RR "github.com/IBM/fp-go/v2/readerresult"
+)
+
+// FilterOrElse filters a ReaderResult value based on a predicate.
+// This is a convenience wrapper around readerresult.FilterOrElse that fixes
+// the context type to context.Context.
+//
+// If the predicate returns true for the Right value, it passes through unchanged.
+// If the predicate returns false, it transforms the Right value into a Left (error) using onFalse.
+// Left values are passed through unchanged.
+//
+// Parameters:
+//   - pred: A predicate function that tests the Right value
+//   - onFalse: A function that converts the failing value into an error
+//
+// Returns:
+//   - An Operator that filters ReaderResult values based on the predicate
+//
+// Example:
+//
+//	// Validate that a number is positive
+//	isPositive := N.MoreThan(0)
+//	onNegative := func(n int) error { return fmt.Errorf("%d is not positive", n) }
+//
+//	filter := readerresult.FilterOrElse(isPositive, onNegative)
+//	result := filter(readerresult.Right(42))(context.Background())
+//
+//go:inline
+func FilterOrElse[A any](pred Predicate[A], onFalse func(A) error) Operator[A, A] {
+	return RR.FilterOrElse[context.Context](pred, onFalse)
+}

v2/context/readerresult/flip.go

@@ -0,0 +1,154 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"context"
+
+	"github.com/IBM/fp-go/v2/reader"
+	RR "github.com/IBM/fp-go/v2/readerresult"
+)
+
+// SequenceReader swaps the order of environment parameters when the inner computation is a Reader.
+//
+// This function is specialized for the context.Context-based ReaderResult monad. It takes a
+// ReaderResult that produces a Reader and returns a reader.Kleisli that produces Results.
+// The context.Context is implicitly used as the outer environment type.
+//
+// Type Parameters:
+//   - R: The inner environment type (becomes outer after flip)
+//   - A: The success value type
+//
+// Parameters:
+//   - ma: A ReaderResult that takes context.Context and may produce a Reader[R, A]
+//
+// Returns:
+//   - A reader.Kleisli[context.Context, R, Result[A]], which is func(context.Context) func(R) Result[A]
+//
+// The function preserves error handling from the outer ReaderResult layer. If the outer
+// computation fails, the error is propagated to the inner Result.
+//
+// Note: This is an inline wrapper around readerresult.SequenceReader, specialized for
+// context.Context as the outer environment type.
+//
+// Example:
+//
+//	type Database struct {
+//	    ConnectionString string
+//	}
+//
+//	// Original: takes context, may fail, produces Reader[Database, string]
+//	original := func(ctx context.Context) result.Result[reader.Reader[Database, string]] {
+//	    if ctx.Err() != nil {
+//	        return result.Error[reader.Reader[Database, string]](ctx.Err())
+//	    }
+//	    return result.Ok[error](func(db Database) string {
+//	        return fmt.Sprintf("Query on %s", db.ConnectionString)
+//	    })
+//	}
+//
+//	// Sequenced: takes context first, then Database
+//	sequenced := SequenceReader(original)
+//
+//	ctx := context.Background()
+//	db := Database{ConnectionString: "localhost:5432"}
+//
+//	// Apply context first to get a function that takes database
+//	dbReader := sequenced(ctx)
+//	// Then apply database to get the final result
+//	result := dbReader(db)
+//	// result is Result[string]
+//
+// Use Cases:
+//   - Dependency injection: Flip parameter order to inject context first, then dependencies
+//   - Testing: Separate context handling from business logic for easier testing
+//   - Composition: Enable point-free style by fixing the context parameter first
+//
+//go:inline
+func SequenceReader[R, A any](ma ReaderResult[Reader[R, A]]) reader.Kleisli[context.Context, R, Result[A]] {
+	return RR.SequenceReader(ma)
+}
+
+// TraverseReader transforms a value using a Reader function and swaps environment parameter order.
+//
+// This function combines mapping and parameter flipping in a single operation. It takes a
+// Reader function (pure computation without error handling) and returns a function that:
+// 1. Maps a ReaderResult[A] to ReaderResult[B] using the provided Reader function
+// 2. Flips the parameter order so R comes before context.Context
+//
+// Type Parameters:
+//   - R: The inner environment type (becomes outer after flip)
+//   - A: The input value type
+//   - B: The output value type
+//
+// Parameters:
+//   - f: A reader.Kleisli[R, A, B], which is func(R) func(A) B - a pure Reader function
+//
+// Returns:
+//   - A function that takes ReaderResult[A] and returns Kleisli[R, B]
+//   - Kleisli[R, B] is func(R) ReaderResult[B], which is func(R) func(context.Context) Result[B]
+//
+// The function preserves error handling from the input ReaderResult. If the input computation
+// fails, the error is propagated without applying the transformation function.
+//
+// Note: This is a wrapper around readerresult.TraverseReader, specialized for context.Context.
+//
+// Example:
+//
+//	type Config struct {
+//	    MaxRetries int
+//	}
+//
+//	// A pure Reader function that depends on Config
+//	formatMessage := func(cfg Config) func(int) string {
+//	    return func(value int) string {
+//	        return fmt.Sprintf("Value: %d, MaxRetries: %d", value, cfg.MaxRetries)
+//	    }
+//	}
+//
+//	// Original computation that may fail
+//	computation := func(ctx context.Context) result.Result[int] {
+//	    if ctx.Err() != nil {
+//	        return result.Error[int](ctx.Err())
+//	    }
+//	    return result.Ok[error](42)
+//	}
+//
+//	// Create a traversal that applies formatMessage and flips parameters
+//	traverse := TraverseReader[Config, int, string](formatMessage)
+//
+//	// Apply to the computation
+//	flipped := traverse(computation)
+//
+//	// Now we can provide Config first, then context
+//	cfg := Config{MaxRetries: 3}
+//	ctx := context.Background()
+//
+//	result := flipped(cfg)(ctx)
+//	// result is Result[string] containing "Value: 42, MaxRetries: 3"
+//
+// Use Cases:
+//   - Dependency injection: Inject configuration/dependencies before context
+//   - Testing: Separate pure business logic from context handling
+//   - Composition: Build pipelines where dependencies are fixed before execution
+//   - Point-free style: Enable partial application by fixing dependencies first
+//
+//go:inline
+func TraverseReader[R, A, B any](
+	f reader.Kleisli[R, A, B],
+) func(ReaderResult[A]) Kleisli[R, B] {
+	return RR.TraverseReader[context.Context](f)
+}

v2/context/readerresult/logging.go

@@ -0,0 +1,215 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package readerresult provides logging utilities for the ReaderResult monad,
+// which combines the Reader monad (for dependency injection via context.Context)
+// with the Result monad (for error handling).
+//
+// The logging functions in this package allow you to log Result values (both
+// successes and errors) while preserving the functional composition style.
+package readerresult
+
+import (
+	"context"
+	"log/slog"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/logging"
+	"github.com/IBM/fp-go/v2/reader"
+	"github.com/IBM/fp-go/v2/result"
+)
+
+// curriedLog creates a curried logging function that takes an slog.Attr and a context,
+// then logs the attribute with the specified log level and message.
+//
+// This is an internal helper function used to create the logging pipeline in a
+// point-free style. The currying allows for partial application in functional
+// composition.
+//
+// Parameters:
+//   - logLevel: The slog.Level at which to log (e.g., LevelInfo, LevelError)
+//   - cb: A callback function that retrieves a logger from the context
+//   - message: The log message to display
+//
+// Returns:
+//   - A curried function that takes an slog.Attr, then a context, and performs logging
+func curriedLog(
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	message string) func(slog.Attr) Reader[context.Context, struct{}] {
+	return F.Curry2(func(a slog.Attr, ctx context.Context) struct{} {
+		cb(ctx).LogAttrs(ctx, logLevel, message, a)
+		return struct{}{}
+	})
+}
+
+// SLogWithCallback creates a Kleisli arrow that logs a Result value using a custom
+// logger callback and log level. The Result value is logged and then returned unchanged,
+// making this function suitable for use in functional pipelines.
+//
+// This function logs both successful values and errors:
+//   - Success values are logged with the key "value"
+//   - Error values are logged with the key "error"
+//
+// The logging is performed as a side effect while preserving the Result value,
+// allowing it to be used in the middle of a computation pipeline without
+// interrupting the flow.
+//
+// Type Parameters:
+//   - A: The type of the success value in the Result
+//
+// Parameters:
+//   - logLevel: The slog.Level at which to log (e.g., LevelInfo, LevelDebug, LevelError)
+//   - cb: A callback function that retrieves a *slog.Logger from the context
+//   - message: The log message to display
+//
+// Returns:
+//   - A Kleisli arrow that takes a Result[A] and returns a ReaderResult[A]
+//     The returned ReaderResult, when executed with a context, logs the Result
+//     and returns it unchanged
+//
+// Example:
+//
+//	type User struct {
+//	    ID   int
+//	    Name string
+//	}
+//
+//	// Custom logger callback
+//	getLogger := func(ctx context.Context) *slog.Logger {
+//	    return slog.Default()
+//	}
+//
+//	// Create a logging function for debug level
+//	logDebug := SLogWithCallback[User](slog.LevelDebug, getLogger, "User data")
+//
+//	// Use in a pipeline
+//	ctx := context.Background()
+//	user := result.Of(User{ID: 123, Name: "Alice"})
+//	logged := logDebug(user)(ctx) // Logs: level=DEBUG msg="User data" value={ID:123 Name:Alice}
+//	// logged still contains the User value
+//
+// Example with error:
+//
+//	err := errors.New("user not found")
+//	userResult := result.Left[User](err)
+//	logged := logDebug(userResult)(ctx) // Logs: level=DEBUG msg="User data" error="user not found"
+//	// logged still contains the error
+func SLogWithCallback[A any](
+	logLevel slog.Level,
+	cb func(context.Context) *slog.Logger,
+	message string) Kleisli[Result[A], A] {
+
+	return F.Pipe1(
+		F.Flow2(
+			result.ToSLogAttr[A](),
+			curriedLog(logLevel, cb, message),
+		),
+		reader.Chain(reader.Sequence(F.Flow2( // this flow is basically the `MapTo` function with side effects
+			reader.Of[struct{}, Result[A]],
+			reader.Map[context.Context, struct{}, Result[A]],
+		))),
+	)
+
+}
+
+// SLog creates a Kleisli arrow that logs a Result value at INFO level using the
+// logger from the context. This is a convenience function that uses SLogWithCallback
+// with default settings.
+//
+// The Result value is logged and then returned unchanged, making this function
+// suitable for use in functional pipelines for debugging or monitoring purposes.
+//
+// This function logs both successful values and errors:
+//   - Success values are logged with the key "value"
+//   - Error values are logged with the key "error"
+//
+// Type Parameters:
+//   - A: The type of the success value in the Result
+//
+// Parameters:
+//   - message: The log message to display
+//
+// Returns:
+//   - A Kleisli arrow that takes a Result[A] and returns a ReaderResult[A]
+//     The returned ReaderResult, when executed with a context, logs the Result
+//     at INFO level and returns it unchanged
+//
+// Example - Logging a successful computation:
+//
+//	ctx := context.Background()
+//
+//	// Simple value logging
+//	res := result.Of(42)
+//	logged := SLog[int]("Processing number")(res)(ctx)
+//	// Logs: level=INFO msg="Processing number" value=42
+//	// logged == result.Of(42)
+//
+// Example - Logging in a pipeline:
+//
+//	type User struct {
+//	    ID   int
+//	    Name string
+//	}
+//
+//	fetchUser := func(id int) result.Result[User] {
+//	    return result.Of(User{ID: id, Name: "Alice"})
+//	}
+//
+//	processUser := func(user User) result.Result[string] {
+//	    return result.Of(fmt.Sprintf("Processed: %s", user.Name))
+//	}
+//
+//	ctx := context.Background()
+//
+//	// Log at each step
+//	userResult := fetchUser(123)
+//	logged1 := SLog[User]("Fetched user")(userResult)(ctx)
+//	// Logs: level=INFO msg="Fetched user" value={ID:123 Name:Alice}
+//
+//	processed := result.Chain(processUser)(logged1)
+//	logged2 := SLog[string]("Processed user")(processed)(ctx)
+//	// Logs: level=INFO msg="Processed user" value="Processed: Alice"
+//
+// Example - Logging errors:
+//
+//	err := errors.New("database connection failed")
+//	errResult := result.Left[User](err)
+//	logged := SLog[User]("Database operation")(errResult)(ctx)
+//	// Logs: level=INFO msg="Database operation" error="database connection failed"
+//	// logged still contains the error
+//
+// Example - Using with context logger:
+//
+//	// Set up a custom logger in the context
+//	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+//	ctx := logging.WithLogger(logger)(context.Background())
+//
+//	res := result.Of("important data")
+//	logged := SLog[string]("Critical operation")(res)(ctx)
+//	// Uses the logger from context to log the message
+//
+// Note: The function uses logging.GetLoggerFromContext to retrieve the logger,
+// which falls back to the global logger if no logger is found in the context.
+//
+//go:inline
+func SLog[A any](message string) Kleisli[Result[A], A] {
+	return SLogWithCallback[A](slog.LevelInfo, logging.GetLoggerFromContext, message)
+}
+
+//go:inline
+func TapSLog[A any](message string) Operator[A, A] {
+	return reader.Chain(SLog[A](message))
+}

v2/context/readerresult/logging_test.go

@@ -0,0 +1,302 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"log/slog"
+	"testing"
+
+	"github.com/IBM/fp-go/v2/logging"
+	N "github.com/IBM/fp-go/v2/number"
+	"github.com/IBM/fp-go/v2/result"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestSLogLogsSuccessValue tests that SLog logs successful Result values
+func TestSLogLogsSuccessValue(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	// Create a Result and log it
+	res1 := result.Of(42)
+	logged := SLog[int]("Result value")(res1)(ctx)
+
+	assert.Equal(t, result.Of(42), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Result value")
+	assert.Contains(t, logOutput, "value=42")
+}
+
+// TestSLogLogsErrorValue tests that SLog logs error Result values
+func TestSLogLogsErrorValue(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+	testErr := errors.New("test error")
+
+	// Create an error Result and log it
+	res1 := result.Left[int](testErr)
+	logged := SLog[int]("Result value")(res1)(ctx)
+
+	assert.Equal(t, res1, logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Result value")
+	assert.Contains(t, logOutput, "error")
+	assert.Contains(t, logOutput, "test error")
+}
+
+// TestSLogInPipeline tests SLog in a functional pipeline
+func TestSLogInPipeline(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	// SLog takes a Result[A] and returns ReaderResult[A]
+	// So we need to start with a Result, apply SLog, then execute with context
+	res1 := result.Of(10)
+	logged := SLog[int]("Initial value")(res1)(ctx)
+
+	assert.Equal(t, result.Of(10), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Initial value")
+	assert.Contains(t, logOutput, "value=10")
+}
+
+// TestSLogWithContextLogger tests SLog using logger from context
+func TestSLogWithContextLogger(t *testing.T) {
+	var buf bytes.Buffer
+	contextLogger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+
+	ctx := logging.WithLogger(contextLogger)(context.Background())
+
+	res1 := result.Of("test value")
+	logged := SLog[string]("Context logger test")(res1)(ctx)
+
+	assert.Equal(t, result.Of("test value"), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Context logger test")
+	assert.Contains(t, logOutput, `value="test value"`)
+}
+
+// TestSLogDisabled tests that SLog respects logger level
+func TestSLogDisabled(t *testing.T) {
+	var buf bytes.Buffer
+	// Create logger with level that disables info logs
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelError, // Only log errors
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	res1 := result.Of(42)
+	logged := SLog[int]("This should not be logged")(res1)(ctx)
+
+	assert.Equal(t, result.Of(42), logged)
+
+	// Should have no logs since level is ERROR
+	logOutput := buf.String()
+	assert.Empty(t, logOutput, "Should have no logs when logging is disabled")
+}
+
+// TestSLogWithStruct tests SLog with structured data
+func TestSLogWithStruct(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	type User struct {
+		ID   int
+		Name string
+	}
+
+	ctx := context.Background()
+	user := User{ID: 123, Name: "Alice"}
+
+	res1 := result.Of(user)
+	logged := SLog[User]("User data")(res1)(ctx)
+
+	assert.Equal(t, result.Of(user), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "User data")
+	assert.Contains(t, logOutput, "ID:123")
+	assert.Contains(t, logOutput, "Name:Alice")
+}
+
+// TestSLogWithCallbackCustomLevel tests SLogWithCallback with custom log level
+func TestSLogWithCallbackCustomLevel(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+	}))
+
+	customCallback := func(ctx context.Context) *slog.Logger {
+		return logger
+	}
+
+	ctx := context.Background()
+
+	// Create a Result and log it with custom callback
+	res1 := result.Of(42)
+	logged := SLogWithCallback[int](slog.LevelDebug, customCallback, "Debug result")(res1)(ctx)
+
+	assert.Equal(t, result.Of(42), logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Debug result")
+	assert.Contains(t, logOutput, "value=42")
+	assert.Contains(t, logOutput, "level=DEBUG")
+}
+
+// TestSLogWithCallbackLogsError tests SLogWithCallback logs errors
+func TestSLogWithCallbackLogsError(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelWarn,
+	}))
+
+	customCallback := func(ctx context.Context) *slog.Logger {
+		return logger
+	}
+
+	ctx := context.Background()
+	testErr := errors.New("warning error")
+
+	// Create an error Result and log it with custom callback
+	res1 := result.Left[int](testErr)
+	logged := SLogWithCallback[int](slog.LevelWarn, customCallback, "Warning result")(res1)(ctx)
+
+	assert.Equal(t, res1, logged)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Warning result")
+	assert.Contains(t, logOutput, "error")
+	assert.Contains(t, logOutput, "warning error")
+	assert.Contains(t, logOutput, "level=WARN")
+}
+
+// TestSLogChainedOperations tests SLog in chained operations
+func TestSLogChainedOperations(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	// First log step 1
+	res1 := result.Of(5)
+	logged1 := SLog[int]("Step 1")(res1)(ctx)
+
+	// Then log step 2 with doubled value
+	res2 := result.Map(N.Mul(2))(logged1)
+	logged2 := SLog[int]("Step 2")(res2)(ctx)
+
+	assert.Equal(t, result.Of(10), logged2)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Step 1")
+	assert.Contains(t, logOutput, "value=5")
+	assert.Contains(t, logOutput, "Step 2")
+	assert.Contains(t, logOutput, "value=10")
+}
+
+// TestSLogPreservesError tests that SLog preserves error through the pipeline
+func TestSLogPreservesError(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+	testErr := errors.New("original error")
+
+	res1 := result.Left[int](testErr)
+	logged := SLog[int]("Logging error")(res1)(ctx)
+
+	// Apply map to verify error is preserved
+	res2 := result.Map(N.Mul(2))(logged)
+
+	assert.Equal(t, res1, res2)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Logging error")
+	assert.Contains(t, logOutput, "original error")
+}
+
+// TestSLogMultipleValues tests logging multiple different values
+func TestSLogMultipleValues(t *testing.T) {
+	var buf bytes.Buffer
+	logger := slog.New(slog.NewTextHandler(&buf, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	oldLogger := logging.SetLogger(logger)
+	defer logging.SetLogger(oldLogger)
+
+	ctx := context.Background()
+
+	// Test with different types
+	intRes := SLog[int]("Integer")(result.Of(42))(ctx)
+	assert.Equal(t, result.Of(42), intRes)
+
+	strRes := SLog[string]("String")(result.Of("hello"))(ctx)
+	assert.Equal(t, result.Of("hello"), strRes)
+
+	boolRes := SLog[bool]("Boolean")(result.Of(true))(ctx)
+	assert.Equal(t, result.Of(true), boolRes)
+
+	logOutput := buf.String()
+	assert.Contains(t, logOutput, "Integer")
+	assert.Contains(t, logOutput, "value=42")
+	assert.Contains(t, logOutput, "String")
+	assert.Contains(t, logOutput, "value=hello")
+	assert.Contains(t, logOutput, "Boolean")
+	assert.Contains(t, logOutput, "value=true")
+}

v2/context/readerresult/reader.go

@@ -18,9 +18,17 @@ package readerresult
 import (
 	"context"
 
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/chain"
+	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/reader"
 	"github.com/IBM/fp-go/v2/readereither"
 )
 
+func FromReader[A any](r Reader[context.Context, A]) ReaderResult[A] {
+	return readereither.FromReader[error](r)
+}
+
 func FromEither[A any](e Either[A]) ReaderResult[A] {
 	return readereither.FromEither[context.Context](e)
 }
@@ -42,11 +50,11 @@ func Map[A, B any](f func(A) B) Operator[A, B] {
 }
 
 func MonadChain[A, B any](ma ReaderResult[A], f Kleisli[A, B]) ReaderResult[B] {
-	return readereither.MonadChain(ma, f)
+	return readereither.MonadChain(ma, F.Flow2(f, WithContext))
 }
 
 func Chain[A, B any](f Kleisli[A, B]) Operator[A, B] {
-	return readereither.Chain(f)
+	return readereither.Chain(F.Flow2(f, WithContext))
 }
 
 func Of[A any](a A) ReaderResult[A] {
@@ -65,8 +73,50 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) Kleisli[A, A
 	return readereither.FromPredicate[context.Context](pred, onFalse)
 }
 
+// OrElse recovers from a Left (error) by providing an alternative computation with access to context.Context.
+// If the ReaderResult is Right, it returns the value unchanged.
+// If the ReaderResult is Left, it applies the provided function to the error value,
+// which returns a new ReaderResult that replaces the original.
+//
+// This is useful for error recovery, fallback logic, or chaining alternative computations
+// that need access to the context (for cancellation, deadlines, or values).
+//
+// Example:
+//
+//	// Recover with context-aware fallback
+//	recover := readerresult.OrElse(func(err error) readerresult.ReaderResult[int] {
+//	    if err.Error() == "not found" {
+//	        return func(ctx context.Context) result.Result[int] {
+//	            // Could check ctx.Err() here
+//	            return result.Of(42)
+//	        }
+//	    }
+//	    return readerresult.Left[int](err)
+//	})
+//
+// OrElse recovers from a Left (error) by providing an alternative computation.
+// If the ReaderResult is Right, it returns the value unchanged.
+// If the ReaderResult is Left, it applies the provided function to the error value,
+// which returns a new ReaderResult that replaces the original.
+//
+// This is useful for error recovery, fallback logic, or chaining alternative computations
+// in the context of Reader computations with context.Context.
+//
+// Example:
+//
+//	// Recover from specific errors with fallback values
+//	recover := readerresult.OrElse(func(err error) readerresult.ReaderResult[int] {
+//	    if err.Error() == "not found" {
+//	        return readerresult.Of[int](0) // default value
+//	    }
+//	    return readerresult.Left[int](err) // propagate other errors
+//	})
+//	result := recover(readerresult.Left[int](errors.New("not found")))(ctx) // Right(0)
+//	result := recover(readerresult.Of(42))(ctx) // Right(42) - unchanged
+//
+//go:inline
 func OrElse[A any](onLeft Kleisli[error, A]) Kleisli[ReaderResult[A], A] {
-	return readereither.OrElse(onLeft)
+	return readereither.OrElse(F.Flow2(onLeft, WithContext))
 }
 
 func Ask() ReaderResult[context.Context] {
@@ -81,7 +131,7 @@ func ChainEitherK[A, B any](f func(A) Either[B]) func(ma ReaderResult[A]) Reader
 	return readereither.ChainEitherK[context.Context](f)
 }
 
-func ChainOptionK[A, B any](onNone func() error) func(func(A) Option[B]) Operator[A, B] {
+func ChainOptionK[A, B any](onNone func() error) func(option.Kleisli[A, B]) Operator[A, B] {
 	return readereither.ChainOptionK[context.Context, A, B](onNone)
 }
 
@@ -97,3 +147,197 @@ func Flap[B, A any](a A) Operator[func(A) B, B] {
 func Read[A any](r context.Context) func(ReaderResult[A]) Result[A] {
 	return readereither.Read[error, A](r)
 }
+
+// MonadMapTo executes a ReaderResult computation, discards its success value, and returns a constant value.
+// This is the monadic version that takes both the ReaderResult and the constant value as parameters.
+//
+// IMPORTANT: ReaderResult represents a side-effectful computation because it depends on context.Context,
+// which is effectful (can be cancelled, has deadlines, carries values). For this reason, MonadMapTo WILL
+// execute the original ReaderResult to allow any side effects to occur, then discard the success result
+// and return the constant value. If the original computation fails, the error is preserved.
+//
+// Type Parameters:
+//   - A: The success type of the first ReaderResult (will be discarded if successful)
+//   - B: The type of the constant value to return on success
+//
+// Parameters:
+//   - ma: The ReaderResult to execute (side effects will occur, success value discarded)
+//   - b: The constant value to return if ma succeeds
+//
+// Returns:
+//   - A ReaderResult that executes ma, preserves errors, but replaces success values with b
+//
+// Example:
+//
+//	type Config struct { Counter int }
+//	increment := func(ctx context.Context) result.Result[int] {
+//	    // Side effect: log the operation
+//	    fmt.Println("incrementing")
+//	    return result.Of(5)
+//	}
+//	r := readerresult.MonadMapTo(increment, "done")
+//	result := r(context.Background()) // Prints "incrementing", returns Right("done")
+//
+//go:inline
+func MonadMapTo[A, B any](ma ReaderResult[A], b B) ReaderResult[B] {
+	return MonadMap(ma, reader.Of[A](b))
+}
+
+// MapTo creates an operator that executes a ReaderResult computation, discards its success value,
+// and returns a constant value. This is the curried version where the constant value is provided first,
+// returning a function that can be applied to any ReaderResult.
+//
+// IMPORTANT: ReaderResult represents a side-effectful computation because it depends on context.Context,
+// which is effectful (can be cancelled, has deadlines, carries values). For this reason, MapTo WILL
+// execute the input ReaderResult to allow any side effects to occur, then discard the success result
+// and return the constant value. If the computation fails, the error is preserved.
+//
+// Type Parameters:
+//   - A: The success type of the input ReaderResult (will be discarded if successful)
+//   - B: The type of the constant value to return on success
+//
+// Parameters:
+//   - b: The constant value to return on success
+//
+// Returns:
+//   - An Operator that executes a ReaderResult[A], preserves errors, but replaces success with b
+//
+// Example:
+//
+//	logStep := func(ctx context.Context) result.Result[int] {
+//	    fmt.Println("step executed")
+//	    return result.Of(42)
+//	}
+//	toDone := readerresult.MapTo[int, string]("done")
+//	pipeline := toDone(logStep)
+//	result := pipeline(context.Background()) // Prints "step executed", returns Right("done")
+//
+// Example - In a functional pipeline:
+//
+//	step1 := func(ctx context.Context) result.Result[int] {
+//	    fmt.Println("processing")
+//	    return result.Of(1)
+//	}
+//	pipeline := F.Pipe1(
+//	    step1,
+//	    readerresult.MapTo[int, string]("complete"),
+//	)
+//	output := pipeline(context.Background()) // Prints "processing", returns Right("complete")
+//
+//go:inline
+func MapTo[A, B any](b B) Operator[A, B] {
+	return Map(reader.Of[A](b))
+}
+
+// MonadChainTo sequences two ReaderResult computations where the second ignores the first's success value.
+// This is the monadic version that takes both ReaderResults as parameters.
+//
+// IMPORTANT: ReaderResult represents a side-effectful computation because it depends on context.Context,
+// which is effectful (can be cancelled, has deadlines, carries values). For this reason, MonadChainTo WILL
+// execute the first ReaderResult to allow any side effects to occur, then discard the success result and
+// execute the second ReaderResult with the same context. If the first computation fails, the error is
+// returned immediately without executing the second computation.
+//
+// Type Parameters:
+//   - A: The success type of the first ReaderResult (will be discarded if successful)
+//   - B: The success type of the second ReaderResult
+//
+// Parameters:
+//   - ma: The first ReaderResult to execute (side effects will occur, success value discarded)
+//   - b: The second ReaderResult to execute if ma succeeds
+//
+// Returns:
+//   - A ReaderResult that executes ma, then b if ma succeeds, returning b's result
+//
+// Example:
+//
+//	logStart := func(ctx context.Context) result.Result[int] {
+//	    fmt.Println("starting")
+//	    return result.Of(1)
+//	}
+//	logEnd := func(ctx context.Context) result.Result[string] {
+//	    fmt.Println("ending")
+//	    return result.Of("done")
+//	}
+//	r := readerresult.MonadChainTo(logStart, logEnd)
+//	result := r(context.Background()) // Prints "starting" then "ending", returns Right("done")
+//
+//go:inline
+func MonadChainTo[A, B any](ma ReaderResult[A], b ReaderResult[B]) ReaderResult[B] {
+	return MonadChain(ma, reader.Of[A](b))
+}
+
+// ChainTo creates an operator that sequences two ReaderResult computations where the second ignores
+// the first's success value. This is the curried version where the second ReaderResult is provided first,
+// returning a function that can be applied to any first ReaderResult.
+//
+// IMPORTANT: ReaderResult represents a side-effectful computation because it depends on context.Context,
+// which is effectful (can be cancelled, has deadlines, carries values). For this reason, ChainTo WILL
+// execute the first ReaderResult to allow any side effects to occur, then discard the success result and
+// execute the second ReaderResult with the same context. If the first computation fails, the error is
+// returned immediately without executing the second computation.
+//
+// Type Parameters:
+//   - A: The success type of the first ReaderResult (will be discarded if successful)
+//   - B: The success type of the second ReaderResult
+//
+// Parameters:
+//   - b: The second ReaderResult to execute after the first succeeds
+//
+// Returns:
+//   - An Operator that executes the first ReaderResult, then b if successful
+//
+// Example:
+//
+//	logEnd := func(ctx context.Context) result.Result[string] {
+//	    fmt.Println("ending")
+//	    return result.Of("done")
+//	}
+//	thenLogEnd := readerresult.ChainTo[int, string](logEnd)
+//
+//	logStart := func(ctx context.Context) result.Result[int] {
+//	    fmt.Println("starting")
+//	    return result.Of(1)
+//	}
+//	pipeline := thenLogEnd(logStart)
+//	result := pipeline(context.Background()) // Prints "starting" then "ending", returns Right("done")
+//
+// Example - In a functional pipeline:
+//
+//	step1 := func(ctx context.Context) result.Result[int] {
+//	    fmt.Println("step 1")
+//	    return result.Of(1)
+//	}
+//	step2 := func(ctx context.Context) result.Result[string] {
+//	    fmt.Println("step 2")
+//	    return result.Of("complete")
+//	}
+//	pipeline := F.Pipe1(
+//	    step1,
+//	    readerresult.ChainTo[int, string](step2),
+//	)
+//	output := pipeline(context.Background()) // Prints "step 1" then "step 2", returns Right("complete")
+//
+//go:inline
+func ChainTo[A, B any](b ReaderResult[B]) Operator[A, B] {
+	return Chain(reader.Of[A](b))
+}
+
+//go:inline
+func MonadChainFirst[A, B any](ma ReaderResult[A], f Kleisli[A, B]) ReaderResult[A] {
+	return chain.MonadChainFirst(
+		MonadChain,
+		MonadMap,
+		ma,
+		F.Flow2(f, WithContext),
+	)
+}
+
+//go:inline
+func ChainFirst[A, B any](f Kleisli[A, B]) Operator[A, A] {
+	return chain.ChainFirst(
+		Chain,
+		Map,
+		F.Flow2(f, WithContext),
+	)
+}

v2/context/readerresult/reader_test.go

@@ -0,0 +1,382 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	E "github.com/IBM/fp-go/v2/either"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMapTo(t *testing.T) {
+	t.Run("executes original reader and returns constant value on success", func(t *testing.T) {
+		executed := false
+		originalReader := func(ctx context.Context) E.Either[error, int] {
+			executed = true
+			return E.Of[error](42)
+		}
+
+		// Apply MapTo operator
+		toDone := MapTo[int]("done")
+		resultReader := toDone(originalReader)
+
+		// Execute the resulting reader
+		result := resultReader(context.Background())
+
+		// Verify the constant value is returned
+		assert.Equal(t, E.Of[error]("done"), result)
+		// Verify the original reader WAS executed (side effect occurred)
+		assert.True(t, executed, "original reader should be executed to allow side effects")
+	})
+
+	t.Run("executes reader in functional pipeline", func(t *testing.T) {
+		executed := false
+		step1 := func(ctx context.Context) E.Either[error, int] {
+			executed = true
+			return E.Of[error](100)
+		}
+
+		pipeline := F.Pipe1(
+			step1,
+			MapTo[int]("complete"),
+		)
+
+		result := pipeline(context.Background())
+
+		assert.Equal(t, E.Of[error]("complete"), result)
+		assert.True(t, executed, "original reader should be executed in pipeline")
+	})
+
+	t.Run("executes reader with side effects", func(t *testing.T) {
+		sideEffectOccurred := false
+		readerWithSideEffect := func(ctx context.Context) E.Either[error, int] {
+			sideEffectOccurred = true
+			return E.Of[error](42)
+		}
+
+		resultReader := MapTo[int](true)(readerWithSideEffect)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Of[error](true), result)
+		assert.True(t, sideEffectOccurred, "side effect should occur")
+	})
+
+	t.Run("preserves errors from original reader", func(t *testing.T) {
+		executed := false
+		testErr := assert.AnError
+		failingReader := func(ctx context.Context) E.Either[error, int] {
+			executed = true
+			return E.Left[int](testErr)
+		}
+
+		resultReader := MapTo[int]("done")(failingReader)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Left[string](testErr), result)
+		assert.True(t, executed, "failing reader should still be executed")
+	})
+}
+
+func TestMonadMapTo(t *testing.T) {
+	t.Run("executes original reader and returns constant value on success", func(t *testing.T) {
+		executed := false
+		originalReader := func(ctx context.Context) E.Either[error, int] {
+			executed = true
+			return E.Of[error](42)
+		}
+
+		// Apply MonadMapTo
+		resultReader := MonadMapTo(originalReader, "done")
+
+		// Execute the resulting reader
+		result := resultReader(context.Background())
+
+		// Verify the constant value is returned
+		assert.Equal(t, E.Of[error]("done"), result)
+		// Verify the original reader WAS executed (side effect occurred)
+		assert.True(t, executed, "original reader should be executed to allow side effects")
+	})
+
+	t.Run("executes complex computation with side effects", func(t *testing.T) {
+		computationExecuted := false
+		complexReader := func(ctx context.Context) E.Either[error, string] {
+			computationExecuted = true
+			return E.Of[error]("complex result")
+		}
+
+		resultReader := MonadMapTo(complexReader, 42)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Of[error](42), result)
+		assert.True(t, computationExecuted, "complex computation should be executed")
+	})
+
+	t.Run("preserves errors from original reader", func(t *testing.T) {
+		executed := false
+		testErr := assert.AnError
+		failingReader := func(ctx context.Context) E.Either[error, []string] {
+			executed = true
+			return E.Left[[]string](testErr)
+		}
+
+		resultReader := MonadMapTo(failingReader, 99)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Left[int](testErr), result)
+		assert.True(t, executed, "failing reader should still be executed")
+	})
+}
+
+func TestChainTo(t *testing.T) {
+	t.Run("executes first reader then second reader on success", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+
+		firstReader := func(ctx context.Context) E.Either[error, int] {
+			firstExecuted = true
+			return E.Of[error](42)
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, string] {
+			secondExecuted = true
+			return E.Of[error]("result")
+		}
+
+		// Apply ChainTo operator
+		thenSecond := ChainTo[int](secondReader)
+		resultReader := thenSecond(firstReader)
+
+		// Execute the resulting reader
+		result := resultReader(context.Background())
+
+		// Verify the second reader's result is returned
+		assert.Equal(t, E.Of[error]("result"), result)
+		// Verify both readers were executed
+		assert.True(t, firstExecuted, "first reader should be executed")
+		assert.True(t, secondExecuted, "second reader should be executed")
+	})
+
+	t.Run("executes both readers in functional pipeline", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+
+		step1 := func(ctx context.Context) E.Either[error, int] {
+			firstExecuted = true
+			return E.Of[error](100)
+		}
+
+		step2 := func(ctx context.Context) E.Either[error, string] {
+			secondExecuted = true
+			return E.Of[error]("complete")
+		}
+
+		pipeline := F.Pipe1(
+			step1,
+			ChainTo[int](step2),
+		)
+
+		result := pipeline(context.Background())
+
+		assert.Equal(t, E.Of[error]("complete"), result)
+		assert.True(t, firstExecuted, "first reader should be executed in pipeline")
+		assert.True(t, secondExecuted, "second reader should be executed in pipeline")
+	})
+
+	t.Run("executes first reader with side effects", func(t *testing.T) {
+		sideEffectOccurred := false
+		readerWithSideEffect := func(ctx context.Context) E.Either[error, int] {
+			sideEffectOccurred = true
+			return E.Of[error](42)
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, bool] {
+			return E.Of[error](true)
+		}
+
+		resultReader := ChainTo[int](secondReader)(readerWithSideEffect)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Of[error](true), result)
+		assert.True(t, sideEffectOccurred, "side effect should occur in first reader")
+	})
+
+	t.Run("preserves error from first reader without executing second", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+		testErr := assert.AnError
+
+		failingReader := func(ctx context.Context) E.Either[error, int] {
+			firstExecuted = true
+			return E.Left[int](testErr)
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, string] {
+			secondExecuted = true
+			return E.Of[error]("result")
+		}
+
+		resultReader := ChainTo[int](secondReader)(failingReader)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Left[string](testErr), result)
+		assert.True(t, firstExecuted, "first reader should be executed")
+		assert.False(t, secondExecuted, "second reader should not be executed on error")
+	})
+}
+
+func TestMonadChainTo(t *testing.T) {
+	t.Run("executes first reader then second reader on success", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+
+		firstReader := func(ctx context.Context) E.Either[error, int] {
+			firstExecuted = true
+			return E.Of[error](42)
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, string] {
+			secondExecuted = true
+			return E.Of[error]("result")
+		}
+
+		// Apply MonadChainTo
+		resultReader := MonadChainTo(firstReader, secondReader)
+
+		// Execute the resulting reader
+		result := resultReader(context.Background())
+
+		// Verify the second reader's result is returned
+		assert.Equal(t, E.Of[error]("result"), result)
+		// Verify both readers were executed
+		assert.True(t, firstExecuted, "first reader should be executed")
+		assert.True(t, secondExecuted, "second reader should be executed")
+	})
+
+	t.Run("executes complex first computation with side effects", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+
+		complexFirstReader := func(ctx context.Context) E.Either[error, []int] {
+			firstExecuted = true
+			return E.Of[error]([]int{1, 2, 3})
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, string] {
+			secondExecuted = true
+			return E.Of[error]("done")
+		}
+
+		resultReader := MonadChainTo(complexFirstReader, secondReader)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Of[error]("done"), result)
+		assert.True(t, firstExecuted, "complex first computation should be executed")
+		assert.True(t, secondExecuted, "second reader should be executed")
+	})
+
+	t.Run("preserves error from first reader without executing second", func(t *testing.T) {
+		firstExecuted := false
+		secondExecuted := false
+		testErr := assert.AnError
+
+		failingReader := func(ctx context.Context) E.Either[error, map[string]int] {
+			firstExecuted = true
+			return E.Left[map[string]int](testErr)
+		}
+
+		secondReader := func(ctx context.Context) E.Either[error, float64] {
+			secondExecuted = true
+			return E.Of[error](3.14)
+		}
+
+		resultReader := MonadChainTo(failingReader, secondReader)
+		result := resultReader(context.Background())
+
+		assert.Equal(t, E.Left[float64](testErr), result)
+		assert.True(t, firstExecuted, "first reader should be executed")
+		assert.False(t, secondExecuted, "second reader should not be executed on error")
+	})
+}
+
+func TestOrElse(t *testing.T) {
+	ctx := context.Background()
+
+	// Test OrElse with Right - should pass through unchanged
+	t.Run("Right value unchanged", func(t *testing.T) {
+		rightValue := Of(42)
+		recover := OrElse(func(err error) ReaderResult[int] {
+			return Left[int](errors.New("should not be called"))
+		})
+		res := recover(rightValue)(ctx)
+		assert.Equal(t, E.Of[error](42), res)
+	})
+
+	// Test OrElse with Left - should recover with fallback
+	t.Run("Left value recovered", func(t *testing.T) {
+		leftValue := Left[int](errors.New("not found"))
+		recoverWithFallback := OrElse(func(err error) ReaderResult[int] {
+			if err.Error() == "not found" {
+				return func(ctx context.Context) E.Either[error, int] {
+					return E.Of[error](99)
+				}
+			}
+			return Left[int](err)
+		})
+		res := recoverWithFallback(leftValue)(ctx)
+		assert.Equal(t, E.Of[error](99), res)
+	})
+
+	// Test OrElse with Left - should propagate other errors
+	t.Run("Left value propagated", func(t *testing.T) {
+		leftValue := Left[int](errors.New("fatal error"))
+		recoverWithFallback := OrElse(func(err error) ReaderResult[int] {
+			if err.Error() == "not found" {
+				return Of(99)
+			}
+			return Left[int](err)
+		})
+		res := recoverWithFallback(leftValue)(ctx)
+		assert.True(t, E.IsLeft(res))
+		val, err := E.UnwrapError(res)
+		assert.Equal(t, 0, val)
+		assert.Equal(t, "fatal error", err.Error())
+	})
+
+	// Test OrElse with context-aware recovery
+	t.Run("Context-aware recovery", func(t *testing.T) {
+		type ctxKey string
+		ctxWithValue := context.WithValue(ctx, ctxKey("fallback"), 123)
+
+		leftValue := Left[int](errors.New("use fallback"))
+		ctxRecover := OrElse(func(err error) ReaderResult[int] {
+			if err.Error() == "use fallback" {
+				return func(ctx context.Context) E.Either[error, int] {
+					if val := ctx.Value(ctxKey("fallback")); val != nil {
+						return E.Of[error](val.(int))
+					}
+					return E.Left[int](errors.New("no fallback"))
+				}
+			}
+			return Left[int](err)
+		})
+		res := ctxRecover(leftValue)(ctxWithValue)
+		assert.Equal(t, E.Of[error](123), res)
+	})
+}

v2/context/readerresult/rec.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package readerresult implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
+package readerresult
+
+import (
+	"context"
+
+	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/result"
+)
+
+// TailRec implements tail-recursive computation for ReaderResult with context cancellation support.
+//
+// TailRec takes a Kleisli function that returns Trampoline[A, B] and converts it into a stack-safe,
+// tail-recursive computation. The function repeatedly applies the Kleisli until it produces a Land value.
+//
+// The implementation includes a short-circuit mechanism that checks for context cancellation on each
+// iteration. If the context is canceled (ctx.Err() != nil), the computation immediately returns a
+// Left result containing the context's cause error, preventing unnecessary computation.
+//
+// Type Parameters:
+//   - A: The input type for the recursive step
+//   - B: The final result type
+//
+// Parameters:
+//   - f: A Kleisli function that takes an A and returns a ReaderResult containing Trampoline[A, B].
+//     When the result is Bounce(a), recursion continues with the new value 'a'.
+//     When the result is Land(b), recursion terminates with the final value 'b'.
+//
+// Returns:
+//   - A Kleisli function that performs the tail-recursive computation in a stack-safe manner.
+//
+// Behavior:
+//   - On each iteration, checks if the context has been canceled (short circuit)
+//   - If canceled, returns result.Left[B](context.Cause(ctx))
+//   - If the step returns Left[B](error), propagates the error
+//   - If the step returns Right[A](Bounce(a)), continues recursion with new value 'a'
+//   - If the step returns Right[A](Land(b)), terminates with success value 'b'
+//
+// Example - Factorial computation with context:
+//
+//	type State struct {
+//	    n   int
+//	    acc int
+//	}
+//
+//	factorialStep := func(state State) ReaderResult[tailrec.Trampoline[State, int]] {
+//	    return func(ctx context.Context) result.Result[tailrec.Trampoline[State, int]] {
+//	        if state.n <= 0 {
+//	            return result.Of(tailrec.Land[State](state.acc))
+//	        }
+//	        return result.Of(tailrec.Bounce[int](State{state.n - 1, state.acc * state.n}))
+//	    }
+//	}
+//
+//	factorial := TailRec(factorialStep)
+//	result := factorial(State{5, 1})(ctx) // Returns result.Of(120)
+//
+// Example - Context cancellation:
+//
+//	ctx, cancel := context.WithCancel(context.Background())
+//	cancel() // Cancel immediately
+//
+//	computation := TailRec(someStep)
+//	result := computation(initialValue)(ctx)
+//	// Returns result.Left[B](context.Cause(ctx)) without executing any steps
+//
+//go:inline
+func TailRec[A, B any](f Kleisli[A, Trampoline[A, B]]) Kleisli[A, B] {
+	return func(a A) ReaderResult[B] {
+		initialReader := f(a)
+		return func(ctx context.Context) result.Result[B] {
+			rdr := initialReader
+			for {
+				// short circuit
+				if ctx.Err() != nil {
+					return result.Left[B](context.Cause(ctx))
+				}
+				current := rdr(ctx)
+				rec, e := either.Unwrap(current)
+				if either.IsLeft(current) {
+					return result.Left[B](e)
+				}
+				if rec.Landed {
+					return result.Of(rec.Land)
+				}
+				rdr = f(rec.Bounce)
+			}
+		}
+	}
+}

v2/context/readerresult/rec_test.go

@@ -0,0 +1,498 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+	"time"
+
+	A "github.com/IBM/fp-go/v2/array"
+	R "github.com/IBM/fp-go/v2/result"
+	TR "github.com/IBM/fp-go/v2/tailrec"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestTailRecFactorial tests factorial computation with context
+func TestTailRecFactorial(t *testing.T) {
+	type State struct {
+		n   int
+		acc int
+	}
+
+	factorialStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.n <= 0 {
+				return R.Of(TR.Land[State](state.acc))
+			}
+			return R.Of(TR.Bounce[int](State{state.n - 1, state.acc * state.n}))
+		}
+	}
+
+	factorial := TailRec(factorialStep)
+	result := factorial(State{5, 1})(context.Background())
+
+	assert.Equal(t, R.Of(120), result)
+}
+
+// TestTailRecFibonacci tests Fibonacci computation
+func TestTailRecFibonacci(t *testing.T) {
+	type State struct {
+		n    int
+		prev int
+		curr int
+	}
+
+	fibStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.n <= 0 {
+				return R.Of(TR.Land[State](state.curr))
+			}
+			return R.Of(TR.Bounce[int](State{state.n - 1, state.curr, state.prev + state.curr}))
+		}
+	}
+
+	fib := TailRec(fibStep)
+	result := fib(State{10, 0, 1})(context.Background())
+
+	assert.Equal(t, R.Of(89), result) // 10th Fibonacci number
+}
+
+// TestTailRecCountdown tests countdown computation
+func TestTailRecCountdown(t *testing.T) {
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(10)(context.Background())
+
+	assert.Equal(t, R.Of(0), result)
+}
+
+// TestTailRecImmediateTermination tests immediate termination (Right on first call)
+func TestTailRecImmediateTermination(t *testing.T) {
+	immediateStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			return R.Of(TR.Land[int](n * 2))
+		}
+	}
+
+	immediate := TailRec(immediateStep)
+	result := immediate(42)(context.Background())
+
+	assert.Equal(t, R.Of(84), result)
+}
+
+// TestTailRecStackSafety tests that TailRec handles large iterations without stack overflow
+func TestTailRecStackSafety(t *testing.T) {
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(10000)(context.Background())
+
+	assert.Equal(t, R.Of(0), result)
+}
+
+// TestTailRecSumList tests summing a list
+func TestTailRecSumList(t *testing.T) {
+	type State struct {
+		list []int
+		sum  int
+	}
+
+	sumStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if A.IsEmpty(state.list) {
+				return R.Of(TR.Land[State](state.sum))
+			}
+			return R.Of(TR.Bounce[int](State{state.list[1:], state.sum + state.list[0]}))
+		}
+	}
+
+	sumList := TailRec(sumStep)
+	result := sumList(State{[]int{1, 2, 3, 4, 5}, 0})(context.Background())
+
+	assert.Equal(t, R.Of(15), result)
+}
+
+// TestTailRecCollatzConjecture tests the Collatz conjecture
+func TestTailRecCollatzConjecture(t *testing.T) {
+	collatzStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n <= 1 {
+				return R.Of(TR.Land[int](n))
+			}
+			if n%2 == 0 {
+				return R.Of(TR.Bounce[int](n / 2))
+			}
+			return R.Of(TR.Bounce[int](3*n + 1))
+		}
+	}
+
+	collatz := TailRec(collatzStep)
+	result := collatz(10)(context.Background())
+
+	assert.Equal(t, R.Of(1), result)
+}
+
+// TestTailRecGCD tests greatest common divisor
+func TestTailRecGCD(t *testing.T) {
+	type State struct {
+		a int
+		b int
+	}
+
+	gcdStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.b == 0 {
+				return R.Of(TR.Land[State](state.a))
+			}
+			return R.Of(TR.Bounce[int](State{state.b, state.a % state.b}))
+		}
+	}
+
+	gcd := TailRec(gcdStep)
+	result := gcd(State{48, 18})(context.Background())
+
+	assert.Equal(t, R.Of(6), result)
+}
+
+// TestTailRecErrorPropagation tests that errors are properly propagated
+func TestTailRecErrorPropagation(t *testing.T) {
+	expectedErr := errors.New("computation error")
+
+	errorStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n == 5 {
+				return R.Left[TR.Trampoline[int, int]](expectedErr)
+			}
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	computation := TailRec(errorStep)
+	result := computation(10)(context.Background())
+
+	assert.True(t, R.IsLeft(result))
+	_, err := R.Unwrap(result)
+	assert.Equal(t, expectedErr, err)
+}
+
+// TestTailRecContextCancellationImmediate tests short circuit when context is already canceled
+func TestTailRecContextCancellationImmediate(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // Cancel immediately before execution
+
+	stepExecuted := false
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			stepExecuted = true
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(10)(ctx)
+
+	// Should short circuit without executing any steps
+	assert.False(t, stepExecuted, "Step should not be executed when context is already canceled")
+	assert.True(t, R.IsLeft(result))
+	_, err := R.Unwrap(result)
+	assert.Equal(t, context.Canceled, err)
+}
+
+// TestTailRecContextCancellationDuringExecution tests short circuit when context is canceled during execution
+func TestTailRecContextCancellationDuringExecution(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	executionCount := 0
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			executionCount++
+			// Cancel after 3 iterations
+			if executionCount == 3 {
+				cancel()
+			}
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(100)(ctx)
+
+	// Should stop after cancellation
+	assert.True(t, R.IsLeft(result))
+	assert.LessOrEqual(t, executionCount, 4, "Should stop shortly after cancellation")
+	_, err := R.Unwrap(result)
+	assert.Equal(t, context.Canceled, err)
+}
+
+// TestTailRecContextWithTimeout tests behavior with timeout context
+func TestTailRecContextWithTimeout(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+	defer cancel()
+
+	executionCount := 0
+	slowStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			executionCount++
+			// Simulate slow computation
+			time.Sleep(20 * time.Millisecond)
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	computation := TailRec(slowStep)
+	result := computation(100)(ctx)
+
+	// Should timeout and return error
+	assert.True(t, R.IsLeft(result))
+	assert.Less(t, executionCount, 100, "Should not complete all iterations due to timeout")
+	_, err := R.Unwrap(result)
+	assert.Equal(t, context.DeadlineExceeded, err)
+}
+
+// TestTailRecContextWithCause tests that context.Cause is properly returned
+func TestTailRecContextWithCause(t *testing.T) {
+	customErr := errors.New("custom cancellation reason")
+	ctx, cancel := context.WithCancelCause(context.Background())
+	cancel(customErr)
+
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(10)(ctx)
+
+	assert.True(t, R.IsLeft(result))
+	_, err := R.Unwrap(result)
+	assert.Equal(t, customErr, err)
+}
+
+// TestTailRecContextCancellationMultipleIterations tests that cancellation is checked on each iteration
+func TestTailRecContextCancellationMultipleIterations(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	executionCount := 0
+	maxExecutions := 5
+
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			executionCount++
+			if executionCount == maxExecutions {
+				cancel()
+			}
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(1000)(ctx)
+
+	// Should detect cancellation on next iteration check
+	assert.True(t, R.IsLeft(result))
+	// Should stop within 1-2 iterations after cancellation
+	assert.LessOrEqual(t, executionCount, maxExecutions+2)
+	_, err := R.Unwrap(result)
+	assert.Equal(t, context.Canceled, err)
+}
+
+// TestTailRecContextNotCanceled tests normal execution when context is not canceled
+func TestTailRecContextNotCanceled(t *testing.T) {
+	ctx := context.Background()
+
+	executionCount := 0
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			executionCount++
+			if n <= 0 {
+				return R.Of(TR.Land[int](n))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(10)(ctx)
+
+	assert.Equal(t, 11, executionCount) // 10, 9, 8, ..., 1, 0
+	assert.Equal(t, R.Of(0), result)
+}
+
+// TestTailRecPowerOfTwo tests computing power of 2
+func TestTailRecPowerOfTwo(t *testing.T) {
+	type State struct {
+		exponent int
+		result   int
+		target   int
+	}
+
+	powerStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.exponent >= state.target {
+				return R.Of(TR.Land[State](state.result))
+			}
+			return R.Of(TR.Bounce[int](State{state.exponent + 1, state.result * 2, state.target}))
+		}
+	}
+
+	power := TailRec(powerStep)
+	result := power(State{0, 1, 10})(context.Background())
+
+	assert.Equal(t, R.Of(1024), result) // 2^10
+}
+
+// TestTailRecFindInRange tests finding a value in a range
+func TestTailRecFindInRange(t *testing.T) {
+	type State struct {
+		current int
+		max     int
+		target  int
+	}
+
+	findStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.current >= state.max {
+				return R.Of(TR.Land[State](-1)) // Not found
+			}
+			if state.current == state.target {
+				return R.Of(TR.Land[State](state.current)) // Found
+			}
+			return R.Of(TR.Bounce[int](State{state.current + 1, state.max, state.target}))
+		}
+	}
+
+	find := TailRec(findStep)
+	result := find(State{0, 100, 42})(context.Background())
+
+	assert.Equal(t, R.Of(42), result)
+}
+
+// TestTailRecFindNotInRange tests finding a value not in range
+func TestTailRecFindNotInRange(t *testing.T) {
+	type State struct {
+		current int
+		max     int
+		target  int
+	}
+
+	findStep := func(state State) ReaderResult[TR.Trampoline[State, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[State, int]] {
+			if state.current >= state.max {
+				return R.Of(TR.Land[State](-1)) // Not found
+			}
+			if state.current == state.target {
+				return R.Of(TR.Land[State](state.current)) // Found
+			}
+			return R.Of(TR.Bounce[int](State{state.current + 1, state.max, state.target}))
+		}
+	}
+
+	find := TailRec(findStep)
+	result := find(State{0, 100, 200})(context.Background())
+
+	assert.Equal(t, R.Of(-1), result)
+}
+
+// TestTailRecWithContextValue tests that context values are accessible
+func TestTailRecWithContextValue(t *testing.T) {
+	type contextKey string
+	const multiplierKey contextKey = "multiplier"
+
+	ctx := context.WithValue(context.Background(), multiplierKey, 3)
+
+	countdownStep := func(n int) ReaderResult[TR.Trampoline[int, int]] {
+		return func(ctx context.Context) Result[TR.Trampoline[int, int]] {
+			if n <= 0 {
+				multiplier := ctx.Value(multiplierKey).(int)
+				return R.Of(TR.Land[int](n * multiplier))
+			}
+			return R.Of(TR.Bounce[int](n - 1))
+		}
+	}
+
+	countdown := TailRec(countdownStep)
+	result := countdown(5)(ctx)
+
+	assert.Equal(t, R.Of(0), result) // 0 * 3 = 0
+}
+
+// TestTailRecComplexState tests with complex state structure
+func TestTailRecComplexState(t *testing.T) {
+	type ComplexState struct {
+		counter   int
+		sum       int
+		product   int
+		completed bool
+	}
+
+	complexStep := func(state ComplexState) ReaderResult[TR.Trampoline[ComplexState, string]] {
+		return func(ctx context.Context) Result[TR.Trampoline[ComplexState, string]] {
+			if state.counter <= 0 || state.completed {
+				result := fmt.Sprintf("sum=%d, product=%d", state.sum, state.product)
+				return R.Of(TR.Land[ComplexState](result))
+			}
+			newState := ComplexState{
+				counter:   state.counter - 1,
+				sum:       state.sum + state.counter,
+				product:   state.product * state.counter,
+				completed: state.counter == 1,
+			}
+			return R.Of(TR.Bounce[string](newState))
+		}
+	}
+
+	computation := TailRec(complexStep)
+	result := computation(ComplexState{5, 0, 1, false})(context.Background())
+
+	assert.Equal(t, R.Of("sum=15, product=120"), result)
+}

v2/context/readerresult/retry.go

@@ -0,0 +1,156 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache LicensVersion 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package readerresult
+
+import (
+	"context"
+	"time"
+
+	RD "github.com/IBM/fp-go/v2/reader"
+	R "github.com/IBM/fp-go/v2/retry"
+	RG "github.com/IBM/fp-go/v2/retry/generic"
+)
+
+// Retrying retries a ReaderResult computation according to a retry policy with context awareness.
+//
+// This function implements a retry mechanism for operations that depend on a [context.Context]
+// and can fail (Result). It respects context cancellation, meaning that if the context is
+// cancelled during retry delays, the operation will stop immediately and return the cancellation error.
+//
+// The retry loop will continue until one of the following occurs:
+//   - The action succeeds and the check function returns false (no retry needed)
+//   - The retry policy returns None (retry limit reached)
+//   - The check function returns false (indicating success or a non-retryable failure)
+//   - The context is cancelled (returns context.Canceled or context.DeadlineExceeded)
+//
+// Type Parameters:
+//   - A: The type of the success value
+//
+// Parameters:
+//
+//   - policy: A RetryPolicy that determines when and how long to wait between retries.
+//     The policy receives a RetryStatus on each iteration and returns an optional delay.
+//     If it returns None, retrying stops. Common policies include LimitRetries,
+//     ExponentialBackoff, and CapDelay from the retry package.
+//
+//   - action: A Kleisli arrow that takes a RetryStatus and returns a ReaderResult[A].
+//     This function is called on each retry attempt and receives information about the
+//     current retry state (iteration number, cumulative delay, etc.). The action depends
+//     on a context.Context and produces a Result[A].
+//
+//   - check: A predicate function that examines the Result[A] and returns true if the
+//     operation should be retried, or false if it should stop. This allows you to
+//     distinguish between retryable failures (e.g., network timeouts) and permanent
+//     failures (e.g., invalid input).
+//
+// Returns:
+//   - A ReaderResult[A] that, when executed with a context, will perform the retry
+//     logic with context cancellation support and return the final result.
+//
+// Example:
+//
+//	// Create a retry policy: exponential backoff with a cap, limited to 5 retries
+//	policy := M.Concat(
+//	    retry.LimitRetries(5),
+//	    retry.CapDelay(10*time.Second, retry.ExponentialBackoff(100*time.Millisecond)),
+//	)(retry.Monoid)
+//
+//	// Action that fetches data
+//	fetchData := func(status retry.RetryStatus) ReaderResult[string] {
+//	    return func(ctx context.Context) Result[string] {
+//	        if ctx.Err() != nil {
+//	            return result.Left[string](ctx.Err())
+//	        }
+//	        if status.IterNumber < 3 {
+//	            return result.Left[string](fmt.Errorf("temporary error"))
+//	        }
+//	        return result.Of("success")
+//	    }
+//	}
+//
+//	// Check function: retry on any error except context cancellation
+//	shouldRetry := func(r Result[string]) bool {
+//	    return result.IsLeft(r) && !errors.Is(result.GetLeft(r), context.Canceled)
+//	}
+//
+//	// Create the retrying computation
+//	retryingFetch := Retrying(policy, fetchData, shouldRetry)
+//
+//	// Execute with a cancellable context
+//	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+//	defer cancel()
+//	finalResult := retryingFetch(ctx)
+//
+//go:inline
+func Retrying[A any](
+	policy R.RetryPolicy,
+	action Kleisli[R.RetryStatus, A],
+	check Predicate[Result[A]],
+) ReaderResult[A] {
+
+	// delayWithCancel implements a context-aware delay mechanism for retry operations.
+	// It creates a timeout context that will be cancelled when either:
+	//   1. The delay duration expires (normal case), or
+	//   2. The parent context is cancelled (early termination)
+	//
+	// The function waits on timeoutCtx.Done(), which will be signaled in either case:
+	//   - If the delay expires, timeoutCtx is cancelled by the timeout
+	//   - If the parent ctx is cancelled, timeoutCtx inherits the cancellation
+	//
+	// After the wait completes, we dispatch to the next action by calling ri(ctx)().
+	// This works correctly because the action is wrapped in WithContextK, which handles
+	// context cancellation by checking ctx.Err() and returning an appropriate error
+	// (context.Canceled or context.DeadlineExceeded) when the context is cancelled.
+	//
+	// This design ensures that:
+	//   - Retry delays respect context cancellation and terminate immediately
+	//   - The cancellation error propagates correctly through the retry chain
+	//   - No unnecessary delays occur when the context is already cancelled
+	delayWithCancel := func(delay time.Duration) RD.Operator[context.Context, R.RetryStatus, R.RetryStatus] {
+		return func(ri Reader[context.Context, R.RetryStatus]) Reader[context.Context, R.RetryStatus] {
+			return func(ctx context.Context) R.RetryStatus {
+				// Create a timeout context that will be cancelled when either:
+				// - The delay duration expires, or
+				// - The parent context is cancelled
+				timeoutCtx, cancelTimeout := context.WithTimeout(ctx, delay)
+				defer cancelTimeout()
+
+				// Wait for either the timeout or parent context cancellation
+				<-timeoutCtx.Done()
+
+				// Dispatch to the next action with the original context.
+				// WithContextK will handle context cancellation correctly.
+				return ri(ctx)
+			}
+		}
+	}
+
+	// get an implementation for the types
+	return RG.Retrying(
+		RD.Chain[context.Context, Result[A], Trampoline[R.RetryStatus, Result[A]]],
+		RD.Map[context.Context, R.RetryStatus, Trampoline[R.RetryStatus, Result[A]]],
+		RD.Of[context.Context, Trampoline[R.RetryStatus, Result[A]]],
+		RD.Of[context.Context, R.RetryStatus],
+		delayWithCancel,
+
+		RD.TailRec,
+
+		policy,
+		WithContextK(action),
+		check,
+	)
+
+}

v2/context/readerresult/type.go

@@ -13,26 +13,61 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// package readerresult implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
+// Package readerresult implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error.
+//
+// # Pure vs Effectful Functions
+//
+// This package distinguishes between pure (side-effect free) and effectful (side-effectful) functions:
+//
+// EFFECTFUL FUNCTIONS (depend on context.Context):
+//   - ReaderResult[A]: func(context.Context) (A, error) - Effectful computation that needs context
+//   - These functions are effectful because context.Context is effectful (can be cancelled, has deadlines, carries values)
+//   - Use for: operations that need cancellation, timeouts, context values, or any context-dependent behavior
+//   - Examples: database queries, HTTP requests, operations that respect cancellation
+//
+// PURE FUNCTIONS (side-effect free):
+//   - func(State) (Value, error) - Pure computation that only depends on state, not context
+//   - func(State) Value - Pure transformation without errors
+//   - These functions are pure because they only read from their input state and don't depend on external context
+//   - Use for: parsing, validation, calculations, data transformations that don't need context
+//   - Examples: JSON parsing, input validation, mathematical computations
+//
+// The package provides different bind operations for each:
+//   - Bind: For effectful ReaderResult computations (State -> ReaderResult[Value])
+//   - BindResultK: For pure functions with errors (State -> (Value, error))
+//   - Let: For pure functions without errors (State -> Value)
+//   - BindReaderK: For context-dependent pure functions (State -> Reader[Context, Value])
+//   - BindEitherK: For pure Result/Either values (State -> Result[Value])
 package readerresult
 
 import (
 	"context"
 
 	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/endomorphism"
+	"github.com/IBM/fp-go/v2/optics/lens"
+	"github.com/IBM/fp-go/v2/optics/prism"
 	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 	"github.com/IBM/fp-go/v2/readereither"
 	"github.com/IBM/fp-go/v2/result"
+	"github.com/IBM/fp-go/v2/tailrec"
 )
 
 type (
-	Option[A any] = option.Option[A]
-	Either[A any] = either.Either[error, A]
-	Result[A any] = result.Result[A]
+	Option[A any]    = option.Option[A]
+	Either[A any]    = either.Either[error, A]
+	Result[A any]    = result.Result[A]
+	Reader[R, A any] = reader.Reader[R, A]
 	// ReaderResult is a specialization of the Reader monad for the typical golang scenario
 	ReaderResult[A any] = readereither.ReaderEither[context.Context, error, A]
 
-	Kleisli[A, B any]  = reader.Reader[A, ReaderResult[B]]
-	Operator[A, B any] = Kleisli[ReaderResult[A], B]
+	Kleisli[A, B any]    = reader.Reader[A, ReaderResult[B]]
+	Operator[A, B any]   = Kleisli[ReaderResult[A], B]
+	Endomorphism[A any]  = endomorphism.Endomorphism[A]
+	Prism[S, T any]      = prism.Prism[S, T]
+	Lens[S, T any]       = lens.Lens[S, T]
+	Trampoline[A, B any] = tailrec.Trampoline[A, B]
+	Predicate[A any]     = predicate.Predicate[A]
 )

v2/context/statereaderioresult/filter.go

@@ -0,0 +1,55 @@
+// Copyright (c) 2024 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package statereaderioresult
+
+import (
+	"context"
+
+	"github.com/IBM/fp-go/v2/statereaderioeither"
+)
+
+// FilterOrElse filters a StateReaderIOResult value based on a predicate.
+// This is a convenience wrapper around statereaderioeither.FilterOrElse that fixes
+// the context type to context.Context and the error type to error.
+//
+// If the predicate returns true for the Right value, it passes through unchanged.
+// If the predicate returns false, it transforms the Right value into a Left (error) using onFalse.
+// Left values are passed through unchanged.
+//
+// Parameters:
+//   - pred: A predicate function that tests the Right value
+//   - onFalse: A function that converts the failing value into an error
+//
+// Returns:
+//   - An Operator that filters StateReaderIOResult values based on the predicate
+//
+// Example:
+//
+//	type AppState struct {
+//	    Counter int
+//	}
+//
+//	// Validate that a number is positive
+//	isPositive := N.MoreThan(0)
+//	onNegative := func(n int) error { return fmt.Errorf("%d is not positive", n) }
+//
+//	filter := statereaderioresult.FilterOrElse[AppState](isPositive, onNegative)
+//	result := filter(statereaderioresult.Right[AppState](42))(AppState{})(context.Background())()
+//
+//go:inline
+func FilterOrElse[S, A any](pred Predicate[A], onFalse func(A) error) Operator[S, A, A] {
+	return statereaderioeither.FilterOrElse[S, context.Context](pred, onFalse)
+}

v2/context/statereaderioresult/type.go

@@ -22,6 +22,7 @@ import (
 	"github.com/IBM/fp-go/v2/ioresult"
 	"github.com/IBM/fp-go/v2/optics/iso/lens"
 	"github.com/IBM/fp-go/v2/pair"
+	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 	"github.com/IBM/fp-go/v2/result"
 	"github.com/IBM/fp-go/v2/state"
@@ -81,4 +82,6 @@ type (
 	// Operator represents a function that transforms one StateReaderIOResult into another.
 	// This is commonly used for building composable operations via Map, Chain, etc.
 	Operator[S, A, B any] = Reader[StateReaderIOResult[S, A], StateReaderIOResult[S, B]]
+
+	Predicate[A any] = predicate.Predicate[A]
 )

v2/di/erasure/injector.go

@@ -23,14 +23,15 @@ import (
 	IOR "github.com/IBM/fp-go/v2/ioresult"
 	L "github.com/IBM/fp-go/v2/lazy"
 	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/pair"
 	R "github.com/IBM/fp-go/v2/record"
 	T "github.com/IBM/fp-go/v2/tuple"
 
 	"sync"
 )
 
-func providerToEntry(p Provider) T.Tuple2[string, ProviderFactory] {
-	return T.MakeTuple2(p.Provides().Id(), p.Factory())
+func providerToEntry(p Provider) Entry[string, ProviderFactory] {
+	return pair.MakePair(p.Provides().Id(), p.Factory())
 }
 
 func itemProviderToMap(p Provider) map[string][]ProviderFactory {

v2/di/erasure/types.go

@@ -4,10 +4,12 @@ import (
 	"github.com/IBM/fp-go/v2/iooption"
 	"github.com/IBM/fp-go/v2/ioresult"
 	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/record"
 )
 
 type (
-	Option[T any]   = option.Option[T]
-	IOResult[T any] = ioresult.IOResult[T]
-	IOOption[T any] = iooption.IOOption[T]
+	Option[T any]              = option.Option[T]
+	IOResult[T any]            = ioresult.IOResult[T]
+	IOOption[T any]            = iooption.IOOption[T]
+	Entry[K comparable, V any] = record.Entry[K, V]
 )

v2/di/token.go

@@ -103,11 +103,11 @@ func (t *token[T]) Unerase(val any) Result[T] {
 func (t *token[T]) ProviderFactory() Option[DIE.ProviderFactory] {
 	return t.base.providerFactory
 }
-func makeTokenBase(name string, id string, typ int, providerFactory Option[DIE.ProviderFactory]) *tokenBase {
+func makeTokenBase(name, id string, typ int, providerFactory Option[DIE.ProviderFactory]) *tokenBase {
 	return &tokenBase{name, id, typ, providerFactory}
 }
 
-func makeToken[T any](name string, id string, typ int, unerase func(val any) Result[T], providerFactory Option[DIE.ProviderFactory]) Dependency[T] {
+func makeToken[T any](name, id string, typ int, unerase func(val any) Result[T], providerFactory Option[DIE.ProviderFactory]) Dependency[T] {
 	return &token[T]{makeTokenBase(name, id, typ, providerFactory), unerase}
 }
 

v2/di/types.go

@@ -4,12 +4,23 @@ import (
 	"github.com/IBM/fp-go/v2/context/ioresult"
 	"github.com/IBM/fp-go/v2/iooption"
 	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/record"
 	"github.com/IBM/fp-go/v2/result"
 )
 
 type (
-	Option[T any]   = option.Option[T]
-	Result[T any]   = result.Result[T]
+	// Option represents an optional value that may or may not be present.
+	Option[T any] = option.Option[T]
+
+	// Result represents a computation that may fail with an error.
+	Result[T any] = result.Result[T]
+
+	// IOResult represents a synchronous computation that may fail with an error.
 	IOResult[T any] = ioresult.IOResult[T]
+
+	// IOOption represents a synchronous computation that may not produce a value.
 	IOOption[T any] = iooption.IOOption[T]
+
+	// Entry represents a key-value pair in a record/map structure.
+	Entry[K comparable, V any] = record.Entry[K, V]
 )

v2/either/array.go

@@ -75,7 +75,7 @@ func TraverseArray[E, A, B any](f Kleisli[E, A, B]) Kleisli[E, []A, []B] {
 // Example:
 //
 //	validate := func(i int, s string) either.Either[error, string] {
-//	    if len(s) > 0 {
+//	    if S.IsNonEmpty(s) {
 //	        return either.Right[error](fmt.Sprintf("%d:%s", i, s))
 //	    }
 //	    return either.Left[string](fmt.Errorf("empty at index %d", i))
@@ -105,7 +105,7 @@ func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, E, A, B any](f func(int, A) Eithe
 // Example:
 //
 //	validate := func(i int, s string) either.Either[error, string] {
-//	    if len(s) > 0 {
+//	    if S.IsNonEmpty(s) {
 //	        return either.Right[error](fmt.Sprintf("%d:%s", i, s))
 //	    }
 //	    return either.Left[string](fmt.Errorf("empty at index %d", i))

v2/either/core.go

@@ -15,10 +15,6 @@
 
 package either
 
-import (
-	"fmt"
-)
-
 type (
 	// Either defines a data structure that logically holds either an E or an A. The flag discriminates the cases
 	Either[E, A any] struct {
@@ -28,28 +24,6 @@ type (
 	}
 )
 
-// String prints some debug info for the object
-//
-//go:noinline
-func (s Either[E, A]) String() string {
-	if !s.isLeft {
-		return fmt.Sprintf("Right[%T](%v)", s.r, s.r)
-	}
-	return fmt.Sprintf("Left[%T](%v)", s.l, s.l)
-}
-
-// Format prints some debug info for the object
-//
-//go:noinline
-func (s Either[E, A]) Format(f fmt.State, c rune) {
-	switch c {
-	case 's':
-		fmt.Fprint(f, s.String())
-	default:
-		fmt.Fprint(f, s.String())
-	}
-}
-
 // IsLeft tests if the Either is a Left value.
 // Rather use [Fold] or [MonadFold] if you need to access the values.
 // Inverse is [IsRight].

v2/either/curry.go

@@ -34,7 +34,7 @@ func Curry0[R any](f func() (R, error)) func() Either[error, R] {
 //
 // Example:
 //
-//	parse := func(s string) (int, error) { return strconv.Atoi(s) }
+//	parse := strconv.Atoi
 //	curried := either.Curry1(parse)
 //	result := curried("42") // Right(42)
 func Curry1[T1, R any](f func(T1) (R, error)) func(T1) Either[error, R] {

v2/either/doc.go

@@ -19,6 +19,21 @@
 //   - Left represents an error or failure case (type E)
 //   - Right represents a success case (type A)
 //
+// # Fantasy Land Specification
+//
+// This implementation corresponds to the Fantasy Land Either type:
+// https://github.com/fantasyland/fantasy-land#either
+//
+// Implemented Fantasy Land algebras:
+//   - Functor: https://github.com/fantasyland/fantasy-land#functor
+//   - Bifunctor: https://github.com/fantasyland/fantasy-land#bifunctor
+//   - Apply: https://github.com/fantasyland/fantasy-land#apply
+//   - Applicative: https://github.com/fantasyland/fantasy-land#applicative
+//   - Chain: https://github.com/fantasyland/fantasy-land#chain
+//   - Monad: https://github.com/fantasyland/fantasy-land#monad
+//   - Alt: https://github.com/fantasyland/fantasy-land#alt
+//   - Foldable: https://github.com/fantasyland/fantasy-land#foldable
+//
 // # Core Concepts
 //
 // The Either type is a discriminated union that can hold either a Left value (typically an error)

v2/either/either.go

@@ -394,12 +394,12 @@ func UnwrapError[A any](ma Either[error, A]) (A, error) {
 // Example:
 //
 //	isPositive := either.FromPredicate(
-//	    func(x int) bool { return x > 0 },
+//	    N.MoreThan(0),
 //	    func(x int) error { return errors.New("not positive") },
 //	)
 //	result := isPositive(42) // Right(42)
 //	result := isPositive(-1) // Left(error)
-func FromPredicate[E, A any](pred func(A) bool, onFalse func(A) E) func(A) Either[E, A] {
+func FromPredicate[E, A any](pred Predicate[A], onFalse func(A) E) Kleisli[E, A, A] {
 	return func(a A) Either[E, A] {
 		if pred(a) {
 			return Right[E](a)
@@ -416,7 +416,7 @@ func FromPredicate[E, A any](pred func(A) bool, onFalse func(A) E) func(A) Eithe
 //	result := either.FromNillable[int](errors.New("nil"))(ptr) // Left(error)
 //	val := 42
 //	result := either.FromNillable[int](errors.New("nil"))(&val) // Right(&42)
-func FromNillable[A, E any](e E) func(*A) Either[E, *A] {
+func FromNillable[A, E any](e E) Kleisli[E, *A, *A] {
 	return FromPredicate(F.IsNonNil[A], F.Constant1[*A](e))
 }
 
@@ -450,7 +450,7 @@ func Reduce[E, A, B any](f func(B, A) B, initial B) func(Either[E, A]) B {
 //	    return either.Right[string](99)
 //	})
 //	result := alternative(either.Left[int](errors.New("fail"))) // Right(99)
-func AltW[E, E1, A any](that Lazy[Either[E1, A]]) func(Either[E, A]) Either[E1, A] {
+func AltW[E, E1, A any](that Lazy[Either[E1, A]]) Kleisli[E1, Either[E, A], A] {
 	return Fold(F.Ignore1of1[E](that), Right[E1, A])
 }
 
@@ -466,16 +466,29 @@ func Alt[E, A any](that Lazy[Either[E, A]]) Operator[E, A, A] {
 	return AltW[E](that)
 }
 
-// OrElse recovers from a Left by providing an alternative computation.
+// OrElse recovers from a Left (error) by providing an alternative computation.
+// If the Either is Right, it returns the value unchanged.
+// If the Either is Left, it applies the provided function to the error value,
+// which returns a new Either that replaces the original.
+//
+// This is useful for error recovery, fallback logic, or chaining alternative computations.
+// The error type can be widened from E1 to E2, allowing transformation of error types.
 //
 // Example:
 //
+//	// Recover from specific errors with fallback values
 //	recover := either.OrElse(func(err error) either.Either[error, int] {
-//	    return either.Right[error](0) // default value
+//	    if err.Error() == "not found" {
+//	        return either.Right[error](0) // default value
+//	    }
+//	    return either.Left[int](err) // propagate other errors
 //	})
-//	result := recover(either.Left[int](errors.New("fail"))) // Right(0)
-func OrElse[E, A any](onLeft Kleisli[E, E, A]) Operator[E, A, A] {
-	return Fold(onLeft, Of[E, A])
+//	result := recover(either.Left[int](errors.New("not found"))) // Right(0)
+//	result := recover(either.Right[error](42)) // Right(42) - unchanged
+//
+//go:inline
+func OrElse[E1, E2, A any](onLeft Kleisli[E2, E1, A]) Kleisli[E2, Either[E1, A], A] {
+	return Fold(onLeft, Of[E2, A])
 }
 
 // ToType attempts to convert an any value to a specific type, returning Either.

v2/either/either_coverage_test.go

@@ -22,8 +22,9 @@ import (
 	"testing"
 
 	F "github.com/IBM/fp-go/v2/function"
-	M "github.com/IBM/fp-go/v2/monoid"
+	N "github.com/IBM/fp-go/v2/number"
 	O "github.com/IBM/fp-go/v2/option"
+	S "github.com/IBM/fp-go/v2/string"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -159,6 +160,7 @@ func TestToError(t *testing.T) {
 
 // Test OrElse
 func TestOrElse(t *testing.T) {
+	// Test basic recovery from Left
 	recover := OrElse(func(e error) Either[error, int] {
 		return Right[error](0)
 	})
@@ -166,8 +168,85 @@ func TestOrElse(t *testing.T) {
 	result := recover(Left[int](errors.New("error")))
 	assert.Equal(t, Right[error](0), result)
 
+	// Test Right value passes through unchanged
 	result = recover(Right[error](42))
 	assert.Equal(t, Right[error](42), result)
+
+	// Test selective recovery - recover some errors, propagate others
+	selectiveRecover := OrElse(func(err error) Either[error, int] {
+		if err.Error() == "not found" {
+			return Right[error](0) // default value for "not found"
+		}
+		return Left[int](err) // propagate other errors
+	})
+	assert.Equal(t, Right[error](0), selectiveRecover(Left[int](errors.New("not found"))))
+	permissionErr := errors.New("permission denied")
+	assert.Equal(t, Left[int](permissionErr), selectiveRecover(Left[int](permissionErr)))
+
+	// Test chaining multiple OrElse operations
+	firstRecover := OrElse(func(err error) Either[error, int] {
+		if err.Error() == "error1" {
+			return Right[error](1)
+		}
+		return Left[int](err)
+	})
+	secondRecover := OrElse(func(err error) Either[error, int] {
+		if err.Error() == "error2" {
+			return Right[error](2)
+		}
+		return Left[int](err)
+	})
+	assert.Equal(t, Right[error](1), F.Pipe1(Left[int](errors.New("error1")), firstRecover))
+	assert.Equal(t, Right[error](2), F.Pipe1(Left[int](errors.New("error2")), F.Flow2(firstRecover, secondRecover)))
+}
+
+// Test OrElseW
+func TestOrElseW(t *testing.T) {
+	type ValidationError string
+	type AppError int
+
+	// Test with Right value - should return Right with widened error type
+	rightValue := Right[ValidationError]("success")
+	recoverValidation := OrElse(func(ve ValidationError) Either[AppError, string] {
+		return Left[string](AppError(400))
+	})
+	result := recoverValidation(rightValue)
+	assert.True(t, IsRight(result))
+	assert.Equal(t, "success", F.Pipe1(result, GetOrElse(F.Constant1[AppError](""))))
+
+	// Test with Left value - should apply recovery with new error type
+	leftValue := Left[string](ValidationError("invalid input"))
+	result = recoverValidation(leftValue)
+	assert.True(t, IsLeft(result))
+	_, leftVal := Unwrap(result)
+	assert.Equal(t, AppError(400), leftVal)
+
+	// Test error type conversion - ValidationError to AppError
+	convertError := OrElse(func(ve ValidationError) Either[AppError, int] {
+		return Left[int](AppError(len(ve)))
+	})
+	converted := convertError(Left[int](ValidationError("short")))
+	assert.True(t, IsLeft(converted))
+	_, leftConv := Unwrap(converted)
+	assert.Equal(t, AppError(5), leftConv)
+
+	// Test recovery to Right with widened error type
+	recoverToRight := OrElse(func(ve ValidationError) Either[AppError, int] {
+		if ve == "recoverable" {
+			return Right[AppError](99)
+		}
+		return Left[int](AppError(500))
+	})
+	assert.Equal(t, Right[AppError](99), recoverToRight(Left[int](ValidationError("recoverable"))))
+	assert.True(t, IsLeft(recoverToRight(Left[int](ValidationError("fatal")))))
+
+	// Test that Right values are preserved with widened error type
+	preservedRight := Right[ValidationError](42)
+	preserveRecover := OrElse(func(ve ValidationError) Either[AppError, int] {
+		return Left[int](AppError(999))
+	})
+	preserved := preserveRecover(preservedRight)
+	assert.Equal(t, Right[AppError](42), preserved)
 }
 
 // Test ToType
@@ -305,7 +384,7 @@ func TestTraverseArray(t *testing.T) {
 // Test TraverseArrayWithIndex
 func TestTraverseArrayWithIndex(t *testing.T) {
 	validate := func(i int, s string) Either[error, string] {
-		if len(s) > 0 {
+		if S.IsNonEmpty(s) {
 			return Right[error](fmt.Sprintf("%d:%s", i, s))
 		}
 		return Left[string](fmt.Errorf("empty at index %d", i))
@@ -334,7 +413,7 @@ func TestTraverseRecord(t *testing.T) {
 // Test TraverseRecordWithIndex
 func TestTraverseRecordWithIndex(t *testing.T) {
 	validate := func(k string, v string) Either[error, string] {
-		if len(v) > 0 {
+		if S.IsNonEmpty(v) {
 			return Right[error](k + ":" + v)
 		}
 		return Left[string](fmt.Errorf("empty value for key %s", k))
@@ -373,7 +452,7 @@ func TestCurry0(t *testing.T) {
 }
 
 func TestCurry1(t *testing.T) {
-	parse := func(s string) (int, error) { return strconv.Atoi(s) }
+	parse := strconv.Atoi
 	curried := Curry1(parse)
 	result := curried("42")
 	assert.Equal(t, Right[error](42), result)
@@ -645,7 +724,7 @@ func TestAltSemigroup(t *testing.T) {
 
 // Test AlternativeMonoid
 func TestAlternativeMonoid(t *testing.T) {
-	intAdd := M.MakeMonoid(func(a, b int) int { return a + b }, 0)
+	intAdd := N.MonoidSum[int]()
 	m := AlternativeMonoid[error](intAdd)
 
 	result := m.Concat(Right[error](1), Right[error](2))

v2/either/either_test.go

@@ -22,7 +22,6 @@ import (
 
 	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/utils"
-	IO "github.com/IBM/fp-go/v2/io"
 	O "github.com/IBM/fp-go/v2/option"
 	S "github.com/IBM/fp-go/v2/string"
 	"github.com/stretchr/testify/assert"
@@ -120,10 +119,3 @@ func TestStringer(t *testing.T) {
 	var s fmt.Stringer = &e
 	assert.Equal(t, exp, s.String())
 }
-
-func TestFromIO(t *testing.T) {
-	f := IO.Of("abc")
-	e := FromIO[error](f)
-
-	assert.Equal(t, Right[error]("abc"), e)
-}

v2/either/examples_format_test.go

@@ -0,0 +1,149 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either_test
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+
+	E "github.com/IBM/fp-go/v2/either"
+)
+
+// ExampleEither_String demonstrates the fmt.Stringer interface implementation.
+func ExampleEither_String() {
+	right := E.Right[error](42)
+	left := E.Left[int](errors.New("something went wrong"))
+
+	fmt.Println(right.String())
+	fmt.Println(left.String())
+
+	// Output:
+	// Right[int](42)
+	// Left[*errors.errorString](something went wrong)
+}
+
+// ExampleEither_GoString demonstrates the fmt.GoStringer interface implementation.
+func ExampleEither_GoString() {
+	right := E.Right[error](42)
+	left := E.Left[int](errors.New("error"))
+
+	fmt.Printf("%#v\n", right)
+	fmt.Printf("%#v\n", left)
+
+	// Output:
+	// either.Right[error](42)
+	// either.Left[int](&errors.errorString{s:"error"})
+}
+
+// ExampleEither_Format demonstrates the fmt.Formatter interface implementation.
+func ExampleEither_Format() {
+	result := E.Right[error](42)
+
+	// Different format verbs
+	fmt.Printf("%%s: %s\n", result)
+	fmt.Printf("%%v: %v\n", result)
+	fmt.Printf("%%+v: %+v\n", result)
+	fmt.Printf("%%#v: %#v\n", result)
+
+	// Output:
+	// %s: Right[int](42)
+	// %v: Right[int](42)
+	// %+v: Right[int](42)
+	// %#v: either.Right[error](42)
+}
+
+// ExampleEither_LogValue demonstrates the slog.LogValuer interface implementation.
+func ExampleEither_LogValue() {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+			// Remove time for consistent output
+			if a.Key == slog.TimeKey {
+				return slog.Attr{}
+			}
+			return a
+		},
+	}))
+
+	// Right value
+	rightResult := E.Right[error](42)
+	logger.Info("computation succeeded", "result", rightResult)
+
+	// Left value
+	leftResult := E.Left[int](errors.New("computation failed"))
+	logger.Error("computation failed", "result", leftResult)
+
+	// Output:
+	// level=INFO msg="computation succeeded" result.right=42
+	// level=ERROR msg="computation failed" result.left="computation failed"
+}
+
+// ExampleEither_formatting_comparison demonstrates different formatting options.
+func ExampleEither_formatting_comparison() {
+	type User struct {
+		ID   int
+		Name string
+	}
+
+	user := User{ID: 123, Name: "Alice"}
+	result := E.Right[error](user)
+
+	fmt.Printf("String():   %s\n", result.String())
+	fmt.Printf("GoString(): %s\n", result.GoString())
+	fmt.Printf("%%v:         %v\n", result)
+	fmt.Printf("%%#v:        %#v\n", result)
+
+	// Output:
+	// String():   Right[either_test.User]({123 Alice})
+	// GoString(): either.Right[error](either_test.User{ID:123, Name:"Alice"})
+	// %v:         Right[either_test.User]({123 Alice})
+	// %#v:        either.Right[error](either_test.User{ID:123, Name:"Alice"})
+}
+
+// ExampleEither_LogValue_structured demonstrates structured logging with Either.
+func ExampleEither_LogValue_structured() {
+	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+			if a.Key == slog.TimeKey {
+				return slog.Attr{}
+			}
+			return a
+		},
+	}))
+
+	// Simulate a computation pipeline
+	compute := func(x int) E.Either[error, int] {
+		if x < 0 {
+			return E.Left[int](errors.New("negative input"))
+		}
+		return E.Right[error](x * 2)
+	}
+
+	// Log successful computation
+	result1 := compute(21)
+	logger.Info("computation", "input", 21, "output", result1)
+
+	// Log failed computation
+	result2 := compute(-5)
+	logger.Error("computation", "input", -5, "output", result2)
+
+	// Output:
+	// level=INFO msg=computation input=21 output.right=42
+	// level=ERROR msg=computation input=-5 output.left="negative input"
+}

v2/either/filter.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+// FilterOrElse filters an Either value based on a predicate.
+// If the Either is Right and the predicate returns true, returns the original Right.
+// If the Either is Right and the predicate returns false, returns Left with the error from onFalse.
+// If the Either is Left, returns the original Left without applying the predicate.
+//
+// This is useful for adding validation to Right values, converting them to Left if they don't meet certain criteria.
+//
+// Example:
+//
+//	isPositive := N.MoreThan(0)
+//	onNegative := func(x int) error { return fmt.Errorf("%d is not positive", x) }
+//	filter := either.FilterOrElse(isPositive, onNegative)
+//
+//	result1 := filter(either.Right[error](5))  // Right(5)
+//	result2 := filter(either.Right[error](-3)) // Left(error: "-3 is not positive")
+//	result3 := filter(either.Left[int](someError)) // Left(someError)
+//
+//go:inline
+func FilterOrElse[E, A any](pred Predicate[A], onFalse func(A) E) Operator[E, A, A] {
+	return Chain(FromPredicate(pred, onFalse))
+}

v2/either/filter_test.go

@@ -0,0 +1,143 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	N "github.com/IBM/fp-go/v2/number"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFilterOrElse(t *testing.T) {
+	// Test with positive predicate
+	isPositive := N.MoreThan(0)
+	onNegative := func(x int) error { return fmt.Errorf("%d is not positive", x) }
+	filter := FilterOrElse(isPositive, onNegative)
+
+	// Test Right value that passes predicate
+	result := filter(Right[error](5))
+	assert.Equal(t, Right[error](5), result)
+
+	// Test Right value that fails predicate
+	result = filter(Right[error](-3))
+	assert.True(t, IsLeft(result))
+	left, _ := UnwrapError(result)
+	assert.Equal(t, 0, left) // default value for int
+
+	// Test Right value at boundary (zero)
+	result = filter(Right[error](0))
+	assert.True(t, IsLeft(result))
+
+	// Test Left value (should pass through unchanged)
+	originalError := errors.New("original error")
+	result = filter(Left[int](originalError))
+	assert.Equal(t, Left[int](originalError), result)
+}
+
+func TestFilterOrElse_StringValidation(t *testing.T) {
+	// Test with string length validation
+	isNotEmpty := func(s string) bool { return len(s) > 0 }
+	onEmpty := func(s string) error { return errors.New("string is empty") }
+	filter := FilterOrElse(isNotEmpty, onEmpty)
+
+	// Test non-empty string
+	result := filter(Right[error]("hello"))
+	assert.Equal(t, Right[error]("hello"), result)
+
+	// Test empty string
+	result = filter(Right[error](""))
+	assert.True(t, IsLeft(result))
+
+	// Test Left value
+	originalError := errors.New("validation error")
+	result = filter(Left[string](originalError))
+	assert.Equal(t, Left[string](originalError), result)
+}
+
+func TestFilterOrElse_ComplexPredicate(t *testing.T) {
+	// Test with range validation
+	inRange := func(x int) bool { return x >= 10 && x <= 100 }
+	outOfRange := func(x int) error { return fmt.Errorf("%d is out of range [10, 100]", x) }
+	filter := FilterOrElse(inRange, outOfRange)
+
+	// Test value in range
+	result := filter(Right[error](50))
+	assert.Equal(t, Right[error](50), result)
+
+	// Test value below range
+	result = filter(Right[error](5))
+	assert.True(t, IsLeft(result))
+
+	// Test value above range
+	result = filter(Right[error](150))
+	assert.True(t, IsLeft(result))
+
+	// Test boundary values
+	result = filter(Right[error](10))
+	assert.Equal(t, Right[error](10), result)
+
+	result = filter(Right[error](100))
+	assert.Equal(t, Right[error](100), result)
+}
+
+func TestFilterOrElse_ChainedFilters(t *testing.T) {
+	// Test chaining multiple filters
+	isPositive := N.MoreThan(0)
+	onNegative := func(x int) error { return fmt.Errorf("%d is not positive", x) }
+
+	isEven := func(x int) bool { return x%2 == 0 }
+	onOdd := func(x int) error { return fmt.Errorf("%d is not even", x) }
+
+	filterPositive := FilterOrElse(isPositive, onNegative)
+	filterEven := FilterOrElse(isEven, onOdd)
+
+	// Test value that passes both filters
+	result := filterEven(filterPositive(Right[error](4)))
+	assert.Equal(t, Right[error](4), result)
+
+	// Test value that fails first filter
+	result = filterEven(filterPositive(Right[error](-2)))
+	assert.True(t, IsLeft(result))
+
+	// Test value that passes first but fails second filter
+	result = filterEven(filterPositive(Right[error](3)))
+	assert.True(t, IsLeft(result))
+}
+
+func TestFilterOrElse_WithStructs(t *testing.T) {
+	type User struct {
+		Name string
+		Age  int
+	}
+
+	// Test with struct validation
+	isAdult := func(u User) bool { return u.Age >= 18 }
+	onMinor := func(u User) error { return fmt.Errorf("%s is not an adult (age: %d)", u.Name, u.Age) }
+	filter := FilterOrElse(isAdult, onMinor)
+
+	// Test adult user
+	adult := User{Name: "Alice", Age: 25}
+	result := filter(Right[error](adult))
+	assert.Equal(t, Right[error](adult), result)
+
+	// Test minor user
+	minor := User{Name: "Bob", Age: 16}
+	result = filter(Right[error](minor))
+	assert.True(t, IsLeft(result))
+}

v2/either/format.go

@@ -0,0 +1,103 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"fmt"
+	"log/slog"
+
+	"github.com/IBM/fp-go/v2/internal/formatting"
+)
+
+const (
+	leftGoTemplate  = "either.Left[%s](%#v)"
+	rightGoTemplate = "either.Right[%s](%#v)"
+
+	leftFmtTemplate  = "Left[%T](%v)"
+	rightFmtTemplate = "Right[%T](%v)"
+)
+
+func goString(template string, other, v any) string {
+	return fmt.Sprintf(template, formatting.TypeInfo(other), v)
+}
+
+// String prints some debug info for the object
+//
+//go:noinline
+func (s Either[E, A]) String() string {
+	if !s.isLeft {
+		return fmt.Sprintf(rightFmtTemplate, s.r, s.r)
+	}
+	return fmt.Sprintf(leftFmtTemplate, s.l, s.l)
+}
+
+// Format implements fmt.Formatter for Either.
+// Supports all standard format verbs:
+//   - %s, %v, %+v: uses String() representation
+//   - %#v: uses GoString() representation
+//   - %q: quoted String() representation
+//   - other verbs: uses String() representation
+//
+// Example:
+//
+//	e := either.Right[error](42)
+//	fmt.Printf("%s", e)   // "Right[int](42)"
+//	fmt.Printf("%v", e)   // "Right[int](42)"
+//	fmt.Printf("%#v", e)  // "either.Right[error](42)"
+//
+//go:noinline
+func (s Either[E, A]) Format(f fmt.State, c rune) {
+	formatting.FmtString(s, f, c)
+}
+
+// GoString implements fmt.GoStringer for Either.
+// Returns a Go-syntax representation of the Either value.
+//
+// Example:
+//
+//	either.Right[error](42).GoString() // "either.Right[error](42)"
+//	either.Left[int](errors.New("fail")).GoString() // "either.Left[int](error)"
+//
+//go:noinline
+func (s Either[E, A]) GoString() string {
+	if !s.isLeft {
+		return goString(rightGoTemplate, new(E), s.r)
+	}
+	return goString(leftGoTemplate, new(A), s.l)
+}
+
+// LogValue implements slog.LogValuer for Either.
+// Returns a slog.Value that represents the Either for structured logging.
+// Returns a group value with "right" key for Right values and "left" key for Left values.
+//
+// Example:
+//
+//	logger := slog.Default()
+//	result := either.Right[error](42)
+//	logger.Info("result", "value", result)
+//	// Logs: {"msg":"result","value":{"right":42}}
+//
+//	err := either.Left[int](errors.New("failed"))
+//	logger.Error("error", "value", err)
+//	// Logs: {"msg":"error","value":{"left":"failed"}}
+//
+//go:noinline
+func (s Either[E, A]) LogValue() slog.Value {
+	if !s.isLeft {
+		return slog.GroupValue(slog.Any("right", s.r))
+	}
+	return slog.GroupValue(slog.Any("left", s.l))
+}

v2/either/format_test.go

@@ -0,0 +1,311 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log/slog"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestString(t *testing.T) {
+	t.Run("Right value", func(t *testing.T) {
+		e := Right[error](42)
+		result := e.String()
+		assert.Equal(t, "Right[int](42)", result)
+	})
+
+	t.Run("Left value", func(t *testing.T) {
+		e := Left[int](errors.New("test error"))
+		result := e.String()
+		assert.Contains(t, result, "Left[*errors.errorString]")
+		assert.Contains(t, result, "test error")
+	})
+
+	t.Run("Right with string", func(t *testing.T) {
+		e := Right[error]("hello")
+		result := e.String()
+		assert.Equal(t, "Right[string](hello)", result)
+	})
+
+	t.Run("Left with string", func(t *testing.T) {
+		e := Left[int]("error message")
+		result := e.String()
+		assert.Equal(t, "Left[string](error message)", result)
+	})
+}
+
+func TestGoString(t *testing.T) {
+	t.Run("Right value", func(t *testing.T) {
+		e := Right[error](42)
+		result := e.GoString()
+		assert.Contains(t, result, "either.Right")
+		assert.Contains(t, result, "42")
+	})
+
+	t.Run("Left value", func(t *testing.T) {
+		e := Left[int](errors.New("test error"))
+		result := e.GoString()
+		assert.Contains(t, result, "either.Left")
+		assert.Contains(t, result, "test error")
+	})
+
+	t.Run("Right with struct", func(t *testing.T) {
+		type TestStruct struct {
+			Name string
+			Age  int
+		}
+		e := Right[error](TestStruct{Name: "Alice", Age: 30})
+		result := e.GoString()
+		assert.Contains(t, result, "either.Right")
+		assert.Contains(t, result, "Alice")
+		assert.Contains(t, result, "30")
+	})
+
+	t.Run("Left with custom error", func(t *testing.T) {
+		e := Left[string]("custom error")
+		result := e.GoString()
+		assert.Contains(t, result, "either.Left")
+		assert.Contains(t, result, "custom error")
+	})
+}
+
+func TestFormatInterface(t *testing.T) {
+	t.Run("Right value with %s", func(t *testing.T) {
+		e := Right[error](42)
+		result := fmt.Sprintf("%s", e)
+		assert.Equal(t, "Right[int](42)", result)
+	})
+
+	t.Run("Left value with %s", func(t *testing.T) {
+		e := Left[int](errors.New("test error"))
+		result := fmt.Sprintf("%s", e)
+		assert.Contains(t, result, "Left")
+		assert.Contains(t, result, "test error")
+	})
+
+	t.Run("Right value with %v", func(t *testing.T) {
+		e := Right[error](42)
+		result := fmt.Sprintf("%v", e)
+		assert.Equal(t, "Right[int](42)", result)
+	})
+
+	t.Run("Left value with %v", func(t *testing.T) {
+		e := Left[int]("error")
+		result := fmt.Sprintf("%v", e)
+		assert.Equal(t, "Left[string](error)", result)
+	})
+
+	t.Run("Right value with %+v", func(t *testing.T) {
+		e := Right[error](42)
+		result := fmt.Sprintf("%+v", e)
+		assert.Contains(t, result, "Right")
+		assert.Contains(t, result, "42")
+	})
+
+	t.Run("Right value with %#v (GoString)", func(t *testing.T) {
+		e := Right[error](42)
+		result := fmt.Sprintf("%#v", e)
+		assert.Contains(t, result, "either.Right")
+		assert.Contains(t, result, "42")
+	})
+
+	t.Run("Left value with %#v (GoString)", func(t *testing.T) {
+		e := Left[int]("error")
+		result := fmt.Sprintf("%#v", e)
+		assert.Contains(t, result, "either.Left")
+		assert.Contains(t, result, "error")
+	})
+
+	t.Run("Right value with %q", func(t *testing.T) {
+		e := Right[error]("hello")
+		result := fmt.Sprintf("%q", e)
+		// Should use String() representation
+		assert.Contains(t, result, "Right")
+	})
+
+	t.Run("Right value with %T", func(t *testing.T) {
+		e := Right[error](42)
+		result := fmt.Sprintf("%T", e)
+		assert.Contains(t, result, "either.Either")
+	})
+}
+
+func TestLogValue(t *testing.T) {
+	t.Run("Right value", func(t *testing.T) {
+		e := Right[error](42)
+		logValue := e.LogValue()
+
+		// Should be a group value
+		assert.Equal(t, slog.KindGroup, logValue.Kind())
+
+		// Extract the group attributes
+		attrs := logValue.Group()
+		assert.Len(t, attrs, 1)
+		assert.Equal(t, "right", attrs[0].Key)
+		assert.Equal(t, int64(42), attrs[0].Value.Any())
+	})
+
+	t.Run("Left value", func(t *testing.T) {
+		e := Left[int](errors.New("test error"))
+		logValue := e.LogValue()
+
+		// Should be a group value
+		assert.Equal(t, slog.KindGroup, logValue.Kind())
+
+		// Extract the group attributes
+		attrs := logValue.Group()
+		assert.Len(t, attrs, 1)
+		assert.Equal(t, "left", attrs[0].Key)
+		assert.NotNil(t, attrs[0].Value.Any())
+	})
+
+	t.Run("Right with string", func(t *testing.T) {
+		e := Right[error]("success")
+		logValue := e.LogValue()
+
+		// Should be a group value
+		assert.Equal(t, slog.KindGroup, logValue.Kind())
+
+		// Extract the group attributes
+		attrs := logValue.Group()
+		assert.Len(t, attrs, 1)
+		assert.Equal(t, "right", attrs[0].Key)
+		assert.Equal(t, "success", attrs[0].Value.Any())
+	})
+
+	t.Run("Left with string", func(t *testing.T) {
+		e := Left[int]("error message")
+		logValue := e.LogValue()
+
+		// Should be a group value
+		assert.Equal(t, slog.KindGroup, logValue.Kind())
+
+		// Extract the group attributes
+		attrs := logValue.Group()
+		assert.Len(t, attrs, 1)
+		assert.Equal(t, "left", attrs[0].Key)
+		assert.Equal(t, "error message", attrs[0].Value.Any())
+	})
+
+	t.Run("Integration with slog - Right", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := slog.New(slog.NewJSONHandler(&buf, &slog.HandlerOptions{
+			Level: slog.LevelInfo,
+		}))
+
+		e := Right[error](42)
+		logger.Info("test message", "result", e)
+
+		output := buf.String()
+		assert.Contains(t, output, "test message")
+		assert.Contains(t, output, "result")
+		assert.Contains(t, output, "right")
+		assert.Contains(t, output, "42")
+	})
+
+	t.Run("Integration with slog - Left", func(t *testing.T) {
+		var buf bytes.Buffer
+		logger := slog.New(slog.NewJSONHandler(&buf, &slog.HandlerOptions{
+			Level: slog.LevelInfo,
+		}))
+
+		e := Left[int]("error occurred")
+		logger.Info("test message", "result", e)
+
+		output := buf.String()
+		assert.Contains(t, output, "test message")
+		assert.Contains(t, output, "result")
+		assert.Contains(t, output, "left")
+		assert.Contains(t, output, "error occurred")
+	})
+}
+
+func TestFormatComprehensive(t *testing.T) {
+	t.Run("All format verbs for Right", func(t *testing.T) {
+		e := Right[error](42)
+
+		tests := []struct {
+			verb     string
+			contains []string
+		}{
+			{"%s", []string{"Right", "42"}},
+			{"%v", []string{"Right", "42"}},
+			{"%+v", []string{"Right", "42"}},
+			{"%#v", []string{"either.Right", "42"}},
+			{"%T", []string{"either.Either"}},
+		}
+
+		for _, tt := range tests {
+			t.Run(tt.verb, func(t *testing.T) {
+				result := fmt.Sprintf(tt.verb, e)
+				for _, substr := range tt.contains {
+					assert.Contains(t, result, substr, "Format %s should contain %s", tt.verb, substr)
+				}
+			})
+		}
+	})
+
+	t.Run("All format verbs for Left", func(t *testing.T) {
+		e := Left[int]("error")
+
+		tests := []struct {
+			verb     string
+			contains []string
+		}{
+			{"%s", []string{"Left", "error"}},
+			{"%v", []string{"Left", "error"}},
+			{"%+v", []string{"Left", "error"}},
+			{"%#v", []string{"either.Left", "error"}},
+			{"%T", []string{"either.Either"}},
+		}
+
+		for _, tt := range tests {
+			t.Run(tt.verb, func(t *testing.T) {
+				result := fmt.Sprintf(tt.verb, e)
+				for _, substr := range tt.contains {
+					assert.Contains(t, result, substr, "Format %s should contain %s", tt.verb, substr)
+				}
+			})
+		}
+	})
+}
+
+func TestInterfaceImplementations(t *testing.T) {
+	t.Run("fmt.Stringer interface", func(t *testing.T) {
+		var _ fmt.Stringer = Right[error](42)
+		var _ fmt.Stringer = Left[int](errors.New("error"))
+	})
+
+	t.Run("fmt.GoStringer interface", func(t *testing.T) {
+		var _ fmt.GoStringer = Right[error](42)
+		var _ fmt.GoStringer = Left[int](errors.New("error"))
+	})
+
+	t.Run("fmt.Formatter interface", func(t *testing.T) {
+		var _ fmt.Formatter = Right[error](42)
+		var _ fmt.Formatter = Left[int](errors.New("error"))
+	})
+
+	t.Run("slog.LogValuer interface", func(t *testing.T) {
+		var _ slog.LogValuer = Right[error](42)
+		var _ slog.LogValuer = Left[int](errors.New("error"))
+	})
+}

v2/either/logger.go

@@ -17,11 +17,19 @@ package either
 
 import (
 	"log"
+	"log/slog"
 
 	F "github.com/IBM/fp-go/v2/function"
 	L "github.com/IBM/fp-go/v2/logging"
 )
 
+var (
+	// slogError creates a slog.Attr with key "error" for logging error values
+	slogError = F.Bind1st(slog.Any, "error")
+	// slogValue creates a slog.Attr with key "value" for logging success values
+	slogValue = F.Bind1st(slog.Any, "value")
+)
+
 func _log[E, A any](left func(string, ...any), right func(string, ...any), prefix string) Operator[E, A, A] {
 	return Fold(
 		func(e E) Either[E, A] {
@@ -62,3 +70,91 @@ func Logger[E, A any](loggers ...*log.Logger) func(string) Operator[E, A, A] {
 		}
 	}
 }
+
+// ToSLogAttr converts an Either value to a structured logging attribute (slog.Attr).
+//
+// This function creates a converter that transforms Either values into slog.Attr for use
+// with Go's structured logging (log/slog). It maps:
+//   - Left values to an "error" attribute
+//   - Right values to a "value" attribute
+//
+// This is particularly useful when integrating Either-based error handling with structured
+// logging systems, allowing you to log both successful values and errors in a consistent,
+// structured format.
+//
+// Type Parameters:
+//   - E: The Left (error) type of the Either
+//   - A: The Right (success) type of the Either
+//
+// Returns:
+//   - A function that converts Either[E, A] to slog.Attr
+//
+// Example with Left (error):
+//
+//	converter := either.ToSLogAttr[error, int]()
+//	leftValue := either.Left[int](errors.New("connection failed"))
+//	attr := converter(leftValue)
+//	// attr is: slog.Any("error", errors.New("connection failed"))
+//
+//	logger.LogAttrs(ctx, slog.LevelError, "Operation failed", attr)
+//	// Logs: {"level":"error","msg":"Operation failed","error":"connection failed"}
+//
+// Example with Right (success):
+//
+//	converter := either.ToSLogAttr[error, User]()
+//	rightValue := either.Right[error](User{ID: 123, Name: "Alice"})
+//	attr := converter(rightValue)
+//	// attr is: slog.Any("value", User{ID: 123, Name: "Alice"})
+//
+//	logger.LogAttrs(ctx, slog.LevelInfo, "User fetched", attr)
+//	// Logs: {"level":"info","msg":"User fetched","value":{"ID":123,"Name":"Alice"}}
+//
+// Example in a pipeline with structured logging:
+//
+//	toAttr := either.ToSLogAttr[error, Data]()
+//
+//	result := F.Pipe2(
+//	    fetchData(id),
+//	    either.Map(processData),
+//	    either.Map(validateData),
+//	)
+//
+//	attr := toAttr(result)
+//	logger.LogAttrs(ctx, slog.LevelInfo, "Data processing complete", attr)
+//	// Logs success: {"level":"info","msg":"Data processing complete","value":{...}}
+//	// Or error: {"level":"info","msg":"Data processing complete","error":"validation failed"}
+//
+// Example with custom log levels based on Either:
+//
+//	toAttr := either.ToSLogAttr[error, Response]()
+//	result := callAPI(endpoint)
+//
+//	level := either.Fold(
+//	    func(error) slog.Level { return slog.LevelError },
+//	    func(Response) slog.Level { return slog.LevelInfo },
+//	)(result)
+//
+//	logger.LogAttrs(ctx, level, "API call completed", toAttr(result))
+//
+// Use Cases:
+//   - Structured logging: Convert Either results to structured log attributes
+//   - Error tracking: Log errors with consistent "error" key in structured logs
+//   - Success monitoring: Log successful values with consistent "value" key
+//   - Observability: Integrate Either-based error handling with logging systems
+//   - Debugging: Inspect Either values in logs with proper structure
+//   - Metrics: Extract Either values for metrics collection in logging pipelines
+//
+// Note: The returned slog.Attr uses "error" for Left values and "value" for Right values.
+// These keys are consistent with common structured logging conventions.
+func ToSLogAttr[E, A any]() func(Either[E, A]) slog.Attr {
+	return Fold(
+		F.Flow2(
+			F.ToAny[E],
+			slogError,
+		),
+		F.Flow2(
+			F.ToAny[A],
+			slogValue,
+		),
+	)
+}

v2/either/logger_test.go

@@ -16,9 +16,12 @@
 package either
 
 import (
+	"errors"
+	"log/slog"
 	"testing"
 
 	F "github.com/IBM/fp-go/v2/function"
+	N "github.com/IBM/fp-go/v2/number"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -35,3 +38,139 @@ func TestLogger(t *testing.T) {
 
 	assert.Equal(t, r, res)
 }
+
+func TestToSLogAttr_Left(t *testing.T) {
+	// Test with Left (error) value
+	converter := ToSLogAttr[error, int]()
+	testErr := errors.New("test error")
+	leftValue := Left[int](testErr)
+
+	attr := converter(leftValue)
+
+	// Verify the attribute has the correct key
+	assert.Equal(t, "error", attr.Key)
+	// Verify the attribute value is the error
+	assert.Equal(t, testErr, attr.Value.Any())
+}
+
+func TestToSLogAttr_Right(t *testing.T) {
+	// Test with Right (success) value
+	converter := ToSLogAttr[error, string]()
+	rightValue := Right[error]("success value")
+
+	attr := converter(rightValue)
+
+	// Verify the attribute has the correct key
+	assert.Equal(t, "value", attr.Key)
+	// Verify the attribute value is the success value
+	assert.Equal(t, "success value", attr.Value.Any())
+}
+
+func TestToSLogAttr_LeftWithCustomType(t *testing.T) {
+	// Test with custom error type
+	type CustomError struct {
+		Code    int
+		Message string
+	}
+
+	converter := ToSLogAttr[CustomError, string]()
+	customErr := CustomError{Code: 404, Message: "not found"}
+	leftValue := Left[string](customErr)
+
+	attr := converter(leftValue)
+
+	assert.Equal(t, "error", attr.Key)
+	assert.Equal(t, customErr, attr.Value.Any())
+}
+
+func TestToSLogAttr_RightWithCustomType(t *testing.T) {
+	// Test with custom success type
+	type User struct {
+		ID   int
+		Name string
+	}
+
+	converter := ToSLogAttr[error, User]()
+	user := User{ID: 123, Name: "Alice"}
+	rightValue := Right[error](user)
+
+	attr := converter(rightValue)
+
+	assert.Equal(t, "value", attr.Key)
+	assert.Equal(t, user, attr.Value.Any())
+}
+
+func TestToSLogAttr_InPipeline(t *testing.T) {
+	// Test ToSLogAttr in a functional pipeline
+	converter := ToSLogAttr[error, int]()
+
+	// Test with successful pipeline
+	successResult := F.Pipe2(
+		Right[error](10),
+		Map[error](N.Mul(2)),
+		converter,
+	)
+
+	assert.Equal(t, "value", successResult.Key)
+	// slog.Any converts int to int64
+	assert.Equal(t, int64(20), successResult.Value.Any())
+
+	// Test with failed pipeline
+	testErr := errors.New("computation failed")
+	failureResult := F.Pipe2(
+		Left[int](testErr),
+		Map[error](N.Mul(2)),
+		converter,
+	)
+
+	assert.Equal(t, "error", failureResult.Key)
+	assert.Equal(t, testErr, failureResult.Value.Any())
+}
+
+func TestToSLogAttr_WithNilError(t *testing.T) {
+	// Test with nil error (edge case)
+	converter := ToSLogAttr[error, string]()
+	var nilErr error = nil
+	leftValue := Left[string](nilErr)
+
+	attr := converter(leftValue)
+
+	assert.Equal(t, "error", attr.Key)
+	assert.Nil(t, attr.Value.Any())
+}
+
+func TestToSLogAttr_WithZeroValue(t *testing.T) {
+	// Test with zero value of success type
+	converter := ToSLogAttr[error, int]()
+	rightValue := Right[error](0)
+
+	attr := converter(rightValue)
+
+	assert.Equal(t, "value", attr.Key)
+	// slog.Any converts int to int64
+	assert.Equal(t, int64(0), attr.Value.Any())
+}
+
+func TestToSLogAttr_WithEmptyString(t *testing.T) {
+	// Test with empty string as success value
+	converter := ToSLogAttr[error, string]()
+	rightValue := Right[error]("")
+
+	attr := converter(rightValue)
+
+	assert.Equal(t, "value", attr.Key)
+	assert.Equal(t, "", attr.Value.Any())
+}
+
+func TestToSLogAttr_AttributeKind(t *testing.T) {
+	// Verify that the returned attribute has the correct Kind
+	converter := ToSLogAttr[error, string]()
+
+	leftAttr := converter(Left[string](errors.New("error")))
+	// Errors are stored as KindAny (which has value 0)
+	assert.Equal(t, slog.KindAny, leftAttr.Value.Kind())
+
+	rightAttr := converter(Right[error]("value"))
+	// Strings have KindString
+	assert.Equal(t, slog.KindString, rightAttr.Value.Kind())
+}

v2/either/rec.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"github.com/IBM/fp-go/v2/tailrec"
+)
+
+//go:inline
+func TailRec[E, A, B any](f Kleisli[E, A, tailrec.Trampoline[A, B]]) Kleisli[E, A, B] {
+	return func(a A) Either[E, B] {
+		current := f(a)
+		for {
+			rec, e := Unwrap(current)
+			if IsLeft(current) {
+				return Left[B](e)
+			}
+			if rec.Landed {
+				return Right[E](rec.Land)
+			}
+			current = f(rec.Bounce)
+		}
+	}
+}

v2/either/testing/laws.go

@@ -48,7 +48,7 @@ import (
 //	    eqError := eq.FromStrictEquals[error]()
 //
 //	    ab := strconv.Itoa
-//	    bc := func(s string) bool { return len(s) > 0 }
+//	    bc := S.IsNonEmpty
 //
 //	    testing.AssertLaws(t, eqError, eqInt, eqString, eq.FromStrictEquals[bool](), ab, bc)(42)
 //	}

v2/either/types.go

@@ -21,18 +21,36 @@ import (
 	"github.com/IBM/fp-go/v2/monoid"
 	"github.com/IBM/fp-go/v2/optics/lens"
 	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 )
 
-// Option is a type alias for option.Option, provided for convenience
-// when working with Either and Option together.
 type (
-	Option[A any]       = option.Option[A]
-	Lens[S, T any]      = lens.Lens[S, T]
-	Endomorphism[T any] = endomorphism.Endomorphism[T]
-	Lazy[T any]         = lazy.Lazy[T]
+	// Option is a type alias for option.Option, provided for convenience
+	// when working with Either and Option together.
+	Option[A any] = option.Option[A]
 
-	Kleisli[E, A, B any]  = reader.Reader[A, Either[E, B]]
+	// Lens is an optic that focuses on a field of type T within a structure of type S.
+	Lens[S, T any] = lens.Lens[S, T]
+
+	// Endomorphism represents a function from a type to itself (T -> T).
+	Endomorphism[T any] = endomorphism.Endomorphism[T]
+
+	// Lazy represents a deferred computation that produces a value of type T.
+	Lazy[T any] = lazy.Lazy[T]
+
+	// Kleisli represents a Kleisli arrow for the Either monad.
+	// It's a function from A to Either[E, B], used for composing operations that may fail.
+	Kleisli[E, A, B any] = reader.Reader[A, Either[E, B]]
+
+	// Operator represents a function that transforms one Either into another.
+	// It takes an Either[E, A] and produces an Either[E, B].
 	Operator[E, A, B any] = Kleisli[E, Either[E, A], B]
-	Monoid[E, A any]      = monoid.Monoid[Either[E, A]]
+
+	// Monoid represents a monoid structure for Either values.
+	Monoid[E, A any] = monoid.Monoid[Either[E, A]]
+
+	// Predicate represents a function that tests a value of type A and returns a boolean.
+	// It's commonly used for filtering and conditional operations.
+	Predicate[A any] = predicate.Predicate[A]
 )

v2/endomorphism/endo.go

@@ -41,7 +41,7 @@ import (
 //	increment := N.Add(1)
 //	result := endomorphism.MonadAp(double, increment) // Composes: double ∘ increment
 //	// result(5) = double(increment(5)) = double(6) = 12
-func MonadAp[A any](fab Endomorphism[A], fa Endomorphism[A]) Endomorphism[A] {
+func MonadAp[A any](fab, fa Endomorphism[A]) Endomorphism[A] {
 	return MonadCompose(fab, fa)
 }
 
@@ -225,7 +225,7 @@ func Map[A any](f Endomorphism[A]) Operator[A] {
 //	// Compare with MonadCompose which executes RIGHT-TO-LEFT:
 //	composed := endomorphism.MonadCompose(increment, double)
 //	result2 := composed(5) // (5 * 2) + 1 = 11 (same result, different parameter order)
-func MonadChain[A any](ma Endomorphism[A], f Endomorphism[A]) Endomorphism[A] {
+func MonadChain[A any](ma, f Endomorphism[A]) Endomorphism[A] {
 	return function.Flow2(ma, f)
 }
 
@@ -247,7 +247,7 @@ func MonadChain[A any](ma Endomorphism[A], f Endomorphism[A]) Endomorphism[A] {
 //	log := func(x int) int { fmt.Println(x); return x }
 //	chained := endomorphism.MonadChainFirst(double, log)
 //	result := chained(5) // Prints 10, returns 10
-func MonadChainFirst[A any](ma Endomorphism[A], f Endomorphism[A]) Endomorphism[A] {
+func MonadChainFirst[A any](ma, f Endomorphism[A]) Endomorphism[A] {
 	return func(a A) A {
 		result := ma(a)
 		f(result)     // Apply f for its effect

v2/endomorphism/types.go

@@ -37,6 +37,8 @@ type (
 	//	var g endomorphism.Endomorphism[int] = increment
 	Endomorphism[A any] = func(A) A
 
+	// Kleisli represents a Kleisli arrow for endomorphisms.
+	// It's a function from A to Endomorphism[A], used for composing endomorphic operations.
 	Kleisli[A any] = func(A) Endomorphism[A]
 
 	// Operator represents a transformation from one endomorphism to another.

v2/eq/eq_test.go

@@ -72,9 +72,7 @@ func TestFromStrictEquals(t *testing.T) {
 
 func TestFromEquals(t *testing.T) {
 	t.Run("case-insensitive string equality", func(t *testing.T) {
-		caseInsensitiveEq := FromEquals(func(a, b string) bool {
-			return strings.EqualFold(a, b)
-		})
+		caseInsensitiveEq := FromEquals(strings.EqualFold)
 
 		assert.True(t, caseInsensitiveEq.Equals("hello", "HELLO"))
 		assert.True(t, caseInsensitiveEq.Equals("Hello", "hello"))
@@ -243,9 +241,7 @@ func TestContramap(t *testing.T) {
 	})
 
 	t.Run("case-insensitive name comparison", func(t *testing.T) {
-		caseInsensitiveEq := FromEquals(func(a, b string) bool {
-			return strings.EqualFold(a, b)
-		})
+		caseInsensitiveEq := FromEquals(strings.EqualFold)
 
 		personEqByNameCI := Contramap(func(p Person) string {
 			return p.Name

v2/function/doc.go

@@ -129,7 +129,7 @@
 //
 // Working with predicates:
 //
-//	isPositive := func(n int) bool { return n > 0 }
+//	isPositive := N.MoreThan(0)
 //	isEven := func(n int) bool { return n%2 == 0 }
 //
 //	classify := Ternary(

v2/function/function.go

@@ -53,7 +53,10 @@ func Identity[A any](a A) A {
 //
 //	getMessage := Constant("Hello")
 //	msg := getMessage()  // "Hello"
+//
+//go:inline
 func Constant[A any](a A) func() A {
+	//go:inline
 	return func() A {
 		return a
 	}
@@ -81,7 +84,10 @@ func Constant[A any](a A) func() A {
 //
 //	defaultName := Constant1[int, string]("Unknown")
 //	name := defaultName(42)  // "Unknown"
+//
+//go:inline
 func Constant1[B, A any](a A) func(B) A {
+	//go:inline
 	return func(_ B) A {
 		return a
 	}
@@ -107,7 +113,10 @@ func Constant1[B, A any](a A) func(B) A {
 //
 //	alwaysTrue := Constant2[int, string, bool](true)
 //	result := alwaysTrue(42, "test")  // true
+//
+//go:inline
 func Constant2[B, C, A any](a A) func(B, C) A {
+	//go:inline
 	return func(_ B, _ C) A {
 		return a
 	}
@@ -128,6 +137,8 @@ func Constant2[B, C, A any](a A) func(B, C) A {
 //
 //	value := 42
 //	IsNil(&value)  // false
+//
+//go:inline
 func IsNil[A any](a *A) bool {
 	return a == nil
 }
@@ -149,6 +160,8 @@ func IsNil[A any](a *A) bool {
 //
 //	value := 42
 //	IsNonNil(&value)  // true
+//
+//go:inline
 func IsNonNil[A any](a *A) bool {
 	return a != nil
 }
@@ -207,6 +220,8 @@ func Swap[T1, T2, R any](f func(T1, T2) R) func(T2, T1) R {
 //
 //	result := First(42, "hello")  // 42
 //	result := First(true, 100)    // true
+//
+//go:inline
 func First[T1, T2 any](t1 T1, _ T2) T1 {
 	return t1
 }
@@ -231,6 +246,14 @@ func First[T1, T2 any](t1 T1, _ T2) T1 {
 //
 //	result := Second(42, "hello")  // "hello"
 //	result := Second(true, 100)    // 100
+//
+//go:inline
 func Second[T1, T2 any](_ T1, t2 T2) T2 {
 	return t2
 }
+
+// Zero returns the zero value of the given type.
+func Zero[A comparable]() A {
+	var zero A
+	return zero
+}