fix: add Bind for Codec

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

v2/go.mod

@@ -4,7 +4,7 @@ go 1.24
 
 require (
 	github.com/stretchr/testify v1.11.1
-	github.com/urfave/cli/v3 v3.6.2
+	github.com/urfave/cli/v3 v3.7.0
 )
 
 require (

v2/go.sum

@@ -6,6 +6,8 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/urfave/cli/v3 v3.6.2 h1:lQuqiPrZ1cIz8hz+HcrG0TNZFxU70dPZ3Yl+pSrH9A8=
 github.com/urfave/cli/v3 v3.6.2/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/urfave/cli/v3 v3.7.0 h1:AGSnbUyjtLiM+WJUb4dzXKldl/gL+F8OwmRDtVr6g2U=
+github.com/urfave/cli/v3 v3.7.0/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

v2/optics/codec/bind.go

@@ -20,6 +20,7 @@ import (
 
 	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/lazy"
+	"github.com/IBM/fp-go/v2/optics/codec/decode"
 	"github.com/IBM/fp-go/v2/optics/codec/validate"
 	"github.com/IBM/fp-go/v2/option"
 	"github.com/IBM/fp-go/v2/reader"
@@ -297,3 +298,154 @@ func ApSO[S, T, O, I any](
 		)
 	}
 }
+
+// Bind creates a monadic sequencing operator for codecs using a lens and a Kleisli arrow.
+//
+// This function implements the "Bind" (monadic bind / chain) pattern for codecs,
+// allowing you to build up complex codecs where the codec for a field depends on
+// the current decoded value of the struct. Unlike ApSL which uses a fixed field
+// codec, Bind accepts a Kleisli arrow — a function from the current struct value S
+// to a Type[T, O, I] — enabling context-sensitive codec construction.
+//
+// The function combines:
+//   - Encoding: Evaluates the Kleisli arrow f on the current struct value s to obtain
+//     the field codec, extracts the field T using the lens, encodes it with that codec,
+//     and combines it with the base encoding using the monoid.
+//   - Validation: Validates the base struct first (monadic sequencing), then uses the
+//     Kleisli arrow to obtain the field codec for the decoded struct value, and validates
+//     the field through the lens. Errors are propagated but NOT accumulated (fail-fast
+//     semantics, unlike ApSL which accumulates errors).
+//
+// # Type Parameters
+//
+//   - S: The source struct type (what we're building a codec for)
+//   - T: The field type accessed by the lens
+//   - O: The output type for encoding (must have a monoid)
+//   - I: The input type for decoding
+//
+// # Parameters
+//
+//   - m: A Monoid[O] for combining encoded outputs
+//   - l: A Lens[S, T] that focuses on a specific field in S
+//   - f: A Kleisli[S, T, O, I] — a function from S to Type[T, O, I] — that produces
+//     the field codec based on the current struct value
+//
+// # Returns
+//
+// An Operator[S, S, O, I] that transforms a base codec by adding the field
+// specified by the lens, where the field codec is determined by the Kleisli arrow.
+//
+// # How It Works
+//
+// 1. **Encoding**: When encoding a value of type S:
+//   - Evaluate f(s) to obtain the field codec fa
+//   - Extract the field T using l.Get
+//   - Encode T to O using fa.Encode
+//   - Combine with the base encoding using the monoid
+//
+// 2. **Validation**: When validating input I:
+//   - Run the base validation to obtain a decoded S (fail-fast: stop on base failure)
+//   - For the decoded S, evaluate f(s) to obtain the field codec fa
+//   - Validate the input I using fa.Validate
+//   - Set the validated T into S using l.Set
+//
+// 3. **Type Checking**: Preserves the base type checker
+//
+// # Difference from ApSL
+//
+// Unlike ApSL which uses a fixed field codec:
+//   - ApSL: Field codec is fixed at construction time; errors are accumulated
+//   - Bind: Field codec depends on the current struct value (Kleisli arrow); validation
+//     uses monadic sequencing (fail-fast on base failure)
+//   - Bind is more powerful but less parallel than ApSL
+//
+// # Example
+//
+//	import (
+//	    "github.com/IBM/fp-go/v2/optics/codec"
+//	    "github.com/IBM/fp-go/v2/optics/lens"
+//	    S "github.com/IBM/fp-go/v2/string"
+//	)
+//
+//	type Config struct {
+//	    Mode  string
+//	    Value int
+//	}
+//
+//	modeLens := lens.MakeLens(
+//	    func(c Config) string { return c.Mode },
+//	    func(c Config, mode string) Config { c.Mode = mode; return c },
+//	)
+//
+//	// Build a Config codec where the Value codec depends on the Mode
+//	configCodec := F.Pipe1(
+//	    codec.Struct[Config]("Config"),
+//	    codec.Bind(S.Monoid, modeLens, func(c Config) codec.Type[string, string, any] {
+//	        return codec.String()
+//	    }),
+//	)
+//
+// # Use Cases
+//
+//   - Building codecs where a field's codec depends on another field's value
+//   - Implementing discriminated unions or tagged variants
+//   - Context-sensitive validation (e.g., validate field B differently based on field A)
+//   - Dependent type-like patterns in codec construction
+//
+// # Notes
+//
+//   - The monoid determines how encoded outputs are combined
+//   - The lens must be total (handle all cases safely)
+//   - Validation uses monadic (fail-fast) sequencing: if the base codec fails,
+//     the Kleisli arrow is never evaluated
+//   - The name is automatically generated for debugging purposes
+//
+// See also:
+//   - ApSL: Applicative sequencing with a fixed lens codec (error accumulation)
+//   - Kleisli: The function type from S to Type[T, O, I]
+//   - decode.Bind: The underlying decode-level bind combinator
+func Bind[S, T, O, I any](
+	m Monoid[O],
+	l Lens[S, T],
+	f Kleisli[S, T, O, I],
+) Operator[S, S, O, I] {
+	name := fmt.Sprintf("Bind[%s]", l)
+	val := reader.Curry(Type[T, O, I].Validate)
+	rm := reader.ApplicativeMonoid[S](m)
+
+	return func(t Type[S, O, I]) Type[S, O, I] {
+		return MakeType(
+			name,
+			t.Is,
+			func(i I) Decode[validate.Context, S] {
+
+				bind := decode.Bind(
+					l.Set,
+					F.Flow2(
+						f,
+						val(i),
+					),
+				)
+
+				return F.Pipe2(
+					i,
+					t.Validate,
+					bind,
+				)
+			},
+			func(s S) O {
+				fa := f(s)
+
+				encConcat := F.Pipe1(
+					F.Flow2(
+						l.Get,
+						fa.Encode,
+					),
+					semigroup.AppendTo(rm),
+				)
+
+				return encConcat(t.Encode)(s)
+			},
+		)
+	}
+}

