fix: add filterable to Either and Result

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>

v2/array/array.go

@@ -21,7 +21,7 @@ import (
 	"github.com/IBM/fp-go/v2/internal/array"
 	M "github.com/IBM/fp-go/v2/monoid"
 	"github.com/IBM/fp-go/v2/option"
-	"github.com/IBM/fp-go/v2/tuple"
+	"github.com/IBM/fp-go/v2/pair"
 )
 
 // From constructs an array from a set of variadic arguments
@@ -163,11 +163,11 @@ func FilterMapWithIndex[A, B any](f func(int, A) Option[B]) Operator[A, B] {
 	return G.FilterMapWithIndex[[]A, []B](f)
 }
 
-// FilterChain maps an array with an iterating function that returns an [Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
+// ChainOptionK maps an array with an iterating function that returns an [Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
 //
 //go:inline
-func FilterChain[A, B any](f option.Kleisli[A, []B]) Operator[A, B] {
-	return G.FilterChain[[]A](f)
+func ChainOptionK[A, B any](f option.Kleisli[A, []B]) Operator[A, B] {
+	return G.ChainOptionK[[]A](f)
 }
 
 // FilterMapRef filters an array using a predicate on pointers and maps the matching elements using a function on pointers.
@@ -453,7 +453,7 @@ func Size[A any](as []A) int {
 // the second contains elements for which it returns true.
 //
 //go:inline
-func MonadPartition[A any](as []A, pred func(A) bool) tuple.Tuple2[[]A, []A] {
+func MonadPartition[A any](as []A, pred func(A) bool) pair.Pair[[]A, []A] {
 	return G.MonadPartition(as, pred)
 }
 
@@ -461,7 +461,7 @@ func MonadPartition[A any](as []A, pred func(A) bool) tuple.Tuple2[[]A, []A] {
 // for which the predicate returns false, the right one those for which the predicate returns true
 //
 //go:inline
-func Partition[A any](pred func(A) bool) func([]A) tuple.Tuple2[[]A, []A] {
+func Partition[A any](pred func(A) bool) func([]A) pair.Pair[[]A, []A] {
 	return G.Partition[[]A](pred)
 }
 

v2/array/array_test.go

@@ -24,8 +24,8 @@ import (
 	"github.com/IBM/fp-go/v2/internal/utils"
 	N "github.com/IBM/fp-go/v2/number"
 	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/pair"
 	S "github.com/IBM/fp-go/v2/string"
-	T "github.com/IBM/fp-go/v2/tuple"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -163,11 +163,11 @@ func TestPartition(t *testing.T) {
 		return n > 2
 	}
 
-	assert.Equal(t, T.MakeTuple2(Empty[int](), Empty[int]()), Partition(pred)(Empty[int]()))
-	assert.Equal(t, T.MakeTuple2(From(1), From(3)), Partition(pred)(From(1, 3)))
+	assert.Equal(t, pair.MakePair(Empty[int](), Empty[int]()), Partition(pred)(Empty[int]()))
+	assert.Equal(t, pair.MakePair(From(1), From(3)), Partition(pred)(From(1, 3)))
 }
 
-func TestFilterChain(t *testing.T) {
+func TestChainOptionK(t *testing.T) {
 	src := From(1, 2, 3)
 
 	f := func(i int) O.Option[[]string] {
@@ -177,7 +177,7 @@ func TestFilterChain(t *testing.T) {
 		return O.None[[]string]()
 	}
 
-	res := FilterChain(f)(src)
+	res := ChainOptionK(f)(src)
 
 	assert.Equal(t, From("a1", "b1", "a3", "b3"), res)
 }

v2/array/generic/array.go

@@ -21,7 +21,7 @@ import (
 	FC "github.com/IBM/fp-go/v2/internal/functor"
 	M "github.com/IBM/fp-go/v2/monoid"
 	O "github.com/IBM/fp-go/v2/option"
-	"github.com/IBM/fp-go/v2/tuple"
+	"github.com/IBM/fp-go/v2/pair"
 )
 
 // Of constructs a single element array
@@ -215,7 +215,7 @@ func Filter[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) AS {
 	return FilterWithIndex[AS](F.Ignore1of2[int](pred))
 }
 
-func FilterChain[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
+func ChainOptionK[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
 	return F.Flow2(
 		FilterMap[GA, []GB](f),
 		Flatten[[]GB],
@@ -234,7 +234,7 @@ func FilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) O.Option[B])
 	return F.Bind2nd(MonadFilterMapWithIndex[GA, GB, A, B], f)
 }
 
-func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) tuple.Tuple2[GA, GA] {
+func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) pair.Pair[GA, GA] {
 	left := Empty[GA]()
 	right := Empty[GA]()
 	array.Reduce(as, func(c bool, a A) bool {
@@ -246,10 +246,10 @@ func MonadPartition[GA ~[]A, A any](as GA, pred func(A) bool) tuple.Tuple2[GA, G
 		return c
 	}, true)
 	// returns the partition
-	return tuple.MakeTuple2(left, right)
+	return pair.MakePair(left, right)
 }
 
-func Partition[GA ~[]A, A any](pred func(A) bool) func(GA) tuple.Tuple2[GA, GA] {
+func Partition[GA ~[]A, A any](pred func(A) bool) func(GA) pair.Pair[GA, GA] {
 	return F.Bind2nd(MonadPartition[GA, A], pred)
 }
 

v2/array/generic/zip.go

@@ -18,7 +18,7 @@ package generic
 import (
 	F "github.com/IBM/fp-go/v2/function"
 	N "github.com/IBM/fp-go/v2/number"
-	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/IBM/fp-go/v2/pair"
 )
 
 // ZipWith applies a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
@@ -34,19 +34,19 @@ func ZipWith[AS ~[]A, BS ~[]B, CS ~[]C, FCT ~func(A, B) C, A, B, C any](fa AS, f
 
 // Zip takes two arrays and returns an array of corresponding pairs. If one input array is short, excess elements of the
 // longer array are discarded
-func Zip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](fb BS) func(AS) CS {
-	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) T.Tuple2[A, B]])(fb, T.MakeTuple2[A, B])
+func Zip[AS ~[]A, BS ~[]B, CS ~[]pair.Pair[A, B], A, B any](fb BS) func(AS) CS {
+	return F.Bind23of3(ZipWith[AS, BS, CS, func(A, B) pair.Pair[A, B]])(fb, pair.MakePair[A, B])
 }
 
 // Unzip is the function is reverse of [Zip]. Takes an array of pairs and return two corresponding arrays
-func Unzip[AS ~[]A, BS ~[]B, CS ~[]T.Tuple2[A, B], A, B any](cs CS) T.Tuple2[AS, BS] {
+func Unzip[AS ~[]A, BS ~[]B, CS ~[]pair.Pair[A, B], A, B any](cs CS) pair.Pair[AS, BS] {
 	l := len(cs)
 	as := make(AS, l)
 	bs := make(BS, l)
 	for i := range l {
 		t := cs[i]
-		as[i] = t.F1
-		bs[i] = t.F2
+		as[i] = pair.Head(t)
+		bs[i] = pair.Tail(t)
 	}
-	return T.MakeTuple2(as, bs)
+	return pair.MakePair(as, bs)
 }

v2/array/zip.go

@@ -17,7 +17,7 @@ package array
 
 import (
 	G "github.com/IBM/fp-go/v2/array/generic"
-	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/IBM/fp-go/v2/pair"
 )
 
 // ZipWith applies a function to pairs of elements at the same index in two arrays,
@@ -55,8 +55,8 @@ func ZipWith[FCT ~func(A, B) C, A, B, C any](fa []A, fb []B, f FCT) []C {
 //	// Result: [(a, 1), (b, 2)]
 //
 //go:inline
-func Zip[A, B any](fb []B) func([]A) []T.Tuple2[A, B] {
-	return G.Zip[[]A, []B, []T.Tuple2[A, B]](fb)
+func Zip[A, B any](fb []B) func([]A) []pair.Pair[A, B] {
+	return G.Zip[[]A, []B, []pair.Pair[A, B]](fb)
 }
 
 // Unzip is the reverse of Zip. It takes an array of pairs (tuples) and returns
@@ -78,6 +78,6 @@ func Zip[A, B any](fb []B) func([]A) []T.Tuple2[A, B] {
 //	ages := result.Tail   // [30, 25, 35]
 //
 //go:inline
-func Unzip[A, B any](cs []T.Tuple2[A, B]) T.Tuple2[[]A, []B] {
+func Unzip[A, B any](cs []pair.Pair[A, B]) pair.Pair[[]A, []B] {
 	return G.Unzip[[]A, []B](cs)
 }

v2/array/zip_test.go

@@ -19,7 +19,7 @@ import (
 	"fmt"
 	"testing"
 
-	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/IBM/fp-go/v2/pair"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -40,7 +40,7 @@ func TestZip(t *testing.T) {
 
 	res := Zip[string](left)(right)
 
-	assert.Equal(t, From(T.MakeTuple2("a", 1), T.MakeTuple2("b", 2), T.MakeTuple2("c", 3)), res)
+	assert.Equal(t, From(pair.MakePair("a", 1), pair.MakePair("b", 2), pair.MakePair("c", 3)), res)
 }
 
 func TestUnzip(t *testing.T) {
@@ -51,6 +51,6 @@ func TestUnzip(t *testing.T) {
 
 	unzipped := Unzip(zipped)
 
-	assert.Equal(t, right, unzipped.F1)
-	assert.Equal(t, left, unzipped.F2)
+	assert.Equal(t, right, pair.Head(unzipped))
+	assert.Equal(t, left, pair.Tail(unzipped))
 }

v2/di/erasure/injector.go

@@ -87,8 +87,8 @@ var (
 	// assembleProviders constructs the provider map for item and non-item providers
 	assembleProviders = F.Flow3(
 		A.Partition(isItemProvider),
-		T.Map2(collectProviders, collectItemProviders),
-		T.Tupled2(mergeProviders.Concat),
+		pair.BiMap(collectProviders, collectItemProviders),
+		pair.Paired(mergeProviders.Concat),
 	)
 )
 

v2/either/filterable.go

@@ -0,0 +1,351 @@
+// 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 either provides implementations of the Either type and related operations.
+//
+// This package implements several Fantasy Land algebraic structures:
+//   - Filterable: https://github.com/fantasyland/fantasy-land#filterable
+//
+// The Filterable specification defines operations for filtering and partitioning
+// data structures based on predicates and mapping functions.
+package either
+
+import (
+	"github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/pair"
+)
+
+// Partition separates an [Either] value into a [Pair] based on a predicate function.
+// It returns a function that takes an Either and produces a Pair of Either values,
+// where the first element contains values that fail the predicate and the second
+// contains values that pass the predicate.
+//
+// This function implements the Filterable specification's partition operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is Left, both elements of the resulting Pair will be the same Left value
+//   - If the input is Right and the predicate returns true, the result is (Left(empty), Right(value))
+//   - If the input is Right and the predicate returns false, the result is (Right(value), Left(empty))
+//
+// This function is useful for separating Either values into two categories based on
+// a condition, commonly used in filtering operations where you want to keep track of
+// both the values that pass and fail a test.
+//
+// Parameters:
+//   - p: A predicate function that tests values of type A
+//   - empty: The default Left value to use when creating Left instances for partitioning
+//
+// Returns:
+//
+//	A function that takes an Either[E, A] and returns a Pair where:
+//	  - First element: Either values that fail the predicate (or original Left)
+//	  - Second element: Either values that pass the predicate (or original Left)
+//
+// Example:
+//
+//	import (
+//	    E "github.com/IBM/fp-go/v2/either"
+//	    N "github.com/IBM/fp-go/v2/number"
+//	    P "github.com/IBM/fp-go/v2/pair"
+//	)
+//
+//	// Partition positive and non-positive numbers
+//	isPositive := N.MoreThan(0)
+//	partition := E.Partition(isPositive, "not positive")
+//
+//	// Right value that passes predicate
+//	result1 := partition(E.Right[string](5))
+//	// result1 = Pair(Left("not positive"), Right(5))
+//	left1, right1 := P.Unpack(result1)
+//	// left1 = Left("not positive"), right1 = Right(5)
+//
+//	// Right value that fails predicate
+//	result2 := partition(E.Right[string](-3))
+//	// result2 = Pair(Right(-3), Left("not positive"))
+//	left2, right2 := P.Unpack(result2)
+//	// left2 = Right(-3), right2 = Left("not positive")
+//
+//	// Left value passes through unchanged in both positions
+//	result3 := partition(E.Left[int]("error"))
+//	// result3 = Pair(Left("error"), Left("error"))
+//	left3, right3 := P.Unpack(result3)
+//	// left3 = Left("error"), right3 = Left("error")
+func Partition[E, A any](p Predicate[A], empty E) func(Either[E, A]) Pair[Either[E, A], Either[E, A]] {
+	l := Left[A](empty)
+	return func(e Either[E, A]) Pair[Either[E, A], Either[E, A]] {
+		if e.isLeft {
+			return pair.Of(e)
+		}
+		if p(e.r) {
+			return pair.MakePair(l, e)
+		}
+		return pair.MakePair(e, l)
+	}
+}
+
+// Filter creates a filtering operation for [Either] values based on a predicate function.
+// It returns a function that takes an Either and produces an Either, where Right values
+// that fail the predicate are converted to Left values with the provided empty value.
+//
+// This function implements the Filterable specification's filter operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is Left, it passes through unchanged
+//   - If the input is Right and the predicate returns true, the Right value passes through unchanged
+//   - If the input is Right and the predicate returns false, it's converted to Left(empty)
+//
+// This function is useful for conditional validation or filtering of Either values,
+// where you want to reject Right values that don't meet certain criteria by converting
+// them to Left values with a default error.
+//
+// Parameters:
+//   - p: A predicate function that tests values of type A
+//   - empty: The default Left value to use when filtering out Right values that fail the predicate
+//
+// Returns:
+//
+//	An Operator function that takes an Either[E, A] and returns an Either[E, A] where:
+//	  - Left values pass through unchanged
+//	  - Right values that pass the predicate remain as Right
+//	  - Right values that fail the predicate become Left(empty)
+//
+// Example:
+//
+//	import (
+//	    E "github.com/IBM/fp-go/v2/either"
+//	    N "github.com/IBM/fp-go/v2/number"
+//	)
+//
+//	// Filter to keep only positive numbers
+//	isPositive := N.MoreThan(0)
+//	filterPositive := E.Filter(isPositive, "not positive")
+//
+//	// Right value that passes predicate - remains Right
+//	result1 := filterPositive(E.Right[string](5))
+//	// result1 = Right(5)
+//
+//	// Right value that fails predicate - becomes Left
+//	result2 := filterPositive(E.Right[string](-3))
+//	// result2 = Left("not positive")
+//
+//	// Left value passes through unchanged
+//	result3 := filterPositive(E.Left[int]("original error"))
+//	// result3 = Left("original error")
+//
+//	// Chaining filters
+//	isEven := func(n int) bool { return n%2 == 0 }
+//	filterEven := E.Filter(isEven, "not even")
+//
+//	// Apply multiple filters in sequence
+//	result4 := filterEven(filterPositive(E.Right[string](4)))
+//	// result4 = Right(4) - passes both filters
+//
+//	result5 := filterEven(filterPositive(E.Right[string](3)))
+//	// result5 = Left("not even") - passes first, fails second
+func Filter[E, A any](p Predicate[A], empty E) Operator[E, A, A] {
+	l := Left[A](empty)
+	return func(e Either[E, A]) Either[E, A] {
+		if e.isLeft || p(e.r) {
+			return e
+		}
+		return l
+	}
+}
+
+// FilterMap combines filtering and mapping operations for [Either] values using an [Option]-returning function.
+// It returns a function that takes an Either[E, A] and produces an Either[E, B], where Right values
+// are transformed by applying the function f. If f returns Some(B), the result is Right(B). If f returns
+// None, the result is Left(empty).
+//
+// This function implements the Filterable specification's filterMap operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is Left, it passes through with its error value preserved as Left[B]
+//   - If the input is Right and f returns Some(B), the result is Right(B)
+//   - If the input is Right and f returns None, the result is Left(empty)
+//
+// This function is useful for operations that combine validation/filtering with transformation,
+// such as parsing strings to numbers (where invalid strings result in None), or extracting
+// optional fields from structures.
+//
+// Parameters:
+//   - f: An Option Kleisli function that transforms values of type A to Option[B]
+//   - empty: The default Left value to use when f returns None
+//
+// Returns:
+//
+//	An Operator function that takes an Either[E, A] and returns an Either[E, B] where:
+//	  - Left values pass through with error preserved
+//	  - Right values are transformed by f: Some(B) becomes Right(B), None becomes Left(empty)
+//
+// Example:
+//
+//	import (
+//	    E "github.com/IBM/fp-go/v2/either"
+//	    O "github.com/IBM/fp-go/v2/option"
+//	    "strconv"
+//	)
+//
+//	// Parse string to int, filtering out invalid values
+//	parseInt := func(s string) O.Option[int] {
+//	    if n, err := strconv.Atoi(s); err == nil {
+//	        return O.Some(n)
+//	    }
+//	    return O.None[int]()
+//	}
+//	filterMapInt := E.FilterMap(parseInt, "invalid number")
+//
+//	// Valid number string - transforms to Right(int)
+//	result1 := filterMapInt(E.Right[string]("42"))
+//	// result1 = Right(42)
+//
+//	// Invalid number string - becomes Left
+//	result2 := filterMapInt(E.Right[string]("abc"))
+//	// result2 = Left("invalid number")
+//
+//	// Left value passes through with error preserved
+//	result3 := filterMapInt(E.Left[string]("original error"))
+//	// result3 = Left("original error")
+//
+//	// Extract optional field from struct
+//	type Person struct {
+//	    Name  string
+//	    Email O.Option[string]
+//	}
+//	extractEmail := func(p Person) O.Option[string] { return p.Email }
+//	filterMapEmail := E.FilterMap(extractEmail, "no email")
+//
+//	result4 := filterMapEmail(E.Right[string](Person{Name: "Alice", Email: O.Some("alice@example.com")}))
+//	// result4 = Right("alice@example.com")
+//
+//	result5 := filterMapEmail(E.Right[string](Person{Name: "Bob", Email: O.None[string]()}))
+//	// result5 = Left("no email")
+func FilterMap[E, A, B any](f option.Kleisli[A, B], empty E) Operator[E, A, B] {
+	l := Left[B](empty)
+	return func(e Either[E, A]) Either[E, B] {
+		if e.isLeft {
+			return Left[B](e.l)
+		}
+		if b, ok := option.Unwrap(f(e.r)); ok {
+			return Right[E](b)
+		}
+		return l
+	}
+}
+
+// PartitionMap separates and transforms an [Either] value into a [Pair] of Either values using a mapping function.
+// It returns a function that takes an Either[E, A] and produces a Pair of Either values, where the mapping
+// function f transforms the Right value into Either[B, C]. The result is partitioned based on whether f
+// produces a Left or Right value.
+//
+// This function implements the Filterable specification's partitionMap operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is Left, both elements of the resulting Pair will be Left with the original error
+//   - If the input is Right and f returns Left(B), the result is (Right(B), Left(empty))
+//   - If the input is Right and f returns Right(C), the result is (Left(empty), Right(C))
+//
+// This function is useful for operations that need to categorize and transform values simultaneously,
+// such as separating valid and invalid data while applying different transformations to each category.
+//
+// Parameters:
+//   - f: A Kleisli function that transforms values of type A to Either[B, C]
+//   - empty: The default error value to use when creating Left instances for partitioning
+//
+// Returns:
+//
+//	A function that takes an Either[E, A] and returns a Pair[Either[E, B], Either[E, C]] where:
+//	  - If input is Left: (Left(original_error), Left(original_error))
+//	  - If f returns Left(B): (Right(B), Left(empty))
+//	  - If f returns Right(C): (Left(empty), Right(C))
+//
+// Example:
+//
+//	import (
+//	    E "github.com/IBM/fp-go/v2/either"
+//	    P "github.com/IBM/fp-go/v2/pair"
+//	)
+//
+//	// Classify and transform numbers: negative -> error message, positive -> squared value
+//	classifyNumber := func(n int) E.Either[string, int] {
+//	    if n < 0 {
+//	        return E.Left[int]("negative: " + strconv.Itoa(n))
+//	    }
+//	    return E.Right[string](n * n)
+//	}
+//	partitionMap := E.PartitionMap(classifyNumber, "not classified")
+//
+//	// Positive number - goes to right side as squared value
+//	result1 := partitionMap(E.Right[string](5))
+//	// result1 = Pair(Left("not classified"), Right(25))
+//	left1, right1 := P.Unpack(result1)
+//	// left1 = Left("not classified"), right1 = Right(25)
+//
+//	// Negative number - goes to left side with error message
+//	result2 := partitionMap(E.Right[string](-3))
+//	// result2 = Pair(Right("negative: -3"), Left("not classified"))
+//	left2, right2 := P.Unpack(result2)
+//	// left2 = Right("negative: -3"), right2 = Left("not classified")
+//
+//	// Original Left value - appears in both positions
+//	result3 := partitionMap(E.Left[int]("original error"))
+//	// result3 = Pair(Left("original error"), Left("original error"))
+//	left3, right3 := P.Unpack(result3)
+//	// left3 = Left("original error"), right3 = Left("original error")
+//
+//	// Validate and transform user input
+//	type ValidationError struct{ Field, Message string }
+//	type User struct{ Name string; Age int }
+//
+//	validateUser := func(input map[string]string) E.Either[ValidationError, User] {
+//	    name, hasName := input["name"]
+//	    ageStr, hasAge := input["age"]
+//	    if !hasName {
+//	        return E.Left[User](ValidationError{"name", "missing"})
+//	    }
+//	    if !hasAge {
+//	        return E.Left[User](ValidationError{"age", "missing"})
+//	    }
+//	    age, err := strconv.Atoi(ageStr)
+//	    if err != nil {
+//	        return E.Left[User](ValidationError{"age", "invalid"})
+//	    }
+//	    return E.Right[ValidationError](User{name, age})
+//	}
+//	partitionUsers := E.PartitionMap(validateUser, ValidationError{"", "not processed"})
+//
+//	validInput := map[string]string{"name": "Alice", "age": "30"}
+//	result4 := partitionUsers(E.Right[string](validInput))
+//	// result4 = Pair(Left(ValidationError{"", "not processed"}), Right(User{"Alice", 30}))
+//
+//	invalidInput := map[string]string{"name": "Bob"}
+//	result5 := partitionUsers(E.Right[string](invalidInput))
+//	// result5 = Pair(Right(ValidationError{"age", "missing"}), Left(ValidationError{"", "not processed"}))
+func PartitionMap[E, A, B, C any](f Kleisli[B, A, C], empty E) func(Either[E, A]) Pair[Either[E, B], Either[E, C]] {
+	return func(e Either[E, A]) Pair[Either[E, B], Either[E, C]] {
+		if e.isLeft {
+			return pair.MakePair(Left[B](e.l), Left[C](e.l))
+		}
+		res := f(e.r)
+		if res.isLeft {
+			return pair.MakePair(Right[E](res.l), Left[C](empty))
+		}
+		return pair.MakePair(Left[B](empty), Right[E](res.r))
+	}
+}

v2/either/types.go

@@ -21,6 +21,7 @@ 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/pair"
 	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 )
@@ -53,4 +54,6 @@ type (
 	// 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]
+
+	Pair[L, R any] = pair.Pair[L, R]
 )

v2/iterator/iter/iter.go

@@ -466,6 +466,11 @@ func Chain[A, B any](f func(A) Seq[B]) Operator[A, B] {
 	return F.Bind2nd(MonadChain[A, B], f)
 }
 
+//go:inline
+func FlatMap[A, B any](f func(A) Seq[B]) Operator[A, B] {
+	return Chain(f)
+}
+
 // Flatten flattens a sequence of sequences into a single sequence.
 //
 // RxJS Equivalent: [mergeAll] - https://rxjs.dev/api/operators/mergeAll

v2/iterator/iter/option.go

@@ -0,0 +1,158 @@
+// 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 iter
+
+import (
+	"github.com/IBM/fp-go/v2/option"
+)
+
+// MonadChainOptionK chains a function that returns an Option into a sequence,
+// filtering out None values and unwrapping Some values.
+//
+// This is useful for operations that may or may not produce a value for each element
+// in the sequence. Only the successful (Some) results are included in the output sequence,
+// while None values are filtered out.
+//
+// This is the monadic form that takes the sequence as the first parameter.
+//
+// RxJS Equivalent: [concatMap] combined with [filter] - https://rxjs.dev/api/operators/concatMap
+//
+// Type parameters:
+//   - A: The element type of the input sequence
+//   - B: The element type of the output sequence (wrapped in Option by the function)
+//
+// Parameters:
+//   - as: The input sequence to transform
+//   - f: A function that takes an element and returns an Option[B]
+//
+// Returns:
+//
+//	A new sequence containing only the unwrapped Some values
+//
+// Example:
+//
+//	import (
+//	    "strconv"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	    O "github.com/IBM/fp-go/v2/option"
+//	    I "github.com/IBM/fp-go/v2/iterator/iter"
+//	)
+//
+//	// Parse strings to integers, filtering out invalid ones
+//	parseNum := func(s string) O.Option[int] {
+//	    if n, err := strconv.Atoi(s); err == nil {
+//	        return O.Some(n)
+//	    }
+//	    return O.None[int]()
+//	}
+//
+//	seq := I.From("1", "invalid", "2", "3", "bad")
+//	result := I.MonadChainOptionK(seq, parseNum)
+//	// yields: 1, 2, 3 (invalid strings are filtered out)
+func MonadChainOptionK[A, B any](as Seq[A], f option.Kleisli[A, B]) Seq[B] {
+	return MonadFilterMap(as, f)
+}
+
+// ChainOptionK returns an operator that chains a function returning an Option into a sequence,
+// filtering out None values and unwrapping Some values.
+//
+// This is the curried version of [MonadChainOptionK], useful for function composition
+// and creating reusable transformations.
+//
+// RxJS Equivalent: [concatMap] combined with [filter] - https://rxjs.dev/api/operators/concatMap
+//
+// Type parameters:
+//   - A: The element type of the input sequence
+//   - B: The element type of the output sequence (wrapped in Option by the function)
+//
+// Parameters:
+//   - f: A function that takes an element and returns an Option[B]
+//
+// Returns:
+//
+//	An Operator that transforms Seq[A] to Seq[B], filtering out None values
+//
+// Example:
+//
+//	import (
+//	    "strconv"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	    O "github.com/IBM/fp-go/v2/option"
+//	    I "github.com/IBM/fp-go/v2/iterator/iter"
+//	)
+//
+//	// Create a reusable parser operator
+//	parsePositive := I.ChainOptionK(func(x int) O.Option[int] {
+//	    if x > 0 {
+//	        return O.Some(x)
+//	    }
+//	    return O.None[int]()
+//	})
+//
+//	result := F.Pipe1(
+//	    I.From(-1, 2, -3, 4, 5),
+//	    parsePositive,
+//	)
+//	// yields: 2, 4, 5 (negative numbers are filtered out)
+//
+//go:inline
+func ChainOptionK[A, B any](f option.Kleisli[A, B]) Operator[A, B] {
+	return FilterMap(f)
+}
+
+// FlatMapOptionK is an alias for [ChainOptionK].
+//
+// This provides a more familiar name for developers coming from other functional
+// programming languages or libraries where "flatMap" is the standard terminology
+// for the monadic bind operation.
+//
+// Type parameters:
+//   - A: The element type of the input sequence
+//   - B: The element type of the output sequence (wrapped in Option by the function)
+//
+// Parameters:
+//   - f: A function that takes an element and returns an Option[B]
+//
+// Returns:
+//
+//	An Operator that transforms Seq[A] to Seq[B], filtering out None values
+//
+// Example:
+//
+//	import (
+//	    F "github.com/IBM/fp-go/v2/function"
+//	    O "github.com/IBM/fp-go/v2/option"
+//	    I "github.com/IBM/fp-go/v2/iterator/iter"
+//	)
+//
+//	// Validate and transform data
+//	validateAge := I.FlatMapOptionK(func(age int) O.Option[string] {
+//	    if age >= 18 && age <= 120 {
+//	        return O.Some(fmt.Sprintf("Valid age: %d", age))
+//	    }
+//	    return O.None[string]()
+//	})
+//
+//	result := F.Pipe1(
+//	    I.From(15, 25, 150, 30),
+//	    validateAge,
+//	)
+//	// yields: "Valid age: 25", "Valid age: 30"
+//
+//go:inline
+func FlatMapOptionK[A, B any](f option.Kleisli[A, B]) Operator[A, B] {
+	return ChainOptionK(f)
+}

v2/iterator/iter/option_test.go

@@ -0,0 +1,389 @@
+// 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 iter
+
+import (
+	"fmt"
+	"slices"
+	"strconv"
+	"testing"
+
+	A "github.com/IBM/fp-go/v2/array"
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestMonadChainOptionK_AllSome tests MonadChainOptionK when all values produce Some
+func TestMonadChainOptionK_AllSome(t *testing.T) {
+	// Function that always returns Some
+	double := func(x int) O.Option[int] {
+		return O.Some(x * 2)
+	}
+
+	seq := From(1, 2, 3, 4, 5)
+	result := MonadChainOptionK(seq, double)
+	values := slices.Collect(result)
+
+	expected := A.From(2, 4, 6, 8, 10)
+	assert.Equal(t, expected, values)
+}
+
+// TestMonadChainOptionK_AllNone tests MonadChainOptionK when all values produce None
+func TestMonadChainOptionK_AllNone(t *testing.T) {
+	// Function that always returns None
+	alwaysNone := func(x int) O.Option[int] {
+		return O.None[int]()
+	}
+
+	seq := From(1, 2, 3, 4, 5)
+	result := MonadChainOptionK(seq, alwaysNone)
+	values := slices.Collect(result)
+
+	assert.Empty(t, values)
+}
+
+// TestMonadChainOptionK_MixedSomeNone tests MonadChainOptionK with mixed Some and None
+func TestMonadChainOptionK_MixedSomeNone(t *testing.T) {
+	// Function that returns Some for even numbers, None for odd
+	evenOnly := func(x int) O.Option[int] {
+		if x%2 == 0 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	}
+
+	seq := From(1, 2, 3, 4, 5, 6)
+	result := MonadChainOptionK(seq, evenOnly)
+	values := slices.Collect(result)
+
+	expected := A.From(2, 4, 6)
+	assert.Equal(t, expected, values)
+}
+
+// TestMonadChainOptionK_ParseStrings tests parsing strings to integers
+func TestMonadChainOptionK_ParseStrings(t *testing.T) {
+	// Parse strings to integers, returning None for invalid strings
+	parseNum := func(s string) O.Option[int] {
+		if n, err := strconv.Atoi(s); err == nil {
+			return O.Some(n)
+		}
+		return O.None[int]()
+	}
+
+	seq := From("1", "invalid", "2", "3", "bad", "4")
+	result := MonadChainOptionK(seq, parseNum)
+	values := slices.Collect(result)
+
+	expected := A.From(1, 2, 3, 4)
+	assert.Equal(t, expected, values)
+}
+
+// TestMonadChainOptionK_EmptySequence tests MonadChainOptionK with empty sequence
+func TestMonadChainOptionK_EmptySequence(t *testing.T) {
+	double := func(x int) O.Option[int] {
+		return O.Some(x * 2)
+	}
+
+	seq := From[int]()
+	result := MonadChainOptionK(seq, double)
+	values := slices.Collect(result)
+
+	assert.Empty(t, values)
+}
+
+// TestMonadChainOptionK_TypeTransformation tests transforming types
+func TestMonadChainOptionK_TypeTransformation(t *testing.T) {
+	// Convert integers to strings, only for positive numbers
+	positiveToString := func(x int) O.Option[string] {
+		if x > 0 {
+			return O.Some(fmt.Sprintf("num_%d", x))
+		}
+		return O.None[string]()
+	}
+
+	seq := From(-2, -1, 0, 1, 2, 3)
+	result := MonadChainOptionK(seq, positiveToString)
+	values := slices.Collect(result)
+
+	expected := A.From("num_1", "num_2", "num_3")
+	assert.Equal(t, expected, values)
+}
+
+// TestMonadChainOptionK_ComplexType tests with complex types
+func TestMonadChainOptionK_ComplexType(t *testing.T) {
+	type Person struct {
+		Name string
+		Age  int
+	}
+
+	// Extract age only for adults
+	getAdultAge := func(p Person) O.Option[int] {
+		if p.Age >= 18 {
+			return O.Some(p.Age)
+		}
+		return O.None[int]()
+	}
+
+	seq := From(
+		Person{"Alice", 25},
+		Person{"Bob", 15},
+		Person{"Charlie", 30},
+		Person{"David", 12},
+	)
+	result := MonadChainOptionK(seq, getAdultAge)
+	values := slices.Collect(result)
+
+	expected := A.From(25, 30)
+	assert.Equal(t, expected, values)
+}
+
+// TestChainOptionK_BasicUsage tests ChainOptionK basic functionality
+func TestChainOptionK_BasicUsage(t *testing.T) {
+	// Create a reusable operator
+	parsePositive := ChainOptionK(func(x int) O.Option[int] {
+		if x > 0 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	})
+
+	seq := From(-1, 2, -3, 4, 5, -6)
+	result := parsePositive(seq)
+	values := slices.Collect(result)
+
+	expected := A.From(2, 4, 5)
+	assert.Equal(t, expected, values)
+}
+
+// TestChainOptionK_WithPipe tests ChainOptionK in a pipeline
+func TestChainOptionK_WithPipe(t *testing.T) {
+	// Validate and transform in a pipeline
+	validateRange := ChainOptionK(func(x int) O.Option[int] {
+		if x >= 0 && x <= 100 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	})
+
+	result := F.Pipe2(
+		From(-10, 20, 150, 50, 200, 75),
+		validateRange,
+		Map(func(x int) int { return x * 2 }),
+	)
+	values := slices.Collect(result)
+
+	expected := A.From(40, 100, 150)
+	assert.Equal(t, expected, values)
+}
+
+// TestChainOptionK_Composition tests composing multiple ChainOptionK operations
+func TestChainOptionK_Composition(t *testing.T) {
+	// First filter: only positive
+	onlyPositive := ChainOptionK(func(x int) O.Option[int] {
+		if x > 0 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	})
+
+	// Second filter: only even
+	onlyEven := ChainOptionK(func(x int) O.Option[int] {
+		if x%2 == 0 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	})
+
+	result := F.Pipe2(
+		From(-2, -1, 0, 1, 2, 3, 4, 5, 6),
+		onlyPositive,
+		onlyEven,
+	)
+	values := slices.Collect(result)
+
+	expected := A.From(2, 4, 6)
+	assert.Equal(t, expected, values)
+}
+
+// TestChainOptionK_StringParsing tests parsing with ChainOptionK
+func TestChainOptionK_StringParsing(t *testing.T) {
+	// Create a reusable string parser
+	parseInt := ChainOptionK(func(s string) O.Option[int] {
+		if n, err := strconv.Atoi(s); err == nil {
+			return O.Some(n)
+		}
+		return O.None[int]()
+	})
+
+	result := F.Pipe1(
+		From("10", "abc", "20", "xyz", "30"),
+		parseInt,
+	)
+	values := slices.Collect(result)
+
+	expected := A.From(10, 20, 30)
+	assert.Equal(t, expected, values)
+}
+
+// TestFlatMapOptionK_Equivalence tests that FlatMapOptionK is equivalent to ChainOptionK
+func TestFlatMapOptionK_Equivalence(t *testing.T) {
+	validate := func(x int) O.Option[int] {
+		if x >= 0 && x <= 10 {
+			return O.Some(x)
+		}
+		return O.None[int]()
+	}
+
+	seq := From(-5, 0, 5, 10, 15)
+
+	// Using ChainOptionK
+	result1 := ChainOptionK(validate)(seq)
+	values1 := slices.Collect(result1)
+
+	// Using FlatMapOptionK
+	result2 := FlatMapOptionK(validate)(seq)
+	values2 := slices.Collect(result2)
+
+	// Both should produce the same result
+	assert.Equal(t, values1, values2)
+	assert.Equal(t, A.From(0, 5, 10), values1)
+}
+
+// TestFlatMapOptionK_WithMap tests FlatMapOptionK combined with Map
+func TestFlatMapOptionK_WithMap(t *testing.T) {
+	// Validate age and convert to category
+	validateAge := FlatMapOptionK(func(age int) O.Option[string] {
+		if age >= 18 && age <= 120 {
+			return O.Some(fmt.Sprintf("Valid age: %d", age))
+		}
+		return O.None[string]()
+	})
+
+	result := F.Pipe1(
+		From(15, 25, 150, 30, 200),
+		validateAge,
+	)
+	values := slices.Collect(result)
+
+	expected := A.From("Valid age: 25", "Valid age: 30")
+	assert.Equal(t, expected, values)
+}
+
+// TestChainOptionK_LookupOperation tests using ChainOptionK for lookup operations
+func TestChainOptionK_LookupOperation(t *testing.T) {
+	// Simulate a lookup table
+	lookup := map[string]int{
+		"one":   1,
+		"two":   2,
+		"three": 3,
+	}
+
+	lookupValue := ChainOptionK(func(key string) O.Option[int] {
+		if val, ok := lookup[key]; ok {
+			return O.Some(val)
+		}
+		return O.None[int]()
+	})
+
+	result := F.Pipe1(
+		From("one", "invalid", "two", "missing", "three"),
+		lookupValue,
+	)
+	values := slices.Collect(result)
+
+	expected := A.From(1, 2, 3)
+	assert.Equal(t, expected, values)
+}
+
+// TestMonadChainOptionK_EarlyTermination tests that iteration stops when yield returns false
+func TestMonadChainOptionK_EarlyTermination(t *testing.T) {
+	callCount := 0
+	countCalls := func(x int) O.Option[int] {
+		callCount++
+		return O.Some(x)
+	}
+
+	seq := From(1, 2, 3, 4, 5)
+	result := MonadChainOptionK(seq, countCalls)
+
+	// Collect only first 3 elements
+	collected := make([]int, 0)
+	for v := range result {
+		collected = append(collected, v)
+		if len(collected) >= 3 {
+			break
+		}
+	}
+
+	// Should have called the function only 3 times due to early termination
+	assert.Equal(t, 3, callCount)
+	assert.Equal(t, A.From(1, 2, 3), collected)
+}
+
+// TestChainOptionK_WithReduce tests ChainOptionK with reduction
+func TestChainOptionK_WithReduce(t *testing.T) {
+	// Parse and sum valid numbers
+	parseInt := ChainOptionK(func(s string) O.Option[int] {
+		if n, err := strconv.Atoi(s); err == nil {
+			return O.Some(n)
+		}
+		return O.None[int]()
+	})
+
+	result := F.Pipe1(
+		From("10", "invalid", "20", "bad", "30"),
+		parseInt,
+	)
+
+	sum := MonadReduce(result, func(acc, x int) int {
+		return acc + x
+	}, 0)
+
+	assert.Equal(t, 60, sum)
+}
+
+// TestFlatMapOptionK_NestedOptions tests FlatMapOptionK with nested option handling
+func TestFlatMapOptionK_NestedOptions(t *testing.T) {
+	type Result struct {
+		Value int
+		Valid bool
+	}
+
+	// Extract value only if valid
+	extractValid := FlatMapOptionK(func(r Result) O.Option[int] {
+		if r.Valid {
+			return O.Some(r.Value)
+		}
+		return O.None[int]()
+	})
+
+	seq := From(
+		Result{10, true},
+		Result{20, false},
+		Result{30, true},
+		Result{40, false},
+		Result{50, true},
+	)
+
+	result := F.Pipe1(seq, extractValid)
+	values := slices.Collect(result)
+
+	expected := A.From(10, 30, 50)
+	assert.Equal(t, expected, values)
+}
+
+// Made with Bob

v2/llms.txt

@@ -0,0 +1,99 @@
+# fp-go
+
+> A comprehensive functional programming library for Go, bringing type-safe monads, functors, applicatives, optics, and composable abstractions inspired by fp-ts and Haskell to the Go ecosystem. Created by IBM, licensed under Apache-2.0.
+
+fp-go v2 requires Go 1.24+ and leverages generic type aliases for a cleaner API. 
+
+Key concepts: `Option` for nullable values, `Either`/`Result` for error handling, `IO` for lazy side effects, `Reader` for dependency injection, `IOResult` for effectful error handling, `ReaderIOResult` for the full monad stack, and `Optics` (lens, prism, traversal, iso) for immutable data manipulation.
+
+## Core Documentation
+
+- [API Reference (pkg.go.dev)](https://pkg.go.dev/github.com/IBM/fp-go/v2): Complete API documentation for all packages
+- [README](https://github.com/IBM/fp-go/blob/main/v2/README.md): Overview, quick start, installation, and migration guide from v1 to v2
+- [Design Decisions](https://github.com/IBM/fp-go/blob/main/v2/DESIGN.md): Key design principles and patterns
+- [Functional I/O Guide](https://github.com/IBM/fp-go/blob/main/v2/FUNCTIONAL_IO.md): Understanding Context, errors, and the Reader pattern for I/O operations
+- [Idiomatic vs Standard Comparison](https://github.com/IBM/fp-go/blob/main/v2/IDIOMATIC_COMPARISON.md): Performance comparison and when to use each approach
+- [Optics README](https://github.com/IBM/fp-go/blob/main/v2/optics/README.md): Guide to lens, prism, optional, and traversal optics
+
+## Standard Packages (struct-based)
+
+- [option](https://pkg.go.dev/github.com/IBM/fp-go/v2/option): Option monad — represent optional values without nil
+- [either](https://pkg.go.dev/github.com/IBM/fp-go/v2/either): Either monad — type-safe error handling with Left/Right values
+- [result](https://pkg.go.dev/github.com/IBM/fp-go/v2/result): Result monad — simplified Either with `error` as Left type (recommended for error handling)
+- [io](https://pkg.go.dev/github.com/IBM/fp-go/v2/io): IO monad — lazy evaluation and side effect management
+- [iooption](https://pkg.go.dev/github.com/IBM/fp-go/v2/iooption): IOOption — IO combined with Option
+- [ioeither](https://pkg.go.dev/github.com/IBM/fp-go/v2/ioeither): IOEither — IO combined with Either for effectful error handling
+- [ioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/ioresult): IOResult — IO combined with Result (recommended over IOEither)
+- [reader](https://pkg.go.dev/github.com/IBM/fp-go/v2/reader): Reader monad — dependency injection pattern
+- [readeroption](https://pkg.go.dev/github.com/IBM/fp-go/v2/readeroption): ReaderOption — Reader combined with Option
+- [readeriooption](https://pkg.go.dev/github.com/IBM/fp-go/v2/readeriooption): ReaderIOOption — Reader + IO + Option
+- [readerioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/readerioresult): ReaderIOResult — Reader + IO + Result for complex workflows
+- [readerioeither](https://pkg.go.dev/github.com/IBM/fp-go/v2/readerioeither): ReaderIOEither — Reader + IO + Either
+- [statereaderioeither](https://pkg.go.dev/github.com/IBM/fp-go/v2/statereaderioeither): StateReaderIOEither — State + Reader + IO + Either
+
+## Idiomatic Packages (tuple-based, high performance)
+
+- [idiomatic/option](https://pkg.go.dev/github.com/IBM/fp-go/v2/idiomatic/option): Option using native Go `(value, bool)` tuples
+- [idiomatic/result](https://pkg.go.dev/github.com/IBM/fp-go/v2/idiomatic/result): Result using native Go `(value, error)` tuples
+- [idiomatic/ioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/idiomatic/ioresult): IOResult using `func() (value, error)`
+- [idiomatic/readerresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/idiomatic/readerresult): ReaderResult with tuple-based results
+- [idiomatic/readerioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/idiomatic/readerioresult): ReaderIOResult with tuple-based results
+
+## Context Packages (context.Context specializations)
+
+- [context/readerioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/context/readerioresult): ReaderIOResult specialized for context.Context
+- [context/readerioresult/http](https://pkg.go.dev/github.com/IBM/fp-go/v2/context/readerioresult/http): Functional HTTP client utilities
+- [context/readerioresult/http/builder](https://pkg.go.dev/github.com/IBM/fp-go/v2/context/readerioresult/http/builder): Functional HTTP request builder
+- [context/statereaderioresult](https://pkg.go.dev/github.com/IBM/fp-go/v2/context/statereaderioresult): State + Reader + IO + Result for context.Context
+
+## Optics
+
+- [optics](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics): Core optics package
+- [optics/lens](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/lens): Lenses for focusing on fields in product types
+- [optics/prism](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/prism): Prisms for focusing on variants in sum types
+- [optics/iso](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/iso): Isomorphisms for bidirectional transformations
+- [optics/optional](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/optional): Optionals for values that may not exist
+- [optics/traversal](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/traversal): Traversals for focusing on multiple values
+- [optics/codec](https://pkg.go.dev/github.com/IBM/fp-go/v2/optics/codec): Codecs for encoding/decoding with validation
+
+## Utility Packages
+
+- [array](https://pkg.go.dev/github.com/IBM/fp-go/v2/array): Functional array/slice operations (map, filter, fold, etc.)
+- [record](https://pkg.go.dev/github.com/IBM/fp-go/v2/record): Functional operations for maps
+- [function](https://pkg.go.dev/github.com/IBM/fp-go/v2/function): Function composition, pipe, flow, curry, identity
+- [pair](https://pkg.go.dev/github.com/IBM/fp-go/v2/pair): Strongly-typed pair/tuple data structure
+- [tuple](https://pkg.go.dev/github.com/IBM/fp-go/v2/tuple): Type-safe heterogeneous tuples
+- [predicate](https://pkg.go.dev/github.com/IBM/fp-go/v2/predicate): Predicate combinators (and, or, not, etc.)
+- [endomorphism](https://pkg.go.dev/github.com/IBM/fp-go/v2/endomorphism): Endomorphism operations (compose, chain)
+- [eq](https://pkg.go.dev/github.com/IBM/fp-go/v2/eq): Type-safe equality comparisons
+- [ord](https://pkg.go.dev/github.com/IBM/fp-go/v2/ord): Total ordering type class
+- [semigroup](https://pkg.go.dev/github.com/IBM/fp-go/v2/semigroup): Semigroup algebraic structure
+- [monoid](https://pkg.go.dev/github.com/IBM/fp-go/v2/monoid): Monoid algebraic structure
+- [number](https://pkg.go.dev/github.com/IBM/fp-go/v2/number): Algebraic structures for numeric types
+- [string](https://pkg.go.dev/github.com/IBM/fp-go/v2/string): Functional string utilities
+- [boolean](https://pkg.go.dev/github.com/IBM/fp-go/v2/boolean): Functional boolean utilities
+- [bytes](https://pkg.go.dev/github.com/IBM/fp-go/v2/bytes): Functional byte slice utilities
+- [json](https://pkg.go.dev/github.com/IBM/fp-go/v2/json): Functional JSON encoding/decoding
+- [lazy](https://pkg.go.dev/github.com/IBM/fp-go/v2/lazy): Lazy evaluation without side effects
+- [identity](https://pkg.go.dev/github.com/IBM/fp-go/v2/identity): Identity monad
+- [retry](https://pkg.go.dev/github.com/IBM/fp-go/v2/retry): Retry policies with configurable backoff
+- [tailrec](https://pkg.go.dev/github.com/IBM/fp-go/v2/tailrec): Trampoline for tail-call optimization
+- [di](https://pkg.go.dev/github.com/IBM/fp-go/v2/di): Dependency injection utilities
+- [effect](https://pkg.go.dev/github.com/IBM/fp-go/v2/effect): Functional effect system
+- [circuitbreaker](https://pkg.go.dev/github.com/IBM/fp-go/v2/circuitbreaker): Circuit breaker error types
+- [builder](https://pkg.go.dev/github.com/IBM/fp-go/v2/builder): Generic builder pattern with validation
+
+## Code Samples
+
+- [samples/builder](https://github.com/IBM/fp-go/tree/main/v2/samples/builder): Functional builder pattern example
+- [samples/http](https://github.com/IBM/fp-go/tree/main/v2/samples/http): HTTP client examples
+- [samples/lens](https://github.com/IBM/fp-go/tree/main/v2/samples/lens): Optics/lens examples
+- [samples/mostly-adequate](https://github.com/IBM/fp-go/tree/main/v2/samples/mostly-adequate): Examples adapted from "Mostly Adequate Guide to Functional Programming"
+- [samples/tuples](https://github.com/IBM/fp-go/tree/main/v2/samples/tuples): Tuple usage examples
+
+## Optional
+
+- [Source Code](https://github.com/IBM/fp-go): GitHub repository
+- [Issues](https://github.com/IBM/fp-go/issues): Bug reports and feature requests
+- [Go Report Card](https://goreportcard.com/report/github.com/IBM/fp-go/v2): Code quality report
+- [Coverage](https://coveralls.io/github/IBM/fp-go?branch=main): Test coverage report

v2/optics/codec/alt.go

@@ -0,0 +1,480 @@
+// 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 codec
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/lazy"
+	"github.com/IBM/fp-go/v2/monoid"
+	"github.com/IBM/fp-go/v2/optics/codec/validate"
+	"github.com/IBM/fp-go/v2/reader"
+)
+
+// validateAlt creates a validation function that tries the first codec's validation,
+// and if it fails, tries the second codec's validation as a fallback.
+//
+// This is an internal helper function that implements the Alternative pattern for
+// codec validation. It combines two codec validators using the validate.Alt operation,
+// which provides error recovery and fallback logic.
+//
+// # Type Parameters
+//
+//   - A: The target type that both codecs decode to
+//   - O: The output type that both codecs encode to
+//   - I: The input type that both codecs decode from
+//
+// # Parameters
+//
+//   - first: The primary codec whose validation is tried first
+//   - second: A lazy codec that serves as the fallback. It's only evaluated if the
+//     first validation fails.
+//
+// # Returns
+//
+// A Validate[I, A] function that tries the first codec's validation, falling back
+// to the second if needed. If both fail, errors from both are aggregated.
+//
+// # Behavior
+//
+//   - **First succeeds**: Returns the first result, second is never evaluated
+//   - **First fails, second succeeds**: Returns the second result
+//   - **Both fail**: Aggregates errors from both validators
+//
+// # Notes
+//
+//   - The second codec is lazily evaluated for efficiency
+//   - This function is used internally by MonadAlt and Alt
+//   - The validation context is threaded through both validators
+//   - Errors are accumulated using the validation error monoid
+func validateAlt[A, O, I any](
+	first Type[A, O, I],
+	second Lazy[Type[A, O, I]],
+) Validate[I, A] {
+
+	return F.Pipe1(
+		first.Validate,
+		validate.Alt(F.Pipe1(
+			second,
+			lazy.Map(F.Flip(reader.Curry(Type[A, O, I].Validate))),
+		)),
+	)
+}
+
+// MonadAlt creates a new codec that tries the first codec, and if it fails during
+// validation, tries the second codec as a fallback.
+//
+// This function implements the Alternative typeclass pattern for codecs, enabling
+// "try this codec, or else try that codec" logic. It's particularly useful for:
+//   - Handling multiple valid input formats
+//   - Providing backward compatibility with legacy formats
+//   - Implementing graceful degradation in parsing
+//   - Supporting union types or polymorphic data
+//
+// The resulting codec uses the first codec's encoder and combines both validators
+// using the Alternative pattern. If both validations fail, errors from both are
+// aggregated for comprehensive error reporting.
+//
+// # Type Parameters
+//
+//   - A: The target type that both codecs decode to
+//   - O: The output type that both codecs encode to
+//   - I: The input type that both codecs decode from
+//
+// # Parameters
+//
+//   - first: The primary codec to try first. Its encoder is used for the result.
+//   - second: A lazy codec that serves as the fallback. It's only evaluated if the
+//     first validation fails.
+//
+// # Returns
+//
+// A new Type[A, O, I] that combines both codecs with Alternative semantics.
+//
+// # Behavior
+//
+// **Validation**:
+//   - **First succeeds**: Returns the first result, second is never evaluated
+//   - **First fails, second succeeds**: Returns the second result
+//   - **Both fail**: Aggregates errors from both validators
+//
+// **Encoding**:
+//   - Always uses the first codec's encoder
+//   - This assumes both codecs encode to the same output format
+//
+// **Type Checking**:
+//   - Uses the generic Is[A]() type checker
+//   - Validates that values are of type A
+//
+// # Example: Multiple Input Formats
+//
+//	import (
+//	    "github.com/IBM/fp-go/v2/optics/codec"
+//	)
+//
+//	// Accept integers as either strings or numbers
+//	intFromString := codec.IntFromString()
+//	intFromNumber := codec.Int()
+//
+//	// Try parsing as string first, fall back to number
+//	flexibleInt := codec.MonadAlt(
+//	    intFromString,
+//	    func() codec.Type[int, any, any] { return intFromNumber },
+//	)
+//
+//	// Can now decode both "42" and 42
+//	result1 := flexibleInt.Decode("42")   // Success(42)
+//	result2 := flexibleInt.Decode(42)     // Success(42)
+//
+// # Example: Backward Compatibility
+//
+//	// Support both old and new configuration formats
+//	newConfigCodec := codec.Struct(/* new format */)
+//	oldConfigCodec := codec.Struct(/* old format */)
+//
+//	// Try new format first, fall back to old format
+//	configCodec := codec.MonadAlt(
+//	    newConfigCodec,
+//	    func() codec.Type[Config, any, any] { return oldConfigCodec },
+//	)
+//
+//	// Automatically handles both formats
+//	config := configCodec.Decode(input)
+//
+// # Example: Error Aggregation
+//
+//	// Both validations will fail for invalid input
+//	result := flexibleInt.Decode("not a number")
+//	// Result contains errors from both string and number parsing attempts
+//
+// # Notes
+//
+//   - The second codec is lazily evaluated for efficiency
+//   - First success short-circuits evaluation (second not called)
+//   - Errors are aggregated when both fail
+//   - The resulting codec's name is "Alt[<first codec name>]"
+//   - Both codecs must have compatible input and output types
+//   - The first codec's encoder is always used
+//
+// # See Also
+//
+//   - Alt: The curried, point-free version
+//   - validate.MonadAlt: The underlying validation operation
+//   - Either: For codecs that decode to Either[L, R] types
+func MonadAlt[A, O, I any](first Type[A, O, I], second Lazy[Type[A, O, I]]) Type[A, O, I] {
+	return MakeType(
+		fmt.Sprintf("Alt[%s]", first.Name()),
+		Is[A](),
+		validateAlt(first, second),
+		first.Encode,
+	)
+}
+
+// Alt creates an operator that adds alternative fallback logic to a codec.
+//
+// This is the curried, point-free version of MonadAlt. It returns a function that
+// can be applied to codecs to add fallback behavior. This style is particularly
+// useful for building codec transformation pipelines using function composition.
+//
+// Alt implements the Alternative typeclass pattern, enabling "try this codec, or
+// else try that codec" logic in a composable way.
+//
+// # Type Parameters
+//
+//   - A: The target type that both codecs decode to
+//   - O: The output type that both codecs encode to
+//   - I: The input type that both codecs decode from
+//
+// # Parameters
+//
+//   - second: A lazy codec that serves as the fallback. It's only evaluated if the
+//     first codec's validation fails.
+//
+// # Returns
+//
+// An Operator[A, A, O, I] that transforms codecs by adding alternative fallback logic.
+// This operator can be applied to any Type[A, O, I] to create a new codec with
+// fallback behavior.
+//
+// # Behavior
+//
+// When the returned operator is applied to a codec:
+//   - **First succeeds**: Returns the first result, second is never evaluated
+//   - **First fails, second succeeds**: Returns the second result
+//   - **Both fail**: Aggregates errors from both validators
+//
+// # Example: Point-Free Style
+//
+//	import (
+//	    F "github.com/IBM/fp-go/v2/function"
+//	    "github.com/IBM/fp-go/v2/optics/codec"
+//	)
+//
+//	// Create a reusable fallback operator
+//	withNumberFallback := codec.Alt(func() codec.Type[int, any, any] {
+//	    return codec.Int()
+//	})
+//
+//	// Apply it to different codecs
+//	flexibleInt1 := withNumberFallback(codec.IntFromString())
+//	flexibleInt2 := withNumberFallback(codec.IntFromHex())
+//
+// # Example: Pipeline Composition
+//
+//	// Build a codec pipeline with multiple fallbacks
+//	flexibleCodec := F.Pipe2(
+//	    primaryCodec,
+//	    codec.Alt(func() codec.Type[T, O, I] { return fallback1 }),
+//	    codec.Alt(func() codec.Type[T, O, I] { return fallback2 }),
+//	)
+//	// Tries primary, then fallback1, then fallback2
+//
+// # Example: Reusable Transformations
+//
+//	// Create a transformation that adds JSON fallback
+//	withJSONFallback := codec.Alt(func() codec.Type[Config, string, string] {
+//	    return codec.JSONCodec[Config]()
+//	})
+//
+//	// Apply to multiple codecs
+//	yamlWithFallback := withJSONFallback(yamlCodec)
+//	tomlWithFallback := withJSONFallback(tomlCodec)
+//
+// # Notes
+//
+//   - This is the point-free style version of MonadAlt
+//   - Useful for building transformation pipelines with F.Pipe
+//   - The second codec is lazily evaluated for efficiency
+//   - First success short-circuits evaluation
+//   - Errors are aggregated when both fail
+//   - Can be composed with other codec operators
+//
+// # See Also
+//
+//   - MonadAlt: The direct application version
+//   - validate.Alt: The underlying validation operation
+//   - F.Pipe: For composing multiple operators
+func Alt[A, O, I any](second Lazy[Type[A, O, I]]) Operator[A, A, O, I] {
+	return F.Bind2nd(MonadAlt, second)
+}
+
+// AltMonoid creates a Monoid instance for Type[A, O, I] using alternative semantics
+// with a provided zero/default codec.
+//
+// This function creates a monoid where:
+//  1. The first successful codec wins (no result combination)
+//  2. If the first fails during validation, the second is tried as a fallback
+//  3. If both fail, errors are aggregated
+//  4. The provided zero codec serves as the identity element
+//
+// Unlike other monoid patterns, AltMonoid does NOT combine successful results - it always
+// returns the first success. This makes it ideal for building fallback chains with default
+// codecs, configuration loading from multiple sources, and parser combinators with alternatives.
+//
+// # Type Parameters
+//
+//   - A: The target type that all codecs decode to
+//   - O: The output type that all codecs encode to
+//   - I: The input type that all codecs decode from
+//
+// # Parameters
+//
+//   - zero: A lazy Type[A, O, I] that serves as the identity element. This is typically
+//     a codec that always succeeds with a default value, but can also be a failing
+//     codec if no default is appropriate.
+//
+// # Returns
+//
+// A Monoid[Type[A, O, I]] that combines codecs using alternative semantics where
+// the first success wins.
+//
+// # Behavior Details
+//
+// The AltMonoid implements a "first success wins" strategy:
+//
+//   - **First succeeds**: Returns the first result, second is never evaluated
+//   - **First fails, second succeeds**: Returns the second result
+//   - **Both fail**: Aggregates errors from both validators
+//   - **Concat with Empty**: The zero codec is used as fallback
+//   - **Encoding**: Always uses the first codec's encoder
+//
+// # Example: Configuration Loading with Fallbacks
+//
+//	import (
+//	    "github.com/IBM/fp-go/v2/optics/codec"
+//	    "github.com/IBM/fp-go/v2/array"
+//	)
+//
+//	// Create a monoid with a default configuration
+//	m := codec.AltMonoid(func() codec.Type[Config, string, string] {
+//	    return codec.MakeType(
+//	        "DefaultConfig",
+//	        codec.Is[Config](),
+//	        func(s string) codec.Decode[codec.Context, Config] {
+//	            return func(c codec.Context) codec.Validation[Config] {
+//	                return validation.Success(defaultConfig)
+//	            }
+//	        },
+//	        encodeConfig,
+//	    )
+//	})
+//
+//	// Define codecs for different sources
+//	fileCodec := loadFromFile("config.json")
+//	envCodec := loadFromEnv()
+//	defaultCodec := m.Empty()
+//
+//	// Try file, then env, then default
+//	configCodec := array.MonadFold(
+//	    []codec.Type[Config, string, string]{fileCodec, envCodec, defaultCodec},
+//	    m.Empty(),
+//	    m.Concat,
+//	)
+//
+//	// Load configuration - tries each source in order
+//	result := configCodec.Decode(input)
+//
+// # Example: Parser with Multiple Formats
+//
+//	// Create a monoid for parsing dates in multiple formats
+//	m := codec.AltMonoid(func() codec.Type[time.Time, string, string] {
+//	    return codec.Date(time.RFC3339) // default format
+//	})
+//
+//	// Define parsers for different date formats
+//	iso8601 := codec.Date("2006-01-02")
+//	usFormat := codec.Date("01/02/2006")
+//	euroFormat := codec.Date("02/01/2006")
+//
+//	// Combine: try ISO 8601, then US, then European, then RFC3339
+//	flexibleDate := m.Concat(
+//	    m.Concat(
+//	        m.Concat(iso8601, usFormat),
+//	        euroFormat,
+//	    ),
+//	    m.Empty(),
+//	)
+//
+//	// Can parse any of these formats
+//	result1 := flexibleDate.Decode("2024-03-15")      // ISO 8601
+//	result2 := flexibleDate.Decode("03/15/2024")      // US format
+//	result3 := flexibleDate.Decode("15/03/2024")      // European format
+//
+// # Example: Integer Parsing with Default
+//
+//	// Create a monoid with default value of 0
+//	m := codec.AltMonoid(func() codec.Type[int, string, string] {
+//	    return codec.MakeType(
+//	        "DefaultZero",
+//	        codec.Is[int](),
+//	        func(s string) codec.Decode[codec.Context, int] {
+//	            return func(c codec.Context) codec.Validation[int] {
+//	                return validation.Success(0)
+//	            }
+//	        },
+//	        strconv.Itoa,
+//	    )
+//	})
+//
+//	// Try parsing as int, fall back to 0
+//	intOrZero := m.Concat(codec.IntFromString(), m.Empty())
+//
+//	result1 := intOrZero.Decode("42")        // Success(42)
+//	result2 := intOrZero.Decode("invalid")   // Success(0) - uses default
+//
+// # Example: Error Aggregation
+//
+//	// Both codecs fail - errors are aggregated
+//	m := codec.AltMonoid(func() codec.Type[int, string, string] {
+//	    return codec.MakeType(
+//	        "NoDefault",
+//	        codec.Is[int](),
+//	        func(s string) codec.Decode[codec.Context, int] {
+//	            return func(c codec.Context) codec.Validation[int] {
+//	                return validation.FailureWithMessage[int](s, "no default available")(c)
+//	            }
+//	        },
+//	        strconv.Itoa,
+//	    )
+//	})
+//
+//	failing1 := codec.MakeType(
+//	    "Failing1",
+//	    codec.Is[int](),
+//	    func(s string) codec.Decode[codec.Context, int] {
+//	        return func(c codec.Context) codec.Validation[int] {
+//	            return validation.FailureWithMessage[int](s, "error 1")(c)
+//	        }
+//	    },
+//	    strconv.Itoa,
+//	)
+//
+//	failing2 := codec.MakeType(
+//	    "Failing2",
+//	    codec.Is[int](),
+//	    func(s string) codec.Decode[codec.Context, int] {
+//	        return func(c codec.Context) codec.Validation[int] {
+//	            return validation.FailureWithMessage[int](s, "error 2")(c)
+//	        }
+//	    },
+//	    strconv.Itoa,
+//	)
+//
+//	combined := m.Concat(failing1, failing2)
+//	result := combined.Decode("input")
+//	// result contains errors: "error 1", "error 2", and "no default available"
+//
+// # Monoid Laws
+//
+// AltMonoid satisfies the monoid laws:
+//
+//  1. **Left Identity**: m.Concat(m.Empty(), codec) ≡ codec
+//  2. **Right Identity**: m.Concat(codec, m.Empty()) ≡ codec (tries codec first, falls back to zero)
+//  3. **Associativity**: m.Concat(m.Concat(a, b), c) ≡ m.Concat(a, m.Concat(b, c))
+//
+// Note: Due to the "first success wins" behavior, right identity means the zero is only
+// used if the codec fails.
+//
+// # Use Cases
+//
+//   - Configuration loading with multiple sources (file, env, default)
+//   - Parsing data in multiple formats with fallbacks
+//   - API versioning (try v2, fall back to v1, then default)
+//   - Content negotiation (try JSON, then XML, then plain text)
+//   - Validation with default values
+//   - Parser combinators with alternative branches
+//
+// # Notes
+//
+//   - The zero codec is lazily evaluated, only when needed
+//   - First success short-circuits evaluation (subsequent codecs not tried)
+//   - Error aggregation ensures all validation failures are reported
+//   - Encoding always uses the first codec's encoder
+//   - This follows the alternative functor laws
+//
+// # See Also
+//
+//   - MonadAlt: The underlying alternative operation for two codecs
+//   - Alt: The curried version for pipeline composition
+//   - validate.AltMonoid: The validation-level alternative monoid
+//   - decode.AltMonoid: The decode-level alternative monoid
+func AltMonoid[A, O, I any](zero Lazy[Type[A, O, I]]) Monoid[Type[A, O, I]] {
+	return monoid.AltMonoid(
+		zero,
+		MonadAlt[A, O, I],
+	)
+}

v2/optics/codec/alt_test.go

@@ -0,0 +1,921 @@
+// 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 codec
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/IBM/fp-go/v2/either"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/optics/codec/validation"
+	"github.com/IBM/fp-go/v2/reader"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestMonadAltBasicFunctionality tests the basic behavior of MonadAlt
+func TestMonadAltBasicFunctionality(t *testing.T) {
+	t.Run("uses first codec when it succeeds", func(t *testing.T) {
+		// Create two codecs that both work with strings
+		stringCodec := Id[string]()
+
+		// Create another string codec that only accepts uppercase
+		uppercaseOnly := MakeType(
+			"UppercaseOnly",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					for _, r := range s {
+						if r >= 'a' && r <= 'z' {
+							return validation.FailureWithMessage[string](s, "must be uppercase")(c)
+						}
+					}
+					return validation.Success(s)
+				}
+			},
+			F.Identity[string],
+		)
+
+		// Create alt codec that tries uppercase first, then any string
+		altCodec := MonadAlt(
+			uppercaseOnly,
+			func() Type[string, string, string] { return stringCodec },
+		)
+
+		// Test with uppercase string - should succeed with first codec
+		result := altCodec.Decode("HELLO")
+
+		assert.True(t, either.IsRight(result), "should successfully decode with first codec")
+
+		value := either.GetOrElse(reader.Of[validation.Errors, string](""))(result)
+		assert.Equal(t, "HELLO", value)
+	})
+
+	t.Run("falls back to second codec when first fails", func(t *testing.T) {
+		// Create a codec that only accepts positive integers
+		positiveInt := MakeType(
+			"PositiveInt",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					if i <= 0 {
+						return validation.FailureWithMessage[int](i, "must be positive")(c)
+					}
+					return validation.Success(i)
+				}
+			},
+			F.Identity[int],
+		)
+
+		// Create a codec that accepts any integer (with same input type)
+		anyInt := MakeType(
+			"AnyInt",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(i)
+				}
+			},
+			F.Identity[int],
+		)
+
+		// Create alt codec
+		altCodec := MonadAlt(
+			positiveInt,
+			func() Type[int, int, int] { return anyInt },
+		)
+
+		// Test with negative number - first fails, second succeeds
+		result := altCodec.Decode(-5)
+
+		assert.True(t, either.IsRight(result), "should successfully decode with second codec")
+
+		value := either.GetOrElse(reader.Of[validation.Errors, int](0))(result)
+		assert.Equal(t, -5, value)
+	})
+
+	t.Run("aggregates errors when both codecs fail", func(t *testing.T) {
+		// Create two codecs that will both fail
+		positiveInt := MakeType(
+			"PositiveInt",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					if i <= 0 {
+						return validation.FailureWithMessage[int](i, "must be positive")(c)
+					}
+					return validation.Success(i)
+				}
+			},
+			F.Identity[int],
+		)
+
+		evenInt := MakeType(
+			"EvenInt",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					if i%2 != 0 {
+						return validation.FailureWithMessage[int](i, "must be even")(c)
+					}
+					return validation.Success(i)
+				}
+			},
+			F.Identity[int],
+		)
+
+		// Create alt codec
+		altCodec := MonadAlt(
+			positiveInt,
+			func() Type[int, int, int] { return evenInt },
+		)
+
+		// Test with -3 (negative and odd) - both should fail
+		result := altCodec.Decode(-3)
+
+		assert.True(t, either.IsLeft(result), "should fail when both codecs fail")
+
+		errors := either.MonadFold(result,
+			F.Identity[validation.Errors],
+			func(int) validation.Errors { return nil },
+		)
+
+		require.NotNil(t, errors)
+		// Should have errors from both validation attempts
+		assert.GreaterOrEqual(t, len(errors), 2, "should have errors from both codecs")
+	})
+}
+
+// TestMonadAltNaming tests that the codec name is correctly generated
+func TestMonadAltNaming(t *testing.T) {
+	t.Run("generates correct name", func(t *testing.T) {
+		stringCodec := Id[string]()
+		anotherStringCodec := Id[string]()
+
+		altCodec := MonadAlt(
+			stringCodec,
+			func() Type[string, string, string] { return anotherStringCodec },
+		)
+
+		assert.Equal(t, "Alt[string]", altCodec.Name())
+	})
+}
+
+// TestMonadAltEncoding tests that encoding uses the first codec's encoder
+func TestMonadAltEncoding(t *testing.T) {
+	t.Run("uses first codec's encoder", func(t *testing.T) {
+		// Create a codec that encodes ints as strings with prefix
+		prefixedInt := MakeType(
+			"PrefixedInt",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					var n int
+					_, err := fmt.Sscanf(s, "NUM:%d", &n)
+					if err != nil {
+						return validation.FailureWithError[int](s, "expected NUM:n format")(err)(c)
+					}
+					return validation.Success(n)
+				}
+			},
+			func(n int) string {
+				return fmt.Sprintf("NUM:%d", n)
+			},
+		)
+
+		// Create a standard int from string codec
+		standardInt := IntFromString()
+
+		// Create alt codec
+		altCodec := MonadAlt(
+			prefixedInt,
+			func() Type[int, string, string] { return standardInt },
+		)
+
+		// Encode should use first codec's encoder
+		encoded := altCodec.Encode(42)
+		assert.Equal(t, "NUM:42", encoded)
+	})
+}
+
+// TestAltOperator tests the curried Alt function
+func TestAltOperator(t *testing.T) {
+	t.Run("creates reusable operator", func(t *testing.T) {
+		// Create a fallback operator that accepts any string
+		withStringFallback := Alt(func() Type[string, string, string] {
+			return Id[string]()
+		})
+
+		// Create a codec that only accepts "hello"
+		helloOnly := MakeType(
+			"HelloOnly",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					if s != "hello" {
+						return validation.FailureWithMessage[string](s, "must be 'hello'")(c)
+					}
+					return validation.Success(s)
+				}
+			},
+			F.Identity[string],
+		)
+
+		// Apply fallback to the codec
+		altCodec := withStringFallback(helloOnly)
+
+		// Test that it works
+		result1 := altCodec.Decode("hello")
+		assert.True(t, either.IsRight(result1))
+
+		result2 := altCodec.Decode("world")
+		assert.True(t, either.IsRight(result2))
+	})
+
+	t.Run("works in pipeline with F.Pipe", func(t *testing.T) {
+		// Create a codec pipeline with multiple fallbacks
+		baseCodec := MakeType(
+			"StrictInt",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					if s != "42" {
+						return validation.FailureWithMessage[int](s, "must be exactly '42'")(c)
+					}
+					return validation.Success(42)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		fallback1 := MakeType(
+			"Fallback1",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					if s != "100" {
+						return validation.FailureWithMessage[int](s, "must be exactly '100'")(c)
+					}
+					return validation.Success(100)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		fallback2 := MakeType(
+			"AnyInt",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					n, err := strconv.Atoi(s)
+					if err != nil {
+						return validation.FailureWithError[int](s, "not an integer")(err)(c)
+					}
+					return validation.Success(n)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		// Build pipeline with multiple alternatives
+		pipeline := F.Pipe2(
+			baseCodec,
+			Alt(func() Type[int, string, string] { return fallback1 }),
+			Alt(func() Type[int, string, string] { return fallback2 }),
+		)
+
+		// Test with "42" - should use base codec
+		result1 := pipeline.Decode("42")
+		assert.True(t, either.IsRight(result1))
+		value1 := either.GetOrElse(reader.Of[validation.Errors, int](0))(result1)
+		assert.Equal(t, 42, value1)
+
+		// Test with "100" - should use fallback1
+		result2 := pipeline.Decode("100")
+		assert.True(t, either.IsRight(result2))
+		value2 := either.GetOrElse(reader.Of[validation.Errors, int](0))(result2)
+		assert.Equal(t, 100, value2)
+
+		// Test with "999" - should use fallback2
+		result3 := pipeline.Decode("999")
+		assert.True(t, either.IsRight(result3))
+		value3 := either.GetOrElse(reader.Of[validation.Errors, int](0))(result3)
+		assert.Equal(t, 999, value3)
+	})
+}
+
+// TestAltLazyEvaluation tests that the second codec is only evaluated when needed
+func TestAltLazyEvaluation(t *testing.T) {
+	t.Run("does not evaluate second codec when first succeeds", func(t *testing.T) {
+		evaluated := false
+
+		stringCodec := Id[string]()
+
+		altCodec := MonadAlt(
+			stringCodec,
+			func() Type[string, string, string] {
+				evaluated = true
+				return Id[string]()
+			},
+		)
+
+		// Decode with first codec succeeding
+		result := altCodec.Decode("hello")
+		assert.True(t, either.IsRight(result))
+
+		// Second codec should not have been evaluated
+		assert.False(t, evaluated, "second codec should not be evaluated when first succeeds")
+	})
+
+	t.Run("evaluates second codec when first fails", func(t *testing.T) {
+		evaluated := false
+
+		// Create a codec that always fails
+		failingCodec := MakeType(
+			"Failing",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					return validation.FailureWithMessage[string](s, "always fails")(c)
+				}
+			},
+			F.Identity[string],
+		)
+
+		altCodec := MonadAlt(
+			failingCodec,
+			func() Type[string, string, string] {
+				evaluated = true
+				return Id[string]()
+			},
+		)
+
+		// Decode with first codec failing
+		result := altCodec.Decode("hello")
+		assert.True(t, either.IsRight(result))
+
+		// Second codec should have been evaluated
+		assert.True(t, evaluated, "second codec should be evaluated when first fails")
+	})
+}
+
+// TestAltWithComplexTypes tests Alt with more complex codec scenarios
+func TestAltWithComplexTypes(t *testing.T) {
+	t.Run("works with string length validation", func(t *testing.T) {
+		// Create codec that accepts strings of length 5
+		length5 := MakeType(
+			"Length5",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					if len(s) != 5 {
+						return validation.FailureWithMessage[string](s, "must be length 5")(c)
+					}
+					return validation.Success(s)
+				}
+			},
+			F.Identity[string],
+		)
+
+		// Create codec that accepts any string
+		anyString := Id[string]()
+
+		// Create alt codec
+		altCodec := MonadAlt(
+			length5,
+			func() Type[string, string, string] { return anyString },
+		)
+
+		// Test with length 5 - should use first codec
+		result1 := altCodec.Decode("hello")
+		assert.True(t, either.IsRight(result1))
+
+		// Test with different length - should fall back to second codec
+		result2 := altCodec.Decode("hi")
+		assert.True(t, either.IsRight(result2))
+	})
+}
+
+// TestAltTypeChecking tests that type checking works correctly
+func TestAltTypeChecking(t *testing.T) {
+	t.Run("type checking uses generic Is", func(t *testing.T) {
+		stringCodec := Id[string]()
+		anotherStringCodec := Id[string]()
+
+		altCodec := MonadAlt(
+			stringCodec,
+			func() Type[string, string, string] { return anotherStringCodec },
+		)
+
+		// Test Is with valid type
+		result1 := altCodec.Is("hello")
+		assert.True(t, either.IsRight(result1))
+
+		// Test Is with invalid type
+		result2 := altCodec.Is(42)
+		assert.True(t, either.IsLeft(result2))
+	})
+}
+
+// TestAltRoundTrip tests encoding and decoding round trips
+func TestAltRoundTrip(t *testing.T) {
+	t.Run("round-trip with first codec", func(t *testing.T) {
+		stringCodec := Id[string]()
+		anotherStringCodec := Id[string]()
+
+		altCodec := MonadAlt(
+			stringCodec,
+			func() Type[string, string, string] { return anotherStringCodec },
+		)
+
+		original := "hello"
+
+		// Decode
+		decodeResult := altCodec.Decode(original)
+		require.True(t, either.IsRight(decodeResult))
+
+		decoded := either.GetOrElse(reader.Of[validation.Errors, string](""))(decodeResult)
+
+		// Encode
+		encoded := altCodec.Encode(decoded)
+
+		// Verify
+		assert.Equal(t, original, encoded)
+	})
+
+	t.Run("round-trip with second codec", func(t *testing.T) {
+		// Create a codec that only accepts "hello"
+		helloOnly := MakeType(
+			"HelloOnly",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					if s != "hello" {
+						return validation.FailureWithMessage[string](s, "must be 'hello'")(c)
+					}
+					return validation.Success(s)
+				}
+			},
+			F.Identity[string],
+		)
+
+		anyString := Id[string]()
+
+		altCodec := MonadAlt(
+			helloOnly,
+			func() Type[string, string, string] { return anyString },
+		)
+
+		original := "world"
+
+		// Decode (will use second codec)
+		decodeResult := altCodec.Decode(original)
+		require.True(t, either.IsRight(decodeResult))
+
+		decoded := either.GetOrElse(reader.Of[validation.Errors, string](""))(decodeResult)
+
+		// Encode (uses first codec's encoder, which is identity)
+		encoded := altCodec.Encode(decoded)
+
+		// Verify
+		assert.Equal(t, original, encoded)
+	})
+}
+
+// TestAltErrorMessages tests that error messages are informative
+func TestAltErrorMessages(t *testing.T) {
+	t.Run("provides detailed error context", func(t *testing.T) {
+		// Create two codecs with specific error messages
+		codec1 := MakeType(
+			"Codec1",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.FailureWithMessage[int](i, "codec1 error")(c)
+				}
+			},
+			F.Identity[int],
+		)
+
+		codec2 := MakeType(
+			"Codec2",
+			Is[int](),
+			func(i int) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.FailureWithMessage[int](i, "codec2 error")(c)
+				}
+			},
+			F.Identity[int],
+		)
+
+		altCodec := MonadAlt(
+			codec1,
+			func() Type[int, int, int] { return codec2 },
+		)
+
+		result := altCodec.Decode(42)
+
+		assert.True(t, either.IsLeft(result))
+
+		errors := either.MonadFold(result,
+			F.Identity[validation.Errors],
+			func(int) validation.Errors { return nil },
+		)
+
+		require.NotNil(t, errors)
+		require.GreaterOrEqual(t, len(errors), 2)
+
+		// Check that both error messages are present
+		messages := make([]string, len(errors))
+		for i, err := range errors {
+			messages[i] = err.Messsage
+		}
+
+		hasCodec1Error := false
+		hasCodec2Error := false
+		for _, msg := range messages {
+			if msg == "codec1 error" {
+				hasCodec1Error = true
+			}
+			if msg == "codec2 error" {
+				hasCodec2Error = true
+			}
+		}
+
+		assert.True(t, hasCodec1Error, "should have error from first codec")
+		assert.True(t, hasCodec2Error, "should have error from second codec")
+	})
+}
+
+// TestAltMonoid tests the AltMonoid function
+func TestAltMonoid(t *testing.T) {
+	t.Run("with default value as zero", func(t *testing.T) {
+		// Create a monoid with a default value of 0
+		m := AltMonoid(func() Type[int, string, string] {
+			return MakeType(
+				"DefaultZero",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.Success(0)
+					}
+				},
+				strconv.Itoa,
+			)
+		})
+
+		// Create codecs
+		intFromString := IntFromString()
+		failing := MakeType(
+			"Failing",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.FailureWithMessage[int](s, "always fails")(c)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		t.Run("first success wins", func(t *testing.T) {
+			// Combine two successful codecs - first should win
+			codec1 := MakeType(
+				"Returns10",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.Success(10)
+					}
+				},
+				strconv.Itoa,
+			)
+			codec2 := MakeType(
+				"Returns20",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.Success(20)
+					}
+				},
+				strconv.Itoa,
+			)
+
+			combined := m.Concat(codec1, codec2)
+			result := combined.Decode("input")
+
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, int](0))(result)
+			assert.Equal(t, 10, value, "first success should win")
+		})
+
+		t.Run("falls back to second when first fails", func(t *testing.T) {
+			combined := m.Concat(failing, intFromString)
+			result := combined.Decode("42")
+
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, int](0))(result)
+			assert.Equal(t, 42, value)
+		})
+
+		t.Run("uses zero when both fail", func(t *testing.T) {
+			combined := m.Concat(failing, m.Empty())
+			result := combined.Decode("invalid")
+
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, int](-1))(result)
+			assert.Equal(t, 0, value, "should use default zero value")
+		})
+	})
+
+	t.Run("with failing zero", func(t *testing.T) {
+		// Create a monoid with a failing zero
+		m := AltMonoid(func() Type[int, string, string] {
+			return MakeType(
+				"NoDefault",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.FailureWithMessage[int](s, "no default available")(c)
+					}
+				},
+				strconv.Itoa,
+			)
+		})
+
+		failing1 := MakeType(
+			"Failing1",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.FailureWithMessage[int](s, "error 1")(c)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		failing2 := MakeType(
+			"Failing2",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.FailureWithMessage[int](s, "error 2")(c)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		t.Run("aggregates all errors when all fail", func(t *testing.T) {
+			combined := m.Concat(m.Concat(failing1, failing2), m.Empty())
+			result := combined.Decode("input")
+
+			assert.True(t, either.IsLeft(result))
+
+			errors := either.MonadFold(result,
+				F.Identity[validation.Errors],
+				func(int) validation.Errors { return nil },
+			)
+
+			require.NotNil(t, errors)
+			// Should have errors from all three: failing1, failing2, and zero
+			assert.GreaterOrEqual(t, len(errors), 3)
+
+			messages := make([]string, len(errors))
+			for i, err := range errors {
+				messages[i] = err.Messsage
+			}
+
+			hasError1 := false
+			hasError2 := false
+			hasNoDefault := false
+			for _, msg := range messages {
+				if msg == "error 1" {
+					hasError1 = true
+				}
+				if msg == "error 2" {
+					hasError2 = true
+				}
+				if msg == "no default available" {
+					hasNoDefault = true
+				}
+			}
+
+			assert.True(t, hasError1, "should have error from failing1")
+			assert.True(t, hasError2, "should have error from failing2")
+			assert.True(t, hasNoDefault, "should have error from zero")
+		})
+	})
+
+	t.Run("chaining multiple fallbacks", func(t *testing.T) {
+		m := AltMonoid(func() Type[string, string, string] {
+			return MakeType(
+				"Default",
+				Is[string](),
+				func(s string) Decode[Context, string] {
+					return func(c Context) Validation[string] {
+						return validation.Success("default")
+					}
+				},
+				F.Identity[string],
+			)
+		})
+
+		primary := MakeType(
+			"Primary",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					if s == "primary" {
+						return validation.Success("from primary")
+					}
+					return validation.FailureWithMessage[string](s, "not primary")(c)
+				}
+			},
+			F.Identity[string],
+		)
+
+		secondary := MakeType(
+			"Secondary",
+			Is[string](),
+			func(s string) Decode[Context, string] {
+				return func(c Context) Validation[string] {
+					if s == "secondary" {
+						return validation.Success("from secondary")
+					}
+					return validation.FailureWithMessage[string](s, "not secondary")(c)
+				}
+			},
+			F.Identity[string],
+		)
+
+		// Chain: try primary, then secondary, then default
+		combined := m.Concat(m.Concat(primary, secondary), m.Empty())
+
+		t.Run("uses primary when it succeeds", func(t *testing.T) {
+			result := combined.Decode("primary")
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, string](""))(result)
+			assert.Equal(t, "from primary", value)
+		})
+
+		t.Run("uses secondary when primary fails", func(t *testing.T) {
+			result := combined.Decode("secondary")
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, string](""))(result)
+			assert.Equal(t, "from secondary", value)
+		})
+
+		t.Run("uses default when both fail", func(t *testing.T) {
+			result := combined.Decode("other")
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, string](""))(result)
+			assert.Equal(t, "default", value)
+		})
+	})
+
+	t.Run("satisfies monoid laws", func(t *testing.T) {
+		m := AltMonoid(func() Type[int, string, string] {
+			return MakeType(
+				"DefaultZero",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.Success(0)
+					}
+				},
+				strconv.Itoa,
+			)
+		})
+
+		codec1 := MakeType(
+			"Codec1",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(10)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		codec2 := MakeType(
+			"Codec2",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(20)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		codec3 := MakeType(
+			"Codec3",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(30)
+				}
+			},
+			strconv.Itoa,
+		)
+
+		t.Run("left identity", func(t *testing.T) {
+			// m.Concat(m.Empty(), codec) should behave like codec
+			// But with AltMonoid, if codec fails, it falls back to empty
+			combined := m.Concat(m.Empty(), codec1)
+			result := combined.Decode("input")
+
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, int](-1))(result)
+			// Empty (0) comes first, so it wins
+			assert.Equal(t, 0, value)
+		})
+
+		t.Run("right identity", func(t *testing.T) {
+			// m.Concat(codec, m.Empty()) tries codec first, falls back to empty
+			combined := m.Concat(codec1, m.Empty())
+			result := combined.Decode("input")
+
+			assert.True(t, either.IsRight(result))
+			value := either.GetOrElse(reader.Of[validation.Errors, int](-1))(result)
+			assert.Equal(t, 10, value, "codec1 should win")
+		})
+
+		t.Run("associativity", func(t *testing.T) {
+			// For AltMonoid, first success wins
+			left := m.Concat(m.Concat(codec1, codec2), codec3)
+			right := m.Concat(codec1, m.Concat(codec2, codec3))
+
+			resultLeft := left.Decode("input")
+			resultRight := right.Decode("input")
+
+			assert.True(t, either.IsRight(resultLeft))
+			assert.True(t, either.IsRight(resultRight))
+
+			valueLeft := either.GetOrElse(reader.Of[validation.Errors, int](-1))(resultLeft)
+			valueRight := either.GetOrElse(reader.Of[validation.Errors, int](-1))(resultRight)
+
+			// Both should return 10 (first success)
+			assert.Equal(t, valueLeft, valueRight)
+			assert.Equal(t, 10, valueLeft)
+		})
+	})
+
+	t.Run("encoding uses first codec", func(t *testing.T) {
+		m := AltMonoid(func() Type[int, string, string] {
+			return MakeType(
+				"Default",
+				Is[int](),
+				func(s string) Decode[Context, int] {
+					return func(c Context) Validation[int] {
+						return validation.Success(0)
+					}
+				},
+				func(n int) string { return "DEFAULT" },
+			)
+		})
+
+		codec1 := MakeType(
+			"Codec1",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(42)
+				}
+			},
+			func(n int) string { return fmt.Sprintf("FIRST:%d", n) },
+		)
+
+		codec2 := MakeType(
+			"Codec2",
+			Is[int](),
+			func(s string) Decode[Context, int] {
+				return func(c Context) Validation[int] {
+					return validation.Success(100)
+				}
+			},
+			func(n int) string { return fmt.Sprintf("SECOND:%d", n) },
+		)
+
+		combined := m.Concat(codec1, codec2)
+
+		// Encoding should use first codec's encoder
+		encoded := combined.Encode(42)
+		assert.Equal(t, "FIRST:42", encoded)
+	})
+}

v2/optics/codec/either.go

@@ -18,11 +18,10 @@ package codec
 import (
 	"fmt"
 
-	"github.com/IBM/fp-go/v2/array"
 	"github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/lazy"
 	"github.com/IBM/fp-go/v2/optics/codec/validate"
-	"github.com/IBM/fp-go/v2/optics/codec/validation"
 )
 
 // encodeEither creates an encoder for Either[A, B] values.
@@ -151,33 +150,20 @@ func validateEither[A, B, O, I any](
 	rightItem Type[B, O, I],
 ) Validate[I, either.Either[A, B]] {
 
-	// F.Pipe1(
-	// 	leftItem.Decode,
-	// 	decode.OrElse()
-	// )
+	valRight := F.Pipe1(
+		rightItem.Validate,
+		validate.Map[I, B](either.Right[A]),
+	)
 
-	return func(i I) Decode[Context, either.Either[A, B]] {
-		valRight := rightItem.Validate(i)
-		valLeft := leftItem.Validate(i)
+	valLeft := F.Pipe1(
+		leftItem.Validate,
+		validate.Map[I, A](either.Left[B]),
+	)
 
-		return func(ctx Context) Validation[either.Either[A, B]] {
-
-			resRight := valRight(ctx)
-
-			return either.Fold(
-				func(rightErrors validate.Errors) Validation[either.Either[A, B]] {
-					resLeft := valLeft(ctx)
-					return either.Fold(
-						func(leftErrors validate.Errors) Validation[either.Either[A, B]] {
-							return validation.Failures[either.Either[A, B]](array.Concat(leftErrors)(rightErrors))
-						},
-						F.Flow2(either.Left[B, A], validation.Of),
-					)(resLeft)
-				},
-				F.Flow2(either.Right[A, B], validation.Of),
-			)(resRight)
-		}
-	}
+	return F.Pipe1(
+		valRight,
+		validate.Alt(lazy.Of(valLeft)),
+	)
 }
 
 // Either creates a codec for Either[A, B] values.
@@ -270,12 +256,9 @@ func Either[A, B, O, I any](
 	leftItem Type[A, O, I],
 	rightItem Type[B, O, I],
 ) Type[either.Either[A, B], O, I] {
-	name := fmt.Sprintf("Either[%s, %s]", leftItem.Name(), rightItem.Name())
-	isEither := Is[either.Either[A, B]]()
-
 	return MakeType(
-		name,
-		isEither,
+		fmt.Sprintf("Either[%s, %s]", leftItem.Name(), rightItem.Name()),
+		Is[either.Either[A, B]](),
 		validateEither(leftItem, rightItem),
 		encodeEither(leftItem, rightItem),
 	)

v2/optics/codec/either_test.go

@@ -342,6 +342,27 @@ func TestEitherErrorAccumulation(t *testing.T) {
 
 		require.NotNil(t, errors)
 		// Should have errors from both string and int validation attempts
-		assert.NotEmpty(t, errors)
+		assert.GreaterOrEqual(t, len(errors), 2, "Should have at least 2 errors (one from Right validation, one from Left validation)")
+
+		// Verify we have errors from both validation attempts
+		messages := make([]string, len(errors))
+		for i, err := range errors {
+			messages[i] = err.Messsage
+		}
+
+		// Check that we have errors related to both validations
+		hasIntError := false
+		hasStringError := false
+		for _, msg := range messages {
+			if msg == "expected integer string" || msg == "must be positive" {
+				hasIntError = true
+			}
+			if msg == "must not be empty" {
+				hasStringError = true
+			}
+		}
+
+		assert.True(t, hasIntError, "Should have error from integer validation (Right branch)")
+		assert.True(t, hasStringError, "Should have error from string validation (Left branch)")
 	})
 }

v2/optics/codec/types.go

@@ -4,6 +4,7 @@ import (
 	"github.com/IBM/fp-go/v2/endomorphism"
 	"github.com/IBM/fp-go/v2/internal/formatting"
 	"github.com/IBM/fp-go/v2/lazy"
+	"github.com/IBM/fp-go/v2/monoid"
 	"github.com/IBM/fp-go/v2/optics/codec/decode"
 	"github.com/IBM/fp-go/v2/optics/codec/validate"
 	"github.com/IBM/fp-go/v2/optics/codec/validation"
@@ -40,6 +41,27 @@ type (
 
 	// Codec combines a Decoder and an Encoder for bidirectional transformations.
 	// It can decode input I to type A and encode type A to output O.
+	//
+	// This is a simple struct that pairs a decoder with an encoder, providing
+	// the basic building blocks for bidirectional data transformation. Unlike
+	// the Type interface, Codec is a concrete struct without validation context
+	// or type checking capabilities.
+	//
+	// Type Parameters:
+	//   - I: The input type to decode from
+	//   - O: The output type to encode to
+	//   - A: The intermediate type (decoded to, encoded from)
+	//
+	// Fields:
+	//   - Decode: A decoder that transforms I to A
+	//   - Encode: An encoder that transforms A to O
+	//
+	// Example:
+	//   A Codec[string, string, int] can decode strings to integers and
+	//   encode integers back to strings.
+	//
+	// Note: For most use cases, prefer using the Type interface which provides
+	// additional validation and type checking capabilities.
 	Codec[I, O, A any] struct {
 		Decode decoder.Decoder[I, A]
 		Encode encoder.Encoder[O, A]
@@ -55,16 +77,82 @@ type (
 
 	// Validate is a function that validates input I to produce type A.
 	// It takes an input and returns a Reader that depends on the validation Context.
+	//
+	// The Validate type is the core validation abstraction, defined as:
+	//   Reader[I, Decode[Context, A]]
+	//
+	// This means:
+	//  1. It takes an input of type I
+	//  2. Returns a Reader that depends on validation Context
+	//  3. That Reader produces a Validation[A] (Either[Errors, A])
+	//
+	// This layered structure allows validators to:
+	//   - Access the input value
+	//   - Track validation context (path in nested structures)
+	//   - Accumulate multiple validation errors
+	//   - Compose with other validators
+	//
+	// Example:
+	//   A Validate[string, int] takes a string and returns a context-aware
+	//   function that validates and converts it to an integer.
 	Validate[I, A any] = validate.Validate[I, A]
 
 	// Decode is a function that decodes input I to type A with validation.
 	// It returns a Validation result directly.
+	//
+	// The Decode type is defined as:
+	//   Reader[I, Validation[A]]
+	//
+	// This is simpler than Validate as it doesn't require explicit context passing.
+	// The context is typically created automatically when the decoder is invoked.
+	//
+	// Decode is used when:
+	//   - You don't need to manually manage validation context
+	//   - You want a simpler API for basic validation
+	//   - You're working at the top level of validation
+	//
+	// Example:
+	//   A Decode[string, int] takes a string and returns a Validation[int]
+	//   which is Either[Errors, int].
 	Decode[I, A any] = decode.Decode[I, A]
 
 	// Encode is a function that encodes type A to output O.
+	//
+	// Encode is simply a Reader[A, O], which is a function from A to O.
+	// Encoders are pure functions with no error handling - they assume
+	// the input is valid.
+	//
+	// Encoding is the inverse of decoding:
+	//   - Decoding: I -> Validation[A] (may fail)
+	//   - Encoding: A -> O (always succeeds)
+	//
+	// Example:
+	//   An Encode[int, string] takes an integer and returns its string
+	//   representation.
 	Encode[A, O any] = Reader[A, O]
 
 	// Decoder is an interface for types that can decode and validate input.
+	//
+	// A Decoder transforms input of type I into a validated value of type A,
+	// providing detailed error information when validation fails. It supports
+	// both context-aware validation (via Validate) and direct decoding (via Decode).
+	//
+	// Type Parameters:
+	//   - I: The input type to decode from
+	//   - A: The target type to decode to
+	//
+	// Methods:
+	//   - Name(): Returns a descriptive name for this decoder (used in error messages)
+	//   - Validate(I): Returns a context-aware validation function that can track
+	//     the path through nested structures
+	//   - Decode(I): Directly decodes input to a Validation result with a fresh context
+	//
+	// The Validate method is more flexible as it returns a Reader that can be called
+	// with different contexts, while Decode is a convenience method that creates a
+	// new context automatically.
+	//
+	// Example:
+	//   A Decoder[string, int] can decode strings to integers with validation.
 	Decoder[I, A any] interface {
 		Name() string
 		Validate(I) Decode[Context, A]
@@ -72,13 +160,76 @@ type (
 	}
 
 	// Encoder is an interface for types that can encode values.
+	//
+	// An Encoder transforms values of type A into output format O. This is the
+	// inverse operation of decoding, allowing bidirectional transformations.
+	//
+	// Type Parameters:
+	//   - A: The source type to encode from
+	//   - O: The output type to encode to
+	//
+	// Methods:
+	//   - Encode(A): Transforms a value of type A into output format O
+	//
+	// Encoders are pure functions with no validation or error handling - they
+	// assume the input is valid. Validation should be performed during decoding.
+	//
+	// Example:
+	//   An Encoder[int, string] can encode integers to their string representation.
 	Encoder[A, O any] interface {
 		// Encode transforms a value of type A into output format O.
 		Encode(A) O
 	}
+
 	// Type is a bidirectional codec that combines encoding, decoding, validation,
 	// and type checking capabilities. It represents a complete specification of
 	// how to work with a particular type.
+	//
+	// Type is the central abstraction in the codec package, providing:
+	//   - Decoding: Transform input I to validated type A
+	//   - Encoding: Transform type A to output O
+	//   - Validation: Context-aware validation with detailed error reporting
+	//   - Type Checking: Runtime type verification via Is()
+	//   - Formatting: Human-readable type descriptions via Name()
+	//
+	// Type Parameters:
+	//   - A: The target type (what we decode to and encode from)
+	//   - O: The output type (what we encode to)
+	//   - I: The input type (what we decode from)
+	//
+	// Common patterns:
+	//   - Type[A, A, A]: Identity codec (no transformation)
+	//   - Type[A, string, string]: String-based serialization
+	//   - Type[A, any, any]: Generic codec accepting any input/output
+	//   - Type[A, JSON, JSON]: JSON codec
+	//
+	// Methods:
+	//   - Name(): Returns the codec's descriptive name
+	//   - Validate(I): Returns context-aware validation function
+	//   - Decode(I): Decodes input with automatic context creation
+	//   - Encode(A): Encodes value to output format
+	//   - AsDecoder(): Returns this Type as a Decoder interface
+	//   - AsEncoder(): Returns this Type as an Encoder interface
+	//   - Is(any): Checks if a value can be converted to type A
+	//
+	// Example usage:
+	//   intCodec := codec.Int()                    // Type[int, int, any]
+	//   stringCodec := codec.String()              // Type[string, string, any]
+	//   intFromString := codec.IntFromString()     // Type[int, string, string]
+	//
+	//   // Decode
+	//   result := intFromString.Decode("42")       // Validation[int]
+	//
+	//   // Encode
+	//   str := intFromString.Encode(42)            // "42"
+	//
+	//   // Type check
+	//   isInt := intCodec.Is(42)                   // Right(42)
+	//   notInt := intCodec.Is("42")                // Left(error)
+	//
+	// Composition:
+	//   Types can be composed using operators like Alt, Map, Chain, and Pipe
+	//   to build complex codecs from simpler ones.
 	Type[A, O, I any] interface {
 		Formattable
 		Decoder[I, A]
@@ -99,6 +250,92 @@ type (
 	// contain a value of type A. It provides a way to preview and review values.
 	Prism[S, A any] = prism.Prism[S, A]
 
-	// Refinement represents the concept that B is a specialized type of A
+	// Refinement represents the concept that B is a specialized type of A.
+	// It's an alias for Prism[A, B], providing a semantic name for type refinement operations.
+	//
+	// A refinement allows you to:
+	//   - Preview: Try to extract a B from an A (may fail if A is not a B)
+	//   - Review: Inject a B back into an A
+	//
+	// This is useful for working with subtypes, validated types, or constrained types.
+	//
+	// Example:
+	//   - Refinement[int, PositiveInt] - refines int to positive integers only
+	//   - Refinement[string, NonEmptyString] - refines string to non-empty strings
+	//   - Refinement[any, User] - refines any to User type
 	Refinement[A, B any] = Prism[A, B]
+
+	// Kleisli represents a Kleisli arrow in the codec context.
+	// It's a function that takes a value of type A and returns a codec Type[B, O, I].
+	//
+	// This is the fundamental building block for codec transformations and compositions.
+	// Kleisli arrows allow you to:
+	//   - Chain codec operations
+	//   - Build dependent codecs (where the next codec depends on the previous result)
+	//   - Create codec pipelines
+	//
+	// Type Parameters:
+	//   - A: The input type to the function
+	//   - B: The target type that the resulting codec decodes to
+	//   - O: The output type that the resulting codec encodes to
+	//   - I: The input type that the resulting codec decodes from
+	//
+	// Example:
+	//   A Kleisli[string, int, string, string] takes a string and returns a codec
+	//   that can decode strings to ints and encode ints to strings.
+	Kleisli[A, B, O, I any] = Reader[A, Type[B, O, I]]
+
+	// Operator is a specialized Kleisli arrow that transforms codecs.
+	// It takes a codec Type[A, O, I] and returns a new codec Type[B, O, I].
+	//
+	// Operators are the primary way to build codec transformation pipelines.
+	// They enable functional composition of codec transformations using F.Pipe.
+	//
+	// Type Parameters:
+	//   - A: The source type that the input codec decodes to
+	//   - B: The target type that the output codec decodes to
+	//   - O: The output type (same for both input and output codecs)
+	//   - I: The input type (same for both input and output codecs)
+	//
+	// Common operators include:
+	//   - Map: Transforms the decoded value
+	//   - Chain: Sequences dependent codec operations
+	//   - Alt: Provides alternative fallback codecs
+	//   - Refine: Adds validation constraints
+	//
+	// Example:
+	//   An Operator[int, PositiveInt, int, any] transforms a codec that decodes
+	//   to int into a codec that decodes to PositiveInt (with validation).
+	//
+	// Usage with F.Pipe:
+	//   codec := F.Pipe2(
+	//       baseCodec,
+	//       operator1,  // Operator[A, B, O, I]
+	//       operator2,  // Operator[B, C, O, I]
+	//   )
+	Operator[A, B, O, I any] = Kleisli[Type[A, O, I], B, O, I]
+
+	// Monoid represents an algebraic structure with an associative binary operation
+	// and an identity element.
+	//
+	// A Monoid[A] provides:
+	//   - Empty(): Returns the identity element
+	//   - Concat(A, A): Combines two values associatively
+	//
+	// Monoid laws:
+	//   1. Left Identity: Concat(Empty(), a) = a
+	//   2. Right Identity: Concat(a, Empty()) = a
+	//   3. Associativity: Concat(Concat(a, b), c) = Concat(a, Concat(b, c))
+	//
+	// In the codec context, monoids are used to:
+	//   - Combine multiple codecs with specific semantics
+	//   - Build codec chains with fallback behavior (AltMonoid)
+	//   - Aggregate validation results (ApplicativeMonoid)
+	//   - Compose codec transformations
+	//
+	// Example monoids for codecs:
+	//   - AltMonoid: First success wins (alternative semantics)
+	//   - ApplicativeMonoid: Combines successful results using inner monoid
+	//   - AlternativeMonoid: Combines applicative and alternative behaviors
+	Monoid[A any] = monoid.Monoid[A]
 )

v2/optics/codec/validation/monad.go

@@ -486,16 +486,17 @@ func OrElse[A any](f Kleisli[Errors, A]) Operator[A, A] {
 //   - Building validation pipelines with fallback logic
 //   - Implementing optional validation with defaults
 //
-// **Key behavior**: Unlike error accumulation in [MonadAp], MonadAlt does NOT accumulate errors.
-// When falling back to the second validation, the first validation's errors are discarded.
-// This is the standard Alt behavior - it's about choosing alternatives, not combining errors.
+// **Key behavior**: When both validations fail, MonadAlt DOES accumulate errors from both
+// validations using the Errors monoid. This is different from standard Either Alt behavior.
+// The error accumulation happens through the underlying ChainLeft/chainErrors mechanism.
 //
 // The second parameter is lazy (Lazy[Validation[A]]) to avoid unnecessary computation when
 // the first validation succeeds. The second validation is only evaluated if needed.
 //
 // Behavior:
 //   - First succeeds: returns first validation (second is not evaluated)
-//   - First fails: evaluates and returns second validation (first errors discarded)
+//   - First fails, second succeeds: returns second validation
+//   - Both fail: aggregates errors from both validations
 //
 // This is useful for:
 //   - Fallback values: provide defaults when primary validation fails
@@ -547,7 +548,7 @@ func OrElse[A any](f Kleisli[Errors, A]) Operator[A, A] {
 //	)
 //	// Tries: env var → file → default (uses first that succeeds)
 //
-// Example - No error accumulation:
+// Example - Error accumulation when both fail:
 //
 //	v1 := Failures[int](Errors{
 //	    &ValidationError{Messsage: "error 1"},
@@ -559,8 +560,8 @@ func OrElse[A any](f Kleisli[Errors, A]) Operator[A, A] {
 //	    })
 //	}
 //	result := MonadAlt(v1, v2)
-//	// Result: Failures with only ["error 3"]
-//	// The errors from v1 are discarded (not accumulated)
+//	// Result: Failures with ALL errors ["error 1", "error 2", "error 3"]
+//	// The errors from v1 are aggregated with errors from v2
 func MonadAlt[A any](first Validation[A], second Lazy[Validation[A]]) Validation[A] {
 	return MonadChainLeft(first, function.Ignore1of1[Errors](second))
 }

v2/readerio/consumer.go

@@ -3,7 +3,7 @@ package readerio
 import "github.com/IBM/fp-go/v2/io"
 
 //go:inline
-func ChainConsumer[R, A any](c Consumer[A]) Operator[R, A, struct{}] {
+func ChainConsumer[R, A any](c Consumer[A]) Operator[R, A, Void] {
 	return ChainIOK[R](io.FromConsumer(c))
 }
 

v2/readerio/types.go

@@ -18,6 +18,7 @@ package readerio
 import (
 	"github.com/IBM/fp-go/v2/consumer"
 	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
@@ -66,4 +67,6 @@ type (
 	// 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]
+
+	Void = function.Void
 )

v2/readerioresult/consumer.go

@@ -1,14 +1,107 @@
+// 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 (
 	"github.com/IBM/fp-go/v2/readerioeither"
 )
 
+// ChainConsumer chains a consumer (side-effect function) into a ReaderIOResult computation,
+// replacing the success value with Void (empty struct).
+//
+// This is useful for performing side effects (like logging, printing, or writing to a file)
+// where you don't need to preserve the original value. The consumer is only executed if the
+// computation succeeds; if it fails with an error, the consumer is skipped.
+//
+// Type parameters:
+//   - R: The context/environment type
+//   - A: The value type to consume
+//
+// Parameters:
+//   - c: A consumer function that performs a side effect on the value
+//
+// Returns:
+//
+//	An Operator that executes the consumer and returns Void on success
+//
+// Example:
+//
+//	import (
+//	    "context"
+//	    "fmt"
+//	    RIO "github.com/IBM/fp-go/v2/readerioresult"
+//	)
+//
+//	// Log a value and discard it
+//	logValue := RIO.ChainConsumer[context.Context](func(x int) {
+//	    fmt.Printf("Value: %d\n", x)
+//	})
+//
+//	computation := F.Pipe1(
+//	    RIO.Of[context.Context](42),
+//	    logValue,
+//	)
+//	// Prints "Value: 42" and returns result.Of(struct{}{})
+//
 //go:inline
-func ChainConsumer[R, A any](c Consumer[A]) Operator[R, A, struct{}] {
+func ChainConsumer[R, A any](c Consumer[A]) Operator[R, A, Void] {
 	return readerioeither.ChainConsumer[R, error](c)
 }
 
+// ChainFirstConsumer chains a consumer into a ReaderIOResult computation while preserving
+// the original value.
+//
+// This is useful for performing side effects (like logging, printing, or metrics collection)
+// where you want to keep the original value for further processing. The consumer is only
+// executed if the computation succeeds; if it fails with an error, the consumer is skipped
+// and the error is propagated.
+//
+// Type parameters:
+//   - R: The context/environment type
+//   - A: The value type to consume and preserve
+//
+// Parameters:
+//   - c: A consumer function that performs a side effect on the value
+//
+// Returns:
+//
+//	An Operator that executes the consumer and returns the original value on success
+//
+// Example:
+//
+//	import (
+//	    "context"
+//	    "fmt"
+//	    F "github.com/IBM/fp-go/v2/function"
+//	    N "github.com/IBM/fp-go/v2/number"
+//	    RIO "github.com/IBM/fp-go/v2/readerioresult"
+//	)
+//
+//	// Log a value but keep it for further processing
+//	logValue := RIO.ChainFirstConsumer[context.Context](func(x int) {
+//	    fmt.Printf("Processing: %d\n", x)
+//	})
+//
+//	computation := F.Pipe2(
+//	    RIO.Of[context.Context](10),
+//	    logValue,
+//	    RIO.Map[context.Context](N.Mul(2)),
+//	)
+//	// Prints "Processing: 10" and returns result.Of(20)
+//
 //go:inline
 func ChainFirstConsumer[R, A any](c Consumer[A]) Operator[R, A, A] {
 	return readerioeither.ChainFirstConsumer[R, error](c)

v2/readerioresult/consumer_test.go

@@ -0,0 +1,362 @@
+// 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"
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	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"
+)
+
+// TestChainConsumer_Success tests that ChainConsumer executes the consumer
+// and returns Void when the computation succeeds
+func TestChainConsumer_Success(t *testing.T) {
+	// Track if consumer was called
+	var consumed int
+	consumer := func(x int) {
+		consumed = x
+	}
+
+	// Create a successful computation and chain the consumer
+	computation := F.Pipe1(
+		Of[context.Context](42),
+		ChainConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was called with correct value
+	assert.Equal(t, 42, consumed)
+
+	// Verify result is successful with Void
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		val := result.GetOrElse(func(error) Void { return Void{} })(res)
+		assert.Equal(t, Void{}, val)
+	}
+}
+
+// TestChainConsumer_Failure tests that ChainConsumer does not execute
+// the consumer when the computation fails
+func TestChainConsumer_Failure(t *testing.T) {
+	// Track if consumer was called
+	consumerCalled := false
+	consumer := func(x int) {
+		consumerCalled = true
+	}
+
+	// Create a failing computation
+	expectedErr := errors.New("test error")
+	computation := F.Pipe1(
+		Left[context.Context, int](expectedErr),
+		ChainConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was NOT called
+	assert.False(t, consumerCalled)
+
+	// Verify result is an error
+	assert.True(t, result.IsLeft(res))
+}
+
+// TestChainConsumer_MultipleOperations tests chaining multiple operations
+// with ChainConsumer in a pipeline
+func TestChainConsumer_MultipleOperations(t *testing.T) {
+	// Track consumer calls
+	var values []int
+	consumer := func(x int) {
+		values = append(values, x)
+	}
+
+	// Create a pipeline with multiple operations
+	computation := F.Pipe2(
+		Of[context.Context](10),
+		Map[context.Context](N.Mul(2)),
+		ChainConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was called with transformed value
+	assert.Equal(t, []int{20}, values)
+
+	// Verify result is successful
+	assert.True(t, result.IsRight(res))
+}
+
+// TestChainFirstConsumer_Success tests that ChainFirstConsumer executes
+// the consumer and preserves the original value
+func TestChainFirstConsumer_Success(t *testing.T) {
+	// Track if consumer was called
+	var consumed int
+	consumer := func(x int) {
+		consumed = x
+	}
+
+	// Create a successful computation and chain the consumer
+	computation := F.Pipe1(
+		Of[context.Context](42),
+		ChainFirstConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was called with correct value
+	assert.Equal(t, 42, consumed)
+
+	// Verify result is successful and preserves original value
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		val := result.GetOrElse(func(error) int { return 0 })(res)
+		assert.Equal(t, 42, val)
+	}
+}
+
+// TestChainFirstConsumer_Failure tests that ChainFirstConsumer does not
+// execute the consumer when the computation fails
+func TestChainFirstConsumer_Failure(t *testing.T) {
+	// Track if consumer was called
+	consumerCalled := false
+	consumer := func(x int) {
+		consumerCalled = true
+	}
+
+	// Create a failing computation
+	expectedErr := errors.New("test error")
+	computation := F.Pipe1(
+		Left[context.Context, int](expectedErr),
+		ChainFirstConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was NOT called
+	assert.False(t, consumerCalled)
+
+	// Verify result is an error
+	assert.True(t, result.IsLeft(res))
+}
+
+// TestChainFirstConsumer_PreservesValue tests that ChainFirstConsumer
+// preserves the value for further processing
+func TestChainFirstConsumer_PreservesValue(t *testing.T) {
+	// Track consumer calls
+	var logged []int
+	logger := func(x int) {
+		logged = append(logged, x)
+	}
+
+	// Create a pipeline that logs intermediate values
+	computation := F.Pipe3(
+		Of[context.Context](10),
+		ChainFirstConsumer[context.Context](logger),
+		Map[context.Context](N.Mul(2)),
+		ChainFirstConsumer[context.Context](logger),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer was called at each step
+	assert.Equal(t, []int{10, 20}, logged)
+
+	// Verify final result
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		val := result.GetOrElse(func(error) int { return 0 })(res)
+		assert.Equal(t, 20, val)
+	}
+}
+
+// TestChainFirstConsumer_WithMap tests combining ChainFirstConsumer with Map
+func TestChainFirstConsumer_WithMap(t *testing.T) {
+	// Track intermediate values
+	var intermediate int
+	consumer := func(x int) {
+		intermediate = x
+	}
+
+	// Create a pipeline with logging and transformation
+	computation := F.Pipe2(
+		Of[context.Context](5),
+		ChainFirstConsumer[context.Context](consumer),
+		Map[context.Context](N.Mul(3)),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer saw original value
+	assert.Equal(t, 5, intermediate)
+
+	// Verify final result is transformed
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		val := result.GetOrElse(func(error) int { return 0 })(res)
+		assert.Equal(t, 15, val)
+	}
+}
+
+// TestChainConsumer_WithContext tests that consumers work with context
+func TestChainConsumer_WithContext(t *testing.T) {
+	type Config struct {
+		Multiplier int
+	}
+
+	// Track consumer calls
+	var consumed int
+	consumer := func(x int) {
+		consumed = x
+	}
+
+	// Create a computation that uses context
+	computation := F.Pipe2(
+		Of[Config](10),
+		Map[Config](N.Mul(2)),
+		ChainConsumer[Config](consumer),
+	)
+
+	// Execute with context
+	cfg := Config{Multiplier: 3}
+	res := computation(cfg)()
+
+	// Verify consumer was called
+	assert.Equal(t, 20, consumed)
+
+	// Verify result is successful
+	assert.True(t, result.IsRight(res))
+}
+
+// TestChainFirstConsumer_SideEffects tests that ChainFirstConsumer
+// can be used for side effects like logging
+func TestChainFirstConsumer_SideEffects(t *testing.T) {
+	// Simulate a logging side effect
+	var logs []string
+	logValue := func(x string) {
+		logs = append(logs, "Processing: "+x)
+	}
+
+	// Create a pipeline with logging
+	computation := F.Pipe3(
+		Of[context.Context]("hello"),
+		ChainFirstConsumer[context.Context](logValue),
+		Map[context.Context](S.Append(" world")),
+		ChainFirstConsumer[context.Context](logValue),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify logs were created
+	assert.Equal(t, []string{
+		"Processing: hello",
+		"Processing: hello world",
+	}, logs)
+
+	// Verify final result
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		val := result.GetOrElse(func(error) string { return "" })(res)
+		assert.Equal(t, "hello world", val)
+	}
+}
+
+// TestChainConsumer_ComplexType tests consumers with complex types
+func TestChainConsumer_ComplexType(t *testing.T) {
+	type User struct {
+		Name string
+		Age  int
+	}
+
+	// Track consumed user
+	var consumedUser *User
+	consumer := func(u User) {
+		consumedUser = &u
+	}
+
+	// Create a computation with a complex type
+	user := User{Name: "Alice", Age: 30}
+	computation := F.Pipe1(
+		Of[context.Context](user),
+		ChainConsumer[context.Context](consumer),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer received the user
+	assert.NotNil(t, consumedUser)
+	assert.Equal(t, "Alice", consumedUser.Name)
+	assert.Equal(t, 30, consumedUser.Age)
+
+	// Verify result is successful
+	assert.True(t, result.IsRight(res))
+}
+
+// TestChainFirstConsumer_ComplexType tests ChainFirstConsumer with complex types
+func TestChainFirstConsumer_ComplexType(t *testing.T) {
+	type Product struct {
+		ID    int
+		Name  string
+		Price float64
+	}
+
+	// Track consumed products
+	var consumedProducts []Product
+	consumer := func(p Product) {
+		consumedProducts = append(consumedProducts, p)
+	}
+
+	// Create a pipeline with complex type
+	product := Product{ID: 1, Name: "Widget", Price: 9.99}
+	computation := F.Pipe2(
+		Of[context.Context](product),
+		ChainFirstConsumer[context.Context](consumer),
+		Map[context.Context](func(p Product) Product {
+			p.Price = p.Price * 1.1 // Apply 10% markup
+			return p
+		}),
+	)
+
+	// Execute the computation
+	res := computation(context.Background())()
+
+	// Verify consumer saw original product
+	assert.Len(t, consumedProducts, 1)
+	assert.Equal(t, 9.99, consumedProducts[0].Price)
+
+	// Verify final result has updated price
+	assert.True(t, result.IsRight(res))
+	if result.IsRight(res) {
+		finalProduct := result.GetOrElse(func(error) Product { return Product{} })(res)
+		assert.InDelta(t, 10.989, finalProduct.Price, 0.001)
+	}
+}
+
+// Made with Bob

v2/readerioresult/reader.go

@@ -25,10 +25,11 @@ import (
 	"github.com/IBM/fp-go/v2/readerio"
 	RIOE "github.com/IBM/fp-go/v2/readerioeither"
 	"github.com/IBM/fp-go/v2/readeroption"
+	"github.com/IBM/fp-go/v2/result"
 )
 
 //go:inline
-func FromReaderOption[R, A any](onNone func() error) Kleisli[R, ReaderOption[R, A], A] {
+func FromReaderOption[R, A any](onNone Lazy[error]) Kleisli[R, ReaderOption[R, A], A] {
 	return RIOE.FromReaderOption[R, A](onNone)
 }
 
@@ -113,7 +114,7 @@ func MonadTap[R, A, B any](fa ReaderIOResult[R, A], f Kleisli[R, A, B]) ReaderIO
 // The Either is automatically lifted into the ReaderIOResult context.
 //
 //go:inline
-func MonadChainEitherK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, B] {
+func MonadChainEitherK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, B] {
 	return RIOE.MonadChainEitherK(ma, f)
 }
 
@@ -121,7 +122,7 @@ func MonadChainEitherK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]
 // The Either is automatically lifted into the ReaderIOResult context.
 //
 //go:inline
-func MonadChainResultK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, B] {
+func MonadChainResultK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, B] {
 	return RIOE.MonadChainEitherK(ma, f)
 }
 
@@ -129,7 +130,7 @@ func MonadChainResultK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]
 // This is the curried version of MonadChainEitherK.
 //
 //go:inline
-func ChainEitherK[R, A, B any](f func(A) Result[B]) Operator[R, A, B] {
+func ChainEitherK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, B] {
 	return RIOE.ChainEitherK[R](f)
 }
 
@@ -137,7 +138,7 @@ func ChainEitherK[R, A, B any](f func(A) Result[B]) Operator[R, A, B] {
 // This is the curried version of MonadChainEitherK.
 //
 //go:inline
-func ChainResultK[R, A, B any](f func(A) Result[B]) Operator[R, A, B] {
+func ChainResultK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, B] {
 	return RIOE.ChainEitherK[R](f)
 }
 
@@ -145,12 +146,12 @@ func ChainResultK[R, A, B any](f func(A) Result[B]) Operator[R, A, B] {
 // Useful for validation or side effects that return Either.
 //
 //go:inline
-func MonadChainFirstEitherK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, A] {
+func MonadChainFirstEitherK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, A] {
 	return RIOE.MonadChainFirstEitherK(ma, f)
 }
 
 //go:inline
-func MonadTapEitherK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, A] {
+func MonadTapEitherK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, A] {
 	return RIOE.MonadTapEitherK(ma, f)
 }
 
@@ -158,12 +159,12 @@ func MonadTapEitherK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B])
 // This is the curried version of MonadChainFirstEitherK.
 //
 //go:inline
-func ChainFirstEitherK[R, A, B any](f func(A) Result[B]) Operator[R, A, A] {
+func ChainFirstEitherK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, A] {
 	return RIOE.ChainFirstEitherK[R](f)
 }
 
 //go:inline
-func TapEitherK[R, A, B any](f func(A) Result[B]) Operator[R, A, A] {
+func TapEitherK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, A] {
 	return RIOE.TapEitherK[R](f)
 }
 
@@ -171,12 +172,12 @@ func TapEitherK[R, A, B any](f func(A) Result[B]) Operator[R, A, A] {
 // Useful for validation or side effects that return Either.
 //
 //go:inline
-func MonadChainFirstResultK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, A] {
+func MonadChainFirstResultK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, A] {
 	return RIOE.MonadChainFirstEitherK(ma, f)
 }
 
 //go:inline
-func MonadTapResultK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B]) ReaderIOResult[R, A] {
+func MonadTapResultK[R, A, B any](ma ReaderIOResult[R, A], f result.Kleisli[A, B]) ReaderIOResult[R, A] {
 	return RIOE.MonadTapEitherK(ma, f)
 }
 
@@ -184,12 +185,12 @@ func MonadTapResultK[R, A, B any](ma ReaderIOResult[R, A], f func(A) Result[B])
 // This is the curried version of MonadChainFirstEitherK.
 //
 //go:inline
-func ChainFirstResultK[R, A, B any](f func(A) Result[B]) Operator[R, A, A] {
+func ChainFirstResultK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, A] {
 	return RIOE.ChainFirstEitherK[R](f)
 }
 
 //go:inline
-func TapResultK[R, A, B any](f func(A) Result[B]) Operator[R, A, A] {
+func TapResultK[R, A, B any](f result.Kleisli[A, B]) Operator[R, A, A] {
 	return RIOE.TapEitherK[R](f)
 }
 
@@ -230,17 +231,17 @@ func TapReaderK[R, A, B any](f reader.Kleisli[R, A, B]) Operator[R, A, A] {
 }
 
 //go:inline
-func ChainReaderOptionK[R, A, B any](onNone func() error) func(readeroption.Kleisli[R, A, B]) Operator[R, A, B] {
+func ChainReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, B] {
 	return RIOE.ChainReaderOptionK[R, A, B](onNone)
 }
 
 //go:inline
-func ChainFirstReaderOptionK[R, A, B any](onNone func() error) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A] {
+func ChainFirstReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A] {
 	return RIOE.ChainFirstReaderOptionK[R, A, B](onNone)
 }
 
 //go:inline
-func TapReaderOptionK[R, A, B any](onNone func() error) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A] {
+func TapReaderOptionK[R, A, B any](onNone Lazy[error]) func(readeroption.Kleisli[R, A, B]) Operator[R, A, A] {
 	return RIOE.TapReaderOptionK[R, A, B](onNone)
 }
 
@@ -421,7 +422,7 @@ func TapIOK[R, A, B any](f func(A) IO[B]) Operator[R, A, A] {
 // If the Option is None, the provided error function is called to produce the error value.
 //
 //go:inline
-func ChainOptionK[R, A, B any](onNone func() error) func(func(A) Option[B]) Operator[R, A, B] {
+func ChainOptionK[R, A, B any](onNone Lazy[error]) func(func(A) Option[B]) Operator[R, A, B] {
 	return RIOE.ChainOptionK[R, A, B](onNone)
 }
 
@@ -619,7 +620,7 @@ func Asks[R, A any](r Reader[R, A]) ReaderIOResult[R, A] {
 // If the Option is None, the provided function is called to produce the error.
 //
 //go:inline
-func FromOption[R, A any](onNone func() error) Kleisli[R, Option[A], A] {
+func FromOption[R, A any](onNone Lazy[error]) Kleisli[R, Option[A], A] {
 	return RIOE.FromOption[R, A](onNone)
 }
 

v2/readerioresult/types.go

@@ -19,6 +19,7 @@ import (
 	"github.com/IBM/fp-go/v2/consumer"
 	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/endomorphism"
+	"github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/ioeither"
 	"github.com/IBM/fp-go/v2/ioresult"
@@ -122,4 +123,6 @@ type (
 
 	// Predicate represents a function that tests a value of type A and returns a boolean.
 	Predicate[A any] = predicate.Predicate[A]
+
+	Void = function.Void
 )

v2/result/filterable.go

@@ -0,0 +1,262 @@
+// 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 result provides filterable operations for Result types.
+//
+// This package implements the Fantasy Land Filterable specification:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// Since Result[A] is an alias for Either[error, A], these functions are
+// thin wrappers around the corresponding either package functions, specialized
+// for the common case where the error type is Go's built-in error interface.
+package result
+
+import (
+	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/option"
+)
+
+// Partition separates a [Result] value into a [Pair] based on a predicate function.
+// It returns a function that takes a Result and produces a Pair of Result values,
+// where the first element contains values that fail the predicate and the second
+// contains values that pass the predicate.
+//
+// This function implements the Filterable specification's partition operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is an error (Left), both elements of the resulting Pair will be the same error
+//   - If the input is Ok (Right) and the predicate returns true, the result is (Err(empty), Ok(value))
+//   - If the input is Ok (Right) and the predicate returns false, the result is (Ok(value), Err(empty))
+//
+// Parameters:
+//   - p: A predicate function that tests values of type A
+//   - empty: The default error to use when creating error Results for partitioning
+//
+// Returns:
+//
+//	A function that takes a Result[A] and returns a Pair where:
+//	  - First element: Result values that fail the predicate (or original error)
+//	  - Second element: Result values that pass the predicate (or original error)
+//
+// Example:
+//
+//	import (
+//	    R "github.com/IBM/fp-go/v2/result"
+//	    N "github.com/IBM/fp-go/v2/number"
+//	    P "github.com/IBM/fp-go/v2/pair"
+//	    "errors"
+//	)
+//
+//	// Partition positive and non-positive numbers
+//	isPositive := N.MoreThan(0)
+//	partition := R.Partition(isPositive, errors.New("not positive"))
+//
+//	// Ok value that passes predicate
+//	result1 := partition(R.Of(5))
+//	// result1 = Pair(Err("not positive"), Ok(5))
+//
+//	// Ok value that fails predicate
+//	result2 := partition(R.Of(-3))
+//	// result2 = Pair(Ok(-3), Err("not positive"))
+//
+//	// Error passes through unchanged in both positions
+//	result3 := partition(R.Error[int](errors.New("original error")))
+//	// result3 = Pair(Err("original error"), Err("original error"))
+//
+//go:inline
+func Partition[A any](p Predicate[A], empty error) func(Result[A]) Pair[Result[A], Result[A]] {
+	return either.Partition(p, empty)
+}
+
+// Filter creates a filtering operation for [Result] values based on a predicate function.
+// It returns a function that takes a Result and produces a Result, where Ok values
+// that fail the predicate are converted to error Results with the provided error.
+//
+// This function implements the Filterable specification's filter operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is an error, it passes through unchanged
+//   - If the input is Ok and the predicate returns true, the Ok value passes through unchanged
+//   - If the input is Ok and the predicate returns false, it's converted to Err(empty)
+//
+// Parameters:
+//   - p: A predicate function that tests values of type A
+//   - empty: The default error to use when filtering out Ok values that fail the predicate
+//
+// Returns:
+//
+//	An Operator function that takes a Result[A] and returns a Result[A] where:
+//	  - Error values pass through unchanged
+//	  - Ok values that pass the predicate remain as Ok
+//	  - Ok values that fail the predicate become Err(empty)
+//
+// Example:
+//
+//	import (
+//	    R "github.com/IBM/fp-go/v2/result"
+//	    N "github.com/IBM/fp-go/v2/number"
+//	    "errors"
+//	)
+//
+//	// Filter to keep only positive numbers
+//	isPositive := N.MoreThan(0)
+//	filterPositive := R.Filter(isPositive, errors.New("not positive"))
+//
+//	// Ok value that passes predicate - remains Ok
+//	result1 := filterPositive(R.Of(5))
+//	// result1 = Ok(5)
+//
+//	// Ok value that fails predicate - becomes Err
+//	result2 := filterPositive(R.Of(-3))
+//	// result2 = Err("not positive")
+//
+//	// Error passes through unchanged
+//	result3 := filterPositive(R.Error[int](errors.New("original error")))
+//	// result3 = Err("original error")
+//
+//	// Chaining filters
+//	isEven := func(n int) bool { return n%2 == 0 }
+//	filterEven := R.Filter(isEven, errors.New("not even"))
+//
+//	result4 := filterEven(filterPositive(R.Of(4)))
+//	// result4 = Ok(4) - passes both filters
+//
+//	result5 := filterEven(filterPositive(R.Of(3)))
+//	// result5 = Err("not even") - passes first, fails second
+//
+//go:inline
+func Filter[A any](p Predicate[A], empty error) Operator[A, A] {
+	return either.Filter(p, empty)
+}
+
+// FilterMap combines filtering and mapping operations for [Result] values using an [Option]-returning function.
+// It returns a function that takes a Result[A] and produces a Result[B], where Ok values
+// are transformed by applying the function f. If f returns Some(B), the result is Ok(B). If f returns
+// None, the result is Err(empty).
+//
+// This function implements the Filterable specification's filterMap operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is an error, it passes through with its error value preserved
+//   - If the input is Ok and f returns Some(B), the result is Ok(B)
+//   - If the input is Ok and f returns None, the result is Err(empty)
+//
+// Parameters:
+//   - f: An Option Kleisli function that transforms values of type A to Option[B]
+//   - empty: The default error to use when f returns None
+//
+// Returns:
+//
+//	An Operator function that takes a Result[A] and returns a Result[B] where:
+//	  - Error values pass through with error preserved
+//	  - Ok values are transformed by f: Some(B) becomes Ok(B), None becomes Err(empty)
+//
+// Example:
+//
+//	import (
+//	    R "github.com/IBM/fp-go/v2/result"
+//	    O "github.com/IBM/fp-go/v2/option"
+//	    "errors"
+//	    "strconv"
+//	)
+//
+//	// Parse string to int, filtering out invalid values
+//	parseInt := func(s string) O.Option[int] {
+//	    if n, err := strconv.Atoi(s); err == nil {
+//	        return O.Some(n)
+//	    }
+//	    return O.None[int]()
+//	}
+//	filterMapInt := R.FilterMap(parseInt, errors.New("invalid number"))
+//
+//	// Valid number string - transforms to Ok(int)
+//	result1 := filterMapInt(R.Of("42"))
+//	// result1 = Ok(42)
+//
+//	// Invalid number string - becomes Err
+//	result2 := filterMapInt(R.Of("abc"))
+//	// result2 = Err("invalid number")
+//
+//	// Error passes through with error preserved
+//	result3 := filterMapInt(R.Error[string](errors.New("original error")))
+//	// result3 = Err("original error")
+//
+//go:inline
+func FilterMap[A, B any](f option.Kleisli[A, B], empty error) Operator[A, B] {
+	return either.FilterMap(f, empty)
+}
+
+// PartitionMap separates and transforms a [Result] value into a [Pair] of Result values using a mapping function.
+// It returns a function that takes a Result[A] and produces a Pair of Result values, where the mapping
+// function f transforms the Ok value into Either[B, C]. The result is partitioned based on whether f
+// produces a Left or Right value.
+//
+// This function implements the Filterable specification's partitionMap operation:
+// https://github.com/fantasyland/fantasy-land#filterable
+//
+// The behavior is as follows:
+//   - If the input is an error, both elements of the resulting Pair will be errors with the original error
+//   - If the input is Ok and f returns Left(B), the result is (Ok(B), Err(empty))
+//   - If the input is Ok and f returns Right(C), the result is (Err(empty), Ok(C))
+//
+// Parameters:
+//   - f: A Kleisli function that transforms values of type A to Either[B, C]
+//   - empty: The default error to use when creating error Results for partitioning
+//
+// Returns:
+//
+//	A function that takes a Result[A] and returns a Pair[Result[B], Result[C]] where:
+//	  - If input is error: (Err(original_error), Err(original_error))
+//	  - If f returns Left(B): (Ok(B), Err(empty))
+//	  - If f returns Right(C): (Err(empty), Ok(C))
+//
+// Example:
+//
+//	import (
+//	    R "github.com/IBM/fp-go/v2/result"
+//	    E "github.com/IBM/fp-go/v2/either"
+//	    P "github.com/IBM/fp-go/v2/pair"
+//	    "errors"
+//	    "strconv"
+//	)
+//
+//	// Classify and transform numbers: negative -> error message, positive -> squared value
+//	classifyNumber := func(n int) E.Either[string, int] {
+//	    if n < 0 {
+//	        return E.Left[int]("negative: " + strconv.Itoa(n))
+//	    }
+//	    return E.Right[string](n * n)
+//	}
+//	partitionMap := R.PartitionMap(classifyNumber, errors.New("not classified"))
+//
+//	// Positive number - goes to right side as squared value
+//	result1 := partitionMap(R.Of(5))
+//	// result1 = Pair(Err("not classified"), Ok(25))
+//
+//	// Negative number - goes to left side with error message
+//	result2 := partitionMap(R.Of(-3))
+//	// result2 = Pair(Ok("negative: -3"), Err("not classified"))
+//
+//	// Original error - appears in both positions
+//	result3 := partitionMap(R.Error[int](errors.New("original error")))
+//	// result3 = Pair(Err("original error"), Err("original error"))
+//
+//go:inline
+func PartitionMap[A, B, C any](f either.Kleisli[B, A, C], empty error) func(Result[A]) Pair[Result[B], Result[C]] {
+	return either.PartitionMap(f, empty)
+}

v2/result/filterable_test.go

@@ -0,0 +1,691 @@
+// 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 result
+
+import (
+	"errors"
+	"math"
+	"strconv"
+	"testing"
+
+	E "github.com/IBM/fp-go/v2/either"
+	N "github.com/IBM/fp-go/v2/number"
+	O "github.com/IBM/fp-go/v2/option"
+	P "github.com/IBM/fp-go/v2/pair"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPartition(t *testing.T) {
+	t.Run("Ok value that passes predicate", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		partition := Partition(isPositive, errors.New("not positive"))
+		input := Of(5)
+
+		// Act
+		result := partition(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsLeft(left), "left should be error")
+		assert.True(t, IsRight(right), "right should be Ok")
+
+		rightVal, _ := Unwrap(right)
+		assert.Equal(t, 5, rightVal)
+	})
+
+	t.Run("Ok value that fails predicate", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		partition := Partition(isPositive, errors.New("not positive"))
+		input := Of(-3)
+
+		// Act
+		result := partition(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsRight(left), "left should be Ok (failed predicate)")
+		assert.True(t, IsLeft(right), "right should be error")
+
+		leftVal, _ := Unwrap(left)
+		assert.Equal(t, -3, leftVal)
+	})
+
+	t.Run("Ok value at boundary (zero)", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		partition := Partition(isPositive, errors.New("not positive"))
+		input := Of(0)
+
+		// Act
+		result := partition(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsRight(left), "left should be Ok (zero fails predicate)")
+		assert.True(t, IsLeft(right), "right should be error")
+
+		leftVal, _ := Unwrap(left)
+		assert.Equal(t, 0, leftVal)
+	})
+
+	t.Run("Error passes through unchanged", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		partition := Partition(isPositive, errors.New("not positive"))
+		originalError := errors.New("original error")
+		input := Left[int](originalError)
+
+		// Act
+		result := partition(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsLeft(left), "left should be error")
+		assert.True(t, IsLeft(right), "right should be error")
+
+		_, leftErr := Unwrap(left)
+		_, rightErr := Unwrap(right)
+
+		assert.Equal(t, originalError, leftErr)
+		assert.Equal(t, originalError, rightErr)
+	})
+
+	t.Run("String predicate - even length strings", func(t *testing.T) {
+		// Arrange
+		isEvenLength := func(s string) bool { return len(s)%2 == 0 }
+		partition := Partition(isEvenLength, errors.New("odd length"))
+
+		// Act & Assert - passes predicate
+		result1 := partition(Of("test"))
+		left1, right1 := P.Unpack(result1)
+		assert.True(t, IsLeft(left1))
+		assert.True(t, IsRight(right1))
+		rightVal1, _ := Unwrap(right1)
+		assert.Equal(t, "test", rightVal1)
+
+		// Act & Assert - fails predicate
+		result2 := partition(Of("hello"))
+		left2, right2 := P.Unpack(result2)
+		assert.True(t, IsRight(left2))
+		assert.True(t, IsLeft(right2))
+		leftVal2, _ := Unwrap(left2)
+		assert.Equal(t, "hello", leftVal2)
+	})
+
+	t.Run("Complex type predicate - struct field check", func(t *testing.T) {
+		// Arrange
+		type Person struct {
+			Name string
+			Age  int
+		}
+		isAdult := func(p Person) bool { return p.Age >= 18 }
+		partition := Partition(isAdult, errors.New("minor"))
+
+		// Act & Assert - adult passes
+		adult := Person{Name: "Alice", Age: 25}
+		result1 := partition(Of(adult))
+		left1, right1 := P.Unpack(result1)
+		assert.True(t, IsLeft(left1))
+		assert.True(t, IsRight(right1))
+		rightVal1, _ := Unwrap(right1)
+		assert.Equal(t, adult, rightVal1)
+
+		// Act & Assert - minor fails
+		minor := Person{Name: "Bob", Age: 15}
+		result2 := partition(Of(minor))
+		left2, right2 := P.Unpack(result2)
+		assert.True(t, IsRight(left2))
+		assert.True(t, IsLeft(right2))
+		leftVal2, _ := Unwrap(left2)
+		assert.Equal(t, minor, leftVal2)
+	})
+}
+
+func TestFilter(t *testing.T) {
+	t.Run("Ok value that passes predicate", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		filter := Filter(isPositive, errors.New("not positive"))
+		input := Of(5)
+
+		// Act
+		result := filter(input)
+
+		// Assert
+		assert.True(t, IsRight(result), "result should be Ok")
+		val, _ := Unwrap(result)
+		assert.Equal(t, 5, val)
+	})
+
+	t.Run("Ok value that fails predicate", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		filter := Filter(isPositive, errors.New("not positive"))
+		input := Of(-3)
+
+		// Act
+		result := filter(input)
+
+		// Assert
+		assert.True(t, IsLeft(result), "result should be error")
+		_, err := Unwrap(result)
+		assert.Equal(t, "not positive", err.Error())
+	})
+
+	t.Run("Ok value at boundary (zero)", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		filter := Filter(isPositive, errors.New("not positive"))
+		input := Of(0)
+
+		// Act
+		result := filter(input)
+
+		// Assert
+		assert.True(t, IsLeft(result), "zero should fail predicate")
+		_, err := Unwrap(result)
+		assert.Equal(t, "not positive", err.Error())
+	})
+
+	t.Run("Error passes through unchanged", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		filter := Filter(isPositive, errors.New("not positive"))
+		originalError := errors.New("original error")
+		input := Left[int](originalError)
+
+		// Act
+		result := filter(input)
+
+		// Assert
+		assert.True(t, IsLeft(result), "result should be error")
+		_, err := Unwrap(result)
+		assert.Equal(t, originalError, err)
+	})
+
+	t.Run("Chaining multiple filters", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		isEven := func(n int) bool { return n%2 == 0 }
+		filterPositive := Filter(isPositive, errors.New("not positive"))
+		filterEven := Filter(isEven, errors.New("not even"))
+
+		// Act & Assert - passes both filters
+		result1 := filterEven(filterPositive(Of(4)))
+		assert.True(t, IsRight(result1))
+		val1, _ := Unwrap(result1)
+		assert.Equal(t, 4, val1)
+
+		// Act & Assert - passes first, fails second
+		result2 := filterEven(filterPositive(Of(3)))
+		assert.True(t, IsLeft(result2))
+		_, err2 := Unwrap(result2)
+		assert.Equal(t, "not even", err2.Error())
+
+		// Act & Assert - fails first filter
+		result3 := filterEven(filterPositive(Of(-2)))
+		assert.True(t, IsLeft(result3))
+		_, err3 := Unwrap(result3)
+		assert.Equal(t, "not positive", err3.Error())
+
+		// Act & Assert - error passes through both
+		originalErr := errors.New("original")
+		result4 := filterEven(filterPositive(Left[int](originalErr)))
+		assert.True(t, IsLeft(result4))
+		_, err4 := Unwrap(result4)
+		assert.Equal(t, originalErr, err4)
+	})
+
+	t.Run("Filter preserves error", func(t *testing.T) {
+		// Arrange
+		isPositive := N.MoreThan(0)
+		filter := Filter(isPositive, errors.New("default error"))
+
+		// Act - error with different message
+		originalError := errors.New("server error")
+		result := filter(Left[int](originalError))
+
+		// Assert - original error preserved
+		assert.True(t, IsLeft(result))
+		_, err := Unwrap(result)
+		assert.Equal(t, originalError, err)
+	})
+}
+
+func TestFilterMap(t *testing.T) {
+	t.Run("Ok value with Some result", func(t *testing.T) {
+		// Arrange
+		parseInt := func(s string) O.Option[int] {
+			if n, err := strconv.Atoi(s); err == nil {
+				return O.Some(n)
+			}
+			return O.None[int]()
+		}
+		filterMap := FilterMap(parseInt, errors.New("invalid number"))
+		input := Of("42")
+
+		// Act
+		result := filterMap(input)
+
+		// Assert
+		assert.True(t, IsRight(result), "result should be Ok")
+		val, _ := Unwrap(result)
+		assert.Equal(t, 42, val)
+	})
+
+	t.Run("Ok value with None result", func(t *testing.T) {
+		// Arrange
+		parseInt := func(s string) O.Option[int] {
+			if n, err := strconv.Atoi(s); err == nil {
+				return O.Some(n)
+			}
+			return O.None[int]()
+		}
+		filterMap := FilterMap(parseInt, errors.New("invalid number"))
+		input := Of("abc")
+
+		// Act
+		result := filterMap(input)
+
+		// Assert
+		assert.True(t, IsLeft(result), "result should be error")
+		_, err := Unwrap(result)
+		assert.Equal(t, "invalid number", err.Error())
+	})
+
+	t.Run("Error passes through", func(t *testing.T) {
+		// Arrange
+		parseInt := func(s string) O.Option[int] {
+			if n, err := strconv.Atoi(s); err == nil {
+				return O.Some(n)
+			}
+			return O.None[int]()
+		}
+		filterMap := FilterMap(parseInt, errors.New("invalid number"))
+		originalError := errors.New("original error")
+		input := Left[string](originalError)
+
+		// Act
+		result := filterMap(input)
+
+		// Assert
+		assert.True(t, IsLeft(result), "result should be error")
+		_, err := Unwrap(result)
+		assert.Equal(t, originalError, err)
+	})
+
+	t.Run("Extract optional field from struct", func(t *testing.T) {
+		// Arrange
+		type Person struct {
+			Name  string
+			Email O.Option[string]
+		}
+		extractEmail := func(p Person) O.Option[string] { return p.Email }
+		filterMap := FilterMap(extractEmail, errors.New("no email"))
+
+		// Act & Assert - has email
+		result1 := filterMap(Of(Person{Name: "Alice", Email: O.Some("alice@example.com")}))
+		assert.True(t, IsRight(result1))
+		val1, _ := Unwrap(result1)
+		assert.Equal(t, "alice@example.com", val1)
+
+		// Act & Assert - no email
+		result2 := filterMap(Of(Person{Name: "Bob", Email: O.None[string]()}))
+		assert.True(t, IsLeft(result2))
+		_, err2 := Unwrap(result2)
+		assert.Equal(t, "no email", err2.Error())
+	})
+
+	t.Run("Transform and filter numbers", func(t *testing.T) {
+		// Arrange
+		sqrtIfPositive := func(n int) O.Option[float64] {
+			if n >= 0 {
+				return O.Some(math.Sqrt(float64(n)))
+			}
+			return O.None[float64]()
+		}
+		filterMap := FilterMap(sqrtIfPositive, errors.New("negative number"))
+
+		// Act & Assert - positive number
+		result1 := filterMap(Of(16))
+		assert.True(t, IsRight(result1))
+		val1, _ := Unwrap(result1)
+		assert.Equal(t, 4.0, val1)
+
+		// Act & Assert - negative number
+		result2 := filterMap(Of(-4))
+		assert.True(t, IsLeft(result2))
+		_, err2 := Unwrap(result2)
+		assert.Equal(t, "negative number", err2.Error())
+
+		// Act & Assert - zero
+		result3 := filterMap(Of(0))
+		assert.True(t, IsRight(result3))
+		val3, _ := Unwrap(result3)
+		assert.Equal(t, 0.0, val3)
+	})
+
+	t.Run("Chain multiple FilterMap operations", func(t *testing.T) {
+		// Arrange
+		parseInt := func(s string) O.Option[int] {
+			if n, err := strconv.Atoi(s); err == nil {
+				return O.Some(n)
+			}
+			return O.None[int]()
+		}
+		doubleIfEven := func(n int) O.Option[int] {
+			if n%2 == 0 {
+				return O.Some(n * 2)
+			}
+			return O.None[int]()
+		}
+		filterMap1 := FilterMap(parseInt, errors.New("invalid number"))
+		filterMap2 := FilterMap(doubleIfEven, errors.New("not even"))
+
+		// Act & Assert - valid even number
+		result1 := filterMap2(filterMap1(Of("4")))
+		assert.True(t, IsRight(result1))
+		val1, _ := Unwrap(result1)
+		assert.Equal(t, 8, val1)
+
+		// Act & Assert - valid odd number
+		result2 := filterMap2(filterMap1(Of("3")))
+		assert.True(t, IsLeft(result2))
+		_, err2 := Unwrap(result2)
+		assert.Equal(t, "not even", err2.Error())
+
+		// Act & Assert - invalid number
+		result3 := filterMap2(filterMap1(Of("abc")))
+		assert.True(t, IsLeft(result3))
+		_, err3 := Unwrap(result3)
+		assert.Equal(t, "invalid number", err3.Error())
+	})
+}
+
+func TestPartitionMap(t *testing.T) {
+	t.Run("Ok value that maps to Left", func(t *testing.T) {
+		// Arrange
+		classifyNumber := func(n int) E.Either[string, int] {
+			if n < 0 {
+				return E.Left[int]("negative: " + strconv.Itoa(n))
+			}
+			return E.Right[string](n * n)
+		}
+		partitionMap := PartitionMap(classifyNumber, errors.New("not classified"))
+		input := Of(-3)
+
+		// Act
+		result := partitionMap(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsRight(left), "left should be Ok (contains error from f)")
+		assert.True(t, IsLeft(right), "right should be error")
+
+		leftVal, _ := Unwrap(left)
+		assert.Equal(t, "negative: -3", leftVal)
+	})
+
+	t.Run("Ok value that maps to Right", func(t *testing.T) {
+		// Arrange
+		classifyNumber := func(n int) E.Either[string, int] {
+			if n < 0 {
+				return E.Left[int]("negative: " + strconv.Itoa(n))
+			}
+			return E.Right[string](n * n)
+		}
+		partitionMap := PartitionMap(classifyNumber, errors.New("not classified"))
+		input := Of(5)
+
+		// Act
+		result := partitionMap(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsLeft(left), "left should be error")
+		assert.True(t, IsRight(right), "right should be Ok (contains value from f)")
+
+		rightVal, _ := Unwrap(right)
+		assert.Equal(t, 25, rightVal)
+	})
+
+	t.Run("Error passes through to both sides", func(t *testing.T) {
+		// Arrange
+		classifyNumber := func(n int) E.Either[string, int] {
+			if n < 0 {
+				return E.Left[int]("negative")
+			}
+			return E.Right[string](n * n)
+		}
+		partitionMap := PartitionMap(classifyNumber, errors.New("not classified"))
+		originalError := errors.New("original error")
+		input := Left[int](originalError)
+
+		// Act
+		result := partitionMap(input)
+		left, right := P.Unpack(result)
+
+		// Assert
+		assert.True(t, IsLeft(left), "left should be error")
+		assert.True(t, IsLeft(right), "right should be error")
+
+		_, leftErr := Unwrap(left)
+		_, rightErr := Unwrap(right)
+
+		assert.Equal(t, originalError, leftErr)
+		assert.Equal(t, originalError, rightErr)
+	})
+
+	t.Run("Validate and transform user input", func(t *testing.T) {
+		// Arrange
+		type ValidationError struct {
+			Field   string
+			Message string
+		}
+		type User struct {
+			Name string
+			Age  int
+		}
+
+		validateUser := func(input map[string]string) E.Either[ValidationError, User] {
+			name, hasName := input["name"]
+			ageStr, hasAge := input["age"]
+			if !hasName {
+				return E.Left[User](ValidationError{"name", "missing"})
+			}
+			if !hasAge {
+				return E.Left[User](ValidationError{"age", "missing"})
+			}
+			age, err := strconv.Atoi(ageStr)
+			if err != nil {
+				return E.Left[User](ValidationError{"age", "invalid"})
+			}
+			return E.Right[ValidationError](User{name, age})
+		}
+		partitionMap := PartitionMap(validateUser, errors.New("not processed"))
+
+		// Act & Assert - valid input
+		validInput := map[string]string{"name": "Alice", "age": "30"}
+		result1 := partitionMap(Of(validInput))
+		left1, right1 := P.Unpack(result1)
+		assert.True(t, IsLeft(left1))
+		assert.True(t, IsRight(right1))
+		rightVal1, _ := Unwrap(right1)
+		assert.Equal(t, User{"Alice", 30}, rightVal1)
+
+		// Act & Assert - invalid input (missing age)
+		invalidInput := map[string]string{"name": "Bob"}
+		result2 := partitionMap(Of(invalidInput))
+		left2, right2 := P.Unpack(result2)
+		assert.True(t, IsRight(left2))
+		assert.True(t, IsLeft(right2))
+		leftVal2, _ := Unwrap(left2)
+		assert.Equal(t, ValidationError{"age", "missing"}, leftVal2)
+	})
+
+	t.Run("Classify strings by length", func(t *testing.T) {
+		// Arrange
+		classifyString := func(s string) E.Either[string, int] {
+			if len(s) < 5 {
+				return E.Left[int]("too short: " + s)
+			}
+			return E.Right[string](len(s))
+		}
+		partitionMap := PartitionMap(classifyString, errors.New("not classified"))
+
+		// Act & Assert - short string
+		result1 := partitionMap(Of("hi"))
+		left1, right1 := P.Unpack(result1)
+		assert.True(t, IsRight(left1))
+		assert.True(t, IsLeft(right1))
+		leftVal1, _ := Unwrap(left1)
+		assert.Equal(t, "too short: hi", leftVal1)
+
+		// Act & Assert - long string
+		result2 := partitionMap(Of("hello world"))
+		left2, right2 := P.Unpack(result2)
+		assert.True(t, IsLeft(left2))
+		assert.True(t, IsRight(right2))
+		rightVal2, _ := Unwrap(right2)
+		assert.Equal(t, 11, rightVal2)
+	})
+}
+
+// Benchmark tests
+func BenchmarkPartition(b *testing.B) {
+	isPositive := N.MoreThan(0)
+	partition := Partition(isPositive, errors.New("not positive"))
+	input := Of(42)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = partition(input)
+	}
+}
+
+func BenchmarkPartitionError(b *testing.B) {
+	isPositive := N.MoreThan(0)
+	partition := Partition(isPositive, errors.New("not positive"))
+	input := Left[int](errors.New("error"))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = partition(input)
+	}
+}
+
+func BenchmarkFilter(b *testing.B) {
+	isPositive := N.MoreThan(0)
+	filter := Filter(isPositive, errors.New("not positive"))
+	input := Of(42)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = filter(input)
+	}
+}
+
+func BenchmarkFilterError(b *testing.B) {
+	isPositive := N.MoreThan(0)
+	filter := Filter(isPositive, errors.New("not positive"))
+	input := Left[int](errors.New("error"))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = filter(input)
+	}
+}
+
+func BenchmarkFilterChained(b *testing.B) {
+	isPositive := N.MoreThan(0)
+	isEven := func(n int) bool { return n%2 == 0 }
+	filterPositive := Filter(isPositive, errors.New("not positive"))
+	filterEven := Filter(isEven, errors.New("not even"))
+	input := Of(42)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = filterEven(filterPositive(input))
+	}
+}
+
+func BenchmarkFilterMap(b *testing.B) {
+	parseInt := func(s string) O.Option[int] {
+		if n, err := strconv.Atoi(s); err == nil {
+			return O.Some(n)
+		}
+		return O.None[int]()
+	}
+	filterMap := FilterMap(parseInt, errors.New("invalid"))
+	input := Of("42")
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = filterMap(input)
+	}
+}
+
+func BenchmarkFilterMapError(b *testing.B) {
+	parseInt := func(s string) O.Option[int] {
+		if n, err := strconv.Atoi(s); err == nil {
+			return O.Some(n)
+		}
+		return O.None[int]()
+	}
+	filterMap := FilterMap(parseInt, errors.New("invalid"))
+	input := Left[string](errors.New("error"))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = filterMap(input)
+	}
+}
+
+func BenchmarkPartitionMap(b *testing.B) {
+	classify := func(n int) E.Either[string, int] {
+		if n < 0 {
+			return E.Left[int]("negative")
+		}
+		return E.Right[string](n * n)
+	}
+	partitionMap := PartitionMap(classify, errors.New("not classified"))
+	input := Of(42)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = partitionMap(input)
+	}
+}
+
+func BenchmarkPartitionMapError(b *testing.B) {
+	classify := func(n int) E.Either[string, int] {
+		if n < 0 {
+			return E.Left[int]("negative")
+		}
+		return E.Right[string](n * n)
+	}
+	partitionMap := PartitionMap(classify, errors.New("not classified"))
+	input := Left[int](errors.New("error"))
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = partitionMap(input)
+	}
+}
+
+// Made with Bob

v2/result/types.go

@@ -22,6 +22,7 @@ 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/pair"
 	"github.com/IBM/fp-go/v2/predicate"
 	"github.com/IBM/fp-go/v2/reader"
 )
@@ -61,4 +62,6 @@ type (
 	// 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]
+
+	Pair[L, R any] = pair.Pair[L, R]
 )