v2/optics/codec/bind_test.go

@@ -814,3 +814,588 @@ func TestApSO_ErrorAccumulation(t *testing.T) {
 		assert.NotEmpty(t, errors, "Should have validation errors")
 	})
 }
+
+// TestBind_EncodingCombination verifies that Bind combines the base encoding with
+// the field encoding produced by the Kleisli arrow using the monoid.
+func TestBind_EncodingCombination(t *testing.T) {
+	t.Run("combines base and field encodings using monoid", func(t *testing.T) {
+		// Lens for Person.Name
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		// Base codec encodes to "Person:"
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "Person:" },
+		)
+
+		// Kleisli arrow: always returns a string identity codec regardless of struct value
+		kleisli := func(p Person) Type[string, string, any] {
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if s, ok := i.(string); ok {
+						return validation.ToResult(validation.Success(s))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected string"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if s, ok := i.(string); ok {
+							return validation.Success(s)
+						}
+						return validation.FailureWithMessage[string](i, "expected string")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		person := Person{Name: "Alice", Age: 30}
+		encoded := enhancedCodec.Encode(person)
+
+		// Encoding should include both the base prefix and the field value
+		assert.Contains(t, encoded, "Person:")
+		assert.Contains(t, encoded, "Alice")
+	})
+}
+
+// TestBind_KleisliArrowReceivesCurrentValue verifies that the Kleisli arrow f
+// receives the current struct value when producing the field codec.
+func TestBind_KleisliArrowReceivesCurrentValue(t *testing.T) {
+	t.Run("kleisli arrow receives current struct value during encoding", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		// Kleisli arrow that uses the struct value to produce a prefix in the encoding
+		var capturedPerson Person
+		kleisli := func(p Person) Type[string, string, any] {
+			capturedPerson = p
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if s, ok := i.(string); ok {
+						return validation.ToResult(validation.Success(s))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected string"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if s, ok := i.(string); ok {
+							return validation.Success(s)
+						}
+						return validation.FailureWithMessage[string](i, "expected string")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		person := Person{Name: "Bob", Age: 25}
+		enhancedCodec.Encode(person)
+
+		// The Kleisli arrow should have been called with the actual struct value
+		assert.Equal(t, person, capturedPerson)
+	})
+}
+
+// TestBind_ValidationSuccess verifies that Bind correctly validates and decodes
+// a struct when both the base and field validations succeed.
+func TestBind_ValidationSuccess(t *testing.T) {
+	t.Run("succeeds when base and field validations pass", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		// The field codec receives the same input I (any = Person struct).
+		// It must extract the Name field from the Person input.
+		kleisli := func(p Person) Type[string, string, any] {
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if person, ok := i.(Person); ok {
+						return validation.ToResult(validation.Success(person.Name))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected Person"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if person, ok := i.(Person); ok {
+							return validation.Success(person.Name)
+						}
+						return validation.FailureWithMessage[string](i, "expected Person")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		person := Person{Name: "Carol", Age: 28}
+		result := enhancedCodec.Decode(person)
+
+		assert.True(t, either.IsRight(result), "Should succeed when both validations pass")
+	})
+}
+
+// TestBind_ValidationFailsOnBaseFailure verifies that Bind uses fail-fast (monadic)
+// semantics: if the base codec fails, the Kleisli arrow is never evaluated.
+func TestBind_ValidationFailsOnBaseFailure(t *testing.T) {
+	t.Run("fails fast when base validation fails", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		// Base codec always fails
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "base always fails"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					return validation.FailureWithMessage[Person](i, "base always fails")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		kleisliCalled := false
+		kleisli := func(p Person) Type[string, string, any] {
+			kleisliCalled = true
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if s, ok := i.(string); ok {
+						return validation.ToResult(validation.Success(s))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected string"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if s, ok := i.(string); ok {
+							return validation.Success(s)
+						}
+						return validation.FailureWithMessage[string](i, "expected string")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		person := Person{Name: "Dave", Age: 40}
+		result := enhancedCodec.Decode(person)
+
+		assert.True(t, either.IsLeft(result), "Should fail when base validation fails")
+		assert.False(t, kleisliCalled, "Kleisli arrow should NOT be called when base fails")
+	})
+}
+
+// TestBind_ValidationFailsOnFieldFailure verifies that Bind propagates field
+// validation errors when the Kleisli arrow's codec fails.
+func TestBind_ValidationFailsOnFieldFailure(t *testing.T) {
+	t.Run("fails when field validation from kleisli codec fails", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		// Base codec succeeds
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		// Kleisli arrow returns a codec that always fails regardless of input
+		kleisli := func(p Person) Type[string, string, any] {
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "field always fails"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						return validation.FailureWithMessage[string](i, "field always fails")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		// The field codec receives the same input (Person) and always fails
+		person := Person{Name: "Eve", Age: 22}
+		result := enhancedCodec.Decode(person)
+
+		assert.True(t, either.IsLeft(result), "Should fail when field validation fails")
+
+		errors := either.MonadFold(result,
+			F.Identity[validation.Errors],
+			func(Person) validation.Errors { return nil },
+		)
+		assert.NotEmpty(t, errors, "Should have validation errors from field codec")
+	})
+}
+
+// TestBind_TypeCheckingPreserved verifies that Bind preserves the base type checker.
+func TestBind_TypeCheckingPreserved(t *testing.T) {
+	t.Run("preserves base type checker", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		kleisli := func(p Person) Type[string, string, any] {
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if s, ok := i.(string); ok {
+						return validation.ToResult(validation.Success(s))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected string"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if s, ok := i.(string); ok {
+							return validation.Success(s)
+						}
+						return validation.FailureWithMessage[string](i, "expected string")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		// Valid type
+		person := Person{Name: "Frank", Age: 35}
+		isResult := enhancedCodec.Is(person)
+		assert.True(t, either.IsRight(isResult), "Should accept Person type")
+
+		// Invalid type
+		invalidResult := enhancedCodec.Is("not a person")
+		assert.True(t, either.IsLeft(invalidResult), "Should reject non-Person type")
+	})
+}
+
+// TestBind_Naming verifies that Bind generates a descriptive name for the codec.
+func TestBind_Naming(t *testing.T) {
+	t.Run("generates descriptive name containing Bind and lens info", func(t *testing.T) {
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		kleisli := func(p Person) Type[string, string, any] {
+			return MakeType(
+				"Name",
+				func(i any) validation.Result[string] {
+					if s, ok := i.(string); ok {
+						return validation.ToResult(validation.Success(s))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected string"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if s, ok := i.(string); ok {
+							return validation.Success(s)
+						}
+						return validation.FailureWithMessage[string](i, "expected string")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		name := enhancedCodec.Name()
+		assert.Contains(t, name, "Bind", "Name should contain 'Bind'")
+	})
+}
+
+// TestBind_DependentFieldCodec verifies that the Kleisli arrow can produce
+// different codecs based on the current struct value (the key differentiator
+// from ApSL).
+//
+// The field codec Type[T, O, I] receives the same input I as the base codec.
+// It must extract the field value from that input. The Kleisli arrow f(s)
+// produces a different codec depending on the already-decoded struct value s.
+func TestBind_DependentFieldCodec(t *testing.T) {
+	t.Run("kleisli arrow produces different codecs based on struct value", func(t *testing.T) {
+		// Lens for Person.Name
+		nameLens := lens.MakeLens(
+			func(p Person) string { return p.Name },
+			func(p Person, name string) Person {
+				return Person{Name: name, Age: p.Age}
+			},
+		)
+
+		// Base codec succeeds for any Person
+		baseCodec := MakeType(
+			"Person",
+			func(i any) validation.Result[Person] {
+				if p, ok := i.(Person); ok {
+					return validation.ToResult(validation.Success(p))
+				}
+				return validation.ToResult(validation.Failures[Person](validation.Errors{
+					&validation.ValidationError{Value: i, Messsage: "expected Person"},
+				}))
+			},
+			func(i any) Decode[Context, Person] {
+				return func(ctx Context) validation.Validation[Person] {
+					if p, ok := i.(Person); ok {
+						return validation.Success(p)
+					}
+					return validation.FailureWithMessage[Person](i, "expected Person")(ctx)
+				}
+			},
+			func(p Person) string { return "" },
+		)
+
+		// Kleisli arrow: the field codec receives the same input I (any = Person).
+		// It extracts the Name from the Person input.
+		// If the decoded struct's Age > 18, accept any name (including empty).
+		// If Age <= 18, reject empty names.
+		kleisli := func(p Person) Type[string, string, any] {
+			if p.Age > 18 {
+				// Adult: accept any name extracted from the Person input
+				return MakeType(
+					"AnyName",
+					func(i any) validation.Result[string] {
+						if person, ok := i.(Person); ok {
+							return validation.ToResult(validation.Success(person.Name))
+						}
+						return validation.ToResult(validation.Failures[string](validation.Errors{
+							&validation.ValidationError{Value: i, Messsage: "expected Person"},
+						}))
+					},
+					func(i any) Decode[Context, string] {
+						return func(ctx Context) validation.Validation[string] {
+							if person, ok := i.(Person); ok {
+								return validation.Success(person.Name)
+							}
+							return validation.FailureWithMessage[string](i, "expected Person")(ctx)
+						}
+					},
+					F.Identity[string],
+				)
+			}
+			// Minor: reject empty names
+			return MakeType(
+				"NonEmptyName",
+				func(i any) validation.Result[string] {
+					if person, ok := i.(Person); ok {
+						if person.Name != "" {
+							return validation.ToResult(validation.Success(person.Name))
+						}
+						return validation.ToResult(validation.Failures[string](validation.Errors{
+							&validation.ValidationError{Value: person.Name, Messsage: "name must not be empty for minors"},
+						}))
+					}
+					return validation.ToResult(validation.Failures[string](validation.Errors{
+						&validation.ValidationError{Value: i, Messsage: "expected Person"},
+					}))
+				},
+				func(i any) Decode[Context, string] {
+					return func(ctx Context) validation.Validation[string] {
+						if person, ok := i.(Person); ok {
+							if person.Name != "" {
+								return validation.Success(person.Name)
+							}
+							return validation.FailureWithMessage[string](person.Name, "name must not be empty for minors")(ctx)
+						}
+						return validation.FailureWithMessage[string](i, "expected Person")(ctx)
+					}
+				},
+				F.Identity[string],
+			)
+		}
+
+		operator := Bind(S.Monoid, nameLens, kleisli)
+		enhancedCodec := operator(baseCodec)
+
+		// Adult (Age=30) with empty name: should succeed (adult codec accepts any name)
+		adultPerson := Person{Name: "", Age: 30}
+		adultResult := enhancedCodec.Decode(adultPerson)
+		assert.True(t, either.IsRight(adultResult), "Adult should accept empty name")
+
+		// Minor (Age=15) with empty name: should fail (minor codec rejects empty names)
+		minorPerson := Person{Name: "", Age: 15}
+		minorResult := enhancedCodec.Decode(minorPerson)
+		assert.True(t, either.IsLeft(minorResult), "Minor with empty name should fail")
+
+		// Minor (Age=15) with non-empty name: should succeed
+		minorWithName := Person{Name: "Junior", Age: 15}
+		minorWithNameResult := enhancedCodec.Decode(minorWithName)
+		assert.True(t, either.IsRight(minorWithNameResult), "Minor with non-empty name should succeed")
+	})
+}