fix: clarify behaviour of array.Concat

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

v2/array/array.go

@@ -529,71 +529,116 @@ func Push[A any](a A) Operator[A, A] {
 	return G.Push[Operator[A, A]](a)
 }
 
-// Concat concatenates two arrays, appending the provided array to the end of the input array.
-// This is a curried function that takes an array to append and returns a function that
-// takes the base array and returns the concatenated result.
+// Concat concatenates two arrays by appending a suffix array to a base array.
 //
-// The function creates a new array containing all elements from the base array followed
-// by all elements from the appended array. Neither input array is modified.
+// This is a curried function that takes a suffix array and returns a function
+// that takes a base array and produces a new array with the suffix appended.
+// It follows the "data last" pattern, where the data to be operated on (base array)
+// is provided last, making it ideal for use in functional pipelines.
+//
+// Semantic: Concat(suffix)(base) produces [base... suffix...]
+//
+// The function creates a new array containing all elements from the base array
+// followed by all elements from the suffix array. Neither input array is modified.
 //
 // Type Parameters:
+//
 //   - A: The type of elements in the arrays
 //
 // Parameters:
-//   - as: The array to append to the end of the base array
+//
+//   - suffix: The array to append to the end of the base array
 //
 // Returns:
-//   - A function that takes a base array and returns a new array with `as` appended to its end
+//
+//   - A function that takes a base array and returns [base... suffix...]
 //
 // Behavior:
-//   - Creates a new array with length equal to the sum of both input arrays
-//   - Copies all elements from the base array first
-//   - Appends all elements from the `as` array at the end
-//   - Returns the base array unchanged if `as` is empty
-//   - Returns `as` unchanged if the base array is empty
-//   - Does not modify either input array
 //
-// Example:
+//   - Creates a new array with length equal to len(base) + len(suffix)
+//   - Copies all elements from the base array first
+//   - Appends all elements from the suffix array at the end
+//   - Returns the base array unchanged if suffix is empty
+//   - Returns suffix unchanged if the base array is empty
+//   - Does not modify either input array
+//   - Preserves element order within each array
+//
+// Example - Basic concatenation:
 //
 //	base := []int{1, 2, 3}
-//	toAppend := []int{4, 5, 6}
-//	result := array.Concat(toAppend)(base)
+//	suffix := []int{4, 5, 6}
+//	concat := array.Concat(suffix)
+//	result := concat(base)
 //	// result: []int{1, 2, 3, 4, 5, 6}
 //	// base: []int{1, 2, 3} (unchanged)
-//	// toAppend: []int{4, 5, 6} (unchanged)
+//	// suffix: []int{4, 5, 6} (unchanged)
 //
-// Example with empty arrays:
+// Example - Direct application:
+//
+//	result := array.Concat([]int{4, 5, 6})([]int{1, 2, 3})
+//	// result: []int{1, 2, 3, 4, 5, 6}
+//	// Demonstrates: Concat(b)(a) = [a... b...]
+//
+// Example - Empty arrays:
 //
 //	base := []int{1, 2, 3}
 //	empty := []int{}
 //	result := array.Concat(empty)(base)
 //	// result: []int{1, 2, 3}
 //
-// Example with strings:
+// Example - Strings:
 //
 //	words1 := []string{"hello", "world"}
 //	words2 := []string{"foo", "bar"}
 //	result := array.Concat(words2)(words1)
 //	// result: []string{"hello", "world", "foo", "bar"}
 //
-// Example with functional composition:
+// Example - Functional composition:
 //
 //	numbers := []int{1, 2, 3}
 //	result := F.Pipe2(
 //	    numbers,
-//	    array.Map(N.Mul(2)),
-//	    array.Concat([]int{10, 20}),
+//	    array.Map(N.Mul(2)),           // [2, 4, 6]
+//	    array.Concat([]int{10, 20}),   // [2, 4, 6, 10, 20]
 //	)
-//	// result: []int{2, 4, 6, 10, 20}
+//
+// Example - Multiple concatenations:
+//
+//	result := F.Pipe2(
+//	    []int{1},
+//	    array.Concat([]int{2, 3}),     // [1, 2, 3]
+//	    array.Concat([]int{4, 5}),     // [1, 2, 3, 4, 5]
+//	)
+//
+// Example - Building arrays incrementally:
+//
+//	header := []string{"Name", "Age"}
+//	data := []string{"Alice", "30"}
+//	footer := []string{"Total: 1"}
+//	result := F.Pipe2(
+//	    header,
+//	    array.Concat(data),
+//	    array.Concat(footer),
+//	)
+//	// result: []string{"Name", "Age", "Alice", "30", "Total: 1"}
 //
 // Use cases:
+//
 //   - Combining multiple arrays into one
-//   - Building arrays incrementally
+//   - Building arrays incrementally in pipelines
 //   - Implementing array-based data structures (queues, buffers)
 //   - Merging results from multiple operations
-//   - Creating array pipelines with functional composition
+//   - Creating array transformation pipelines
+//   - Appending batches of elements
+//
+// Mathematical properties:
+//
+//   - Associativity: Concat(c)(Concat(b)(a)) == Concat(Concat(c)(b))(a)
+//   - Identity: Concat([])(a) == a and Concat(a)([]) == a
+//   - Length: len(Concat(b)(a)) == len(a) + len(b)
 //
 // Performance:
+//
 //   - Time complexity: O(n + m) where n and m are the lengths of the arrays
 //   - Space complexity: O(n + m) for the new array
 //   - Optimized to avoid allocation when one array is empty
@@ -601,9 +646,15 @@ func Push[A any](a A) Operator[A, A] {
 // Note: This function is immutable - it creates a new array rather than modifying
 // the input arrays. For appending a single element, consider using Append or Push.
 //
+// See Also:
+//
+//   - Append: For appending a single element
+//   - Push: Curried version of Append
+//   - Flatten: For flattening nested arrays
+//
 //go:inline
-func Concat[A any](as []A) Operator[A, A] {
-	return F.Bind2nd(array.Concat[[]A, A], as)
+func Concat[A any](suffix []A) Operator[A, A] {
+	return F.Bind2nd(array.Concat[[]A, A], suffix)
 }
 
 // MonadFlap applies a value to an array of functions, producing an array of results.

v2/array/array_test.go

@@ -767,6 +767,25 @@ func TestExtendUseCases(t *testing.T) {
 
 // TestConcat tests the Concat function
 func TestConcat(t *testing.T) {
+	t.Run("Semantic: Concat(b)(a) produces [a... b...]", func(t *testing.T) {
+		a := []int{1, 2, 3}
+		b := []int{4, 5, 6}
+
+		// Concat(b)(a) should produce [a... b...]
+		result := Concat(b)(a)
+		expected := []int{1, 2, 3, 4, 5, 6}
+
+		assert.Equal(t, expected, result, "Concat(b)(a) should produce [a... b...]")
+
+		// Verify order: a's elements come first, then b's elements
+		assert.Equal(t, a[0], result[0], "First element should be from a")
+		assert.Equal(t, a[1], result[1], "Second element should be from a")
+		assert.Equal(t, a[2], result[2], "Third element should be from a")
+		assert.Equal(t, b[0], result[3], "Fourth element should be from b")
+		assert.Equal(t, b[1], result[4], "Fifth element should be from b")
+		assert.Equal(t, b[2], result[5], "Sixth element should be from b")
+	})
+
 	t.Run("Concat two non-empty arrays", func(t *testing.T) {
 		base := []int{1, 2, 3}
 		toAppend := []int{4, 5, 6}
@@ -870,6 +889,54 @@ func TestConcat(t *testing.T) {
 		expected := []int{1, 2, 3}
 		assert.Equal(t, expected, result)
 	})
+	t.Run("Explicit append semantic demonstration", func(t *testing.T) {
+		// Given a base array
+		base := []string{"A", "B", "C"}
+
+		// And a suffix to append
+		suffix := []string{"D", "E", "F"}
+
+		// When we apply Concat(suffix) to base
+		appendSuffix := Concat(suffix)
+		result := appendSuffix(base)
+
+		// Then the result should be base followed by suffix
+		expected := []string{"A", "B", "C", "D", "E", "F"}
+		assert.Equal(t, expected, result)
+
+		// And the base should be unchanged
+		assert.Equal(t, []string{"A", "B", "C"}, base)
+
+		// And the suffix should be unchanged
+		assert.Equal(t, []string{"D", "E", "F"}, suffix)
+	})
+
+	t.Run("Append semantic with different types", func(t *testing.T) {
+		// Integers
+		intResult := Concat([]int{4, 5})([]int{1, 2, 3})
+		assert.Equal(t, []int{1, 2, 3, 4, 5}, intResult)
+
+		// Strings
+		strResult := Concat([]string{"world"})([]string{"hello"})
+		assert.Equal(t, []string{"hello", "world"}, strResult)
+
+		// Floats
+		floatResult := Concat([]float64{3.3, 4.4})([]float64{1.1, 2.2})
+		assert.Equal(t, []float64{1.1, 2.2, 3.3, 4.4}, floatResult)
+	})
+
+	t.Run("Append semantic in pipeline", func(t *testing.T) {
+		// Start with [1, 2, 3]
+		// Append [4, 5] to get [1, 2, 3, 4, 5]
+		// Append [6, 7] to get [1, 2, 3, 4, 5, 6, 7]
+		result := F.Pipe2(
+			[]int{1, 2, 3},
+			Concat([]int{4, 5}),
+			Concat([]int{6, 7}),
+		)
+		expected := []int{1, 2, 3, 4, 5, 6, 7}
+		assert.Equal(t, expected, result)
+	})
 }
 
 // TestConcatComposition tests Concat with other array operations

v2/function/gen.go

@@ -236,6 +236,7 @@ func Pipe4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T
 // The final return value is the result of the last function application
 //go:inline
 func Flow4[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, T0, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T0) T4 {
+	//go:inline
 	return func(t0 T0) T4 {
 		return Pipe4(t0, f1, f2, f3, f4)
 	}
@@ -302,6 +303,7 @@ func Pipe5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F
 // The final return value is the result of the last function application
 //go:inline
 func Flow5[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, T0, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T0) T5 {
+	//go:inline
 	return func(t0 T0) T5 {
 		return Pipe5(t0, f1, f2, f3, f4, f5)
 	}
@@ -370,6 +372,7 @@ func Pipe6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F
 // The final return value is the result of the last function application
 //go:inline
 func Flow6[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, T0, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T0) T6 {
+	//go:inline
 	return func(t0 T0) T6 {
 		return Pipe6(t0, f1, f2, f3, f4, f5, f6)
 	}
@@ -440,6 +443,7 @@ func Pipe7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F
 // The final return value is the result of the last function application
 //go:inline
 func Flow7[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, T0, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T0) T7 {
+	//go:inline
 	return func(t0 T0) T7 {
 		return Pipe7(t0, f1, f2, f3, f4, f5, f6, f7)
 	}
@@ -512,6 +516,7 @@ func Pipe8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F
 // The final return value is the result of the last function application
 //go:inline
 func Flow8[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, T0, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T0) T8 {
+	//go:inline
 	return func(t0 T0) T8 {
 		return Pipe8(t0, f1, f2, f3, f4, f5, f6, f7, f8)
 	}
@@ -586,6 +591,7 @@ func Pipe9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F
 // The final return value is the result of the last function application
 //go:inline
 func Flow9[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T0) T9 {
+	//go:inline
 	return func(t0 T0) T9 {
 		return Pipe9(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9)
 	}
@@ -662,6 +668,7 @@ func Pipe10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow10[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T0) T10 {
+	//go:inline
 	return func(t0 T0) T10 {
 		return Pipe10(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10)
 	}
@@ -740,6 +747,7 @@ func Pipe11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow11[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11) func(T0) T11 {
+	//go:inline
 	return func(t0 T0) T11 {
 		return Pipe11(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11)
 	}
@@ -820,6 +828,7 @@ func Pipe12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow12[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12) func(T0) T12 {
+	//go:inline
 	return func(t0 T0) T12 {
 		return Pipe12(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12)
 	}
@@ -902,6 +911,7 @@ func Pipe13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow13[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13) func(T0) T13 {
+	//go:inline
 	return func(t0 T0) T13 {
 		return Pipe13(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13)
 	}
@@ -986,6 +996,7 @@ func Pipe14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow14[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14) func(T0) T14 {
+	//go:inline
 	return func(t0 T0) T14 {
 		return Pipe14(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14)
 	}
@@ -1072,6 +1083,7 @@ func Pipe15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow15[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15) func(T0) T15 {
+	//go:inline
 	return func(t0 T0) T15 {
 		return Pipe15(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15)
 	}
@@ -1160,6 +1172,7 @@ func Pipe16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow16[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16) func(T0) T16 {
+	//go:inline
 	return func(t0 T0) T16 {
 		return Pipe16(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16)
 	}
@@ -1250,6 +1263,7 @@ func Pipe17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow17[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17) func(T0) T17 {
+	//go:inline
 	return func(t0 T0) T17 {
 		return Pipe17(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17)
 	}
@@ -1342,6 +1356,7 @@ func Pipe18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow18[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18) func(T0) T18 {
+	//go:inline
 	return func(t0 T0) T18 {
 		return Pipe18(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18)
 	}
@@ -1436,6 +1451,7 @@ func Pipe19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow19[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19) func(T0) T19 {
+	//go:inline
 	return func(t0 T0) T19 {
 		return Pipe19(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19)
 	}
@@ -1532,6 +1548,7 @@ func Pipe20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4,
 // The final return value is the result of the last function application
 //go:inline
 func Flow20[F1 ~func(T0) T1, F2 ~func(T1) T2, F3 ~func(T2) T3, F4 ~func(T3) T4, F5 ~func(T4) T5, F6 ~func(T5) T6, F7 ~func(T6) T7, F8 ~func(T7) T8, F9 ~func(T8) T9, F10 ~func(T9) T10, F11 ~func(T10) T11, F12 ~func(T11) T12, F13 ~func(T12) T13, F14 ~func(T13) T14, F15 ~func(T14) T15, F16 ~func(T15) T16, F17 ~func(T16) T17, F18 ~func(T17) T18, F19 ~func(T18) T19, F20 ~func(T19) T20, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10, f11 F11, f12 F12, f13 F13, f14 F14, f15 F15, f16 F16, f17 F17, f18 F18, f19 F19, f20 F20) func(T0) T20 {
+	//go:inline
 	return func(t0 T0) T20 {
 		return Pipe20(t0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20)
 	}

v2/optics/codec/iso.go

@@ -0,0 +1,169 @@
+// 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/optics/codec/decode"
+)
+
+// FromIso creates a Type codec from an Iso (isomorphism).
+//
+// An isomorphism represents a bidirectional transformation between types I and A
+// without any loss of information. This function converts an Iso[I, A] into a
+// Type[A, I, I] codec that can validate, decode, and encode values using the
+// isomorphism's transformations.
+//
+// The resulting codec:
+//   - Decode: Uses iso.Get to transform I → A, always succeeds (no validation)
+//   - Encode: Uses iso.ReverseGet to transform A → I
+//   - Validation: Always succeeds since isomorphisms are lossless transformations
+//   - Type checking: Uses standard type checking for type A
+//
+// This is particularly useful for:
+//   - Creating codecs for newtype patterns (wrapping/unwrapping types)
+//   - Building codecs for types with lossless conversions
+//   - Composing with other codecs using Pipe or other operators
+//   - Implementing bidirectional transformations in codec pipelines
+//
+// # Type Parameters
+//
+//   - A: The target type (what we decode to and encode from)
+//   - I: The input/output type (what we decode from and encode to)
+//
+// # Parameters
+//
+//   - iso: An Iso[I, A] that defines the bidirectional transformation:
+//   - Get: I → A (converts input to target type)
+//   - ReverseGet: A → I (converts target back to input type)
+//
+// # Returns
+//
+//   - A Type[A, I, I] codec where:
+//   - Decode: I → Validation[A] - transforms using iso.Get, always succeeds
+//   - Encode: A → I - transforms using iso.ReverseGet
+//   - Is: Checks if a value is of type A
+//   - Name: Returns "FromIso[iso_string_representation]"
+//
+// # Behavior
+//
+// Decoding:
+//   - Applies iso.Get to transform the input value
+//   - Wraps the result in decode.Of (always successful validation)
+//   - No validation errors can occur since isomorphisms are lossless
+//
+// Encoding:
+//   - Applies iso.ReverseGet to transform back to the input type
+//   - Always succeeds as isomorphisms guarantee reversibility
+//
+// # Example Usage
+//
+// Creating a codec for a newtype pattern:
+//
+//	type UserId int
+//
+//	// Define an isomorphism between int and UserId
+//	userIdIso := iso.MakeIso(
+//	    func(id UserId) int { return int(id) },
+//	    func(i int) UserId { return UserId(i) },
+//	)
+//
+//	// Create a codec from the isomorphism
+//	userIdCodec := codec.FromIso[int, UserId](userIdIso)
+//
+//	// Decode: UserId → int
+//	result := userIdCodec.Decode(UserId(42))  // Success: Right(42)
+//
+//	// Encode: int → UserId
+//	encoded := userIdCodec.Encode(42)         // Returns: UserId(42)
+//
+// Using with temperature conversions:
+//
+//	type Celsius float64
+//	type Fahrenheit float64
+//
+//	celsiusToFahrenheit := iso.MakeIso(
+//	    func(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) },
+//	    func(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) },
+//	)
+//
+//	tempCodec := codec.FromIso[Fahrenheit, Celsius](celsiusToFahrenheit)
+//
+//	// Decode: Celsius → Fahrenheit
+//	result := tempCodec.Decode(Celsius(20))   // Success: Right(68°F)
+//
+//	// Encode: Fahrenheit → Celsius
+//	encoded := tempCodec.Encode(Fahrenheit(68)) // Returns: 20°C
+//
+// Composing with other codecs:
+//
+//	type Email string
+//	type ValidatedEmail struct{ value Email }
+//
+//	emailIso := iso.MakeIso(
+//	    func(ve ValidatedEmail) Email { return ve.value },
+//	    func(e Email) ValidatedEmail { return ValidatedEmail{value: e} },
+//	)
+//
+//	// Compose with string codec for validation
+//	emailCodec := F.Pipe2(
+//	    codec.String(),                           // Type[string, string, any]
+//	    codec.Pipe(codec.FromIso[Email, string](  // Add string → Email iso
+//	        iso.MakeIso(
+//	            func(s string) Email { return Email(s) },
+//	            func(e Email) string { return string(e) },
+//	        ),
+//	    )),
+//	    codec.Pipe(codec.FromIso[ValidatedEmail, Email](emailIso)), // Add Email → ValidatedEmail iso
+//	)
+//
+// # Use Cases
+//
+//   - Newtype patterns: Wrapping primitive types for type safety
+//   - Unit conversions: Temperature, distance, time, etc.
+//   - Format transformations: Between equivalent representations
+//   - Type aliasing: Creating semantic types from base types
+//   - Codec composition: Building complex codecs from simple isomorphisms
+//
+// # Notes
+//
+//   - Isomorphisms must satisfy the round-trip laws:
+//   - iso.ReverseGet(iso.Get(i)) == i
+//   - iso.Get(iso.ReverseGet(a)) == a
+//   - Validation always succeeds since isomorphisms are lossless
+//   - The codec name includes the isomorphism's string representation
+//   - Type checking is performed using the standard Is[A]() function
+//   - This codec is ideal for lossless transformations without validation logic
+//
+// # See Also
+//
+//   - iso.Iso: The isomorphism type used by this function
+//   - iso.MakeIso: Constructor for creating isomorphisms
+//   - Pipe: For composing this codec with other codecs
+//   - MakeType: For creating codecs with custom validation logic
+func FromIso[A, I any](iso Iso[I, A]) Type[A, I, I] {
+	return MakeType(
+		fmt.Sprintf("FromIso[%s]", iso),
+		Is[A](),
+		F.Flow2(
+			iso.Get,
+			decode.Of[Context],
+		),
+		iso.ReverseGet,
+	)
+}

v2/optics/codec/iso_test.go

@@ -0,0 +1,504 @@
+// 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 (
+	"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/optics/iso"
+	"github.com/stretchr/testify/assert"
+)
+
+// Test types for newtype pattern
+type UserId int
+type Email string
+type Celsius float64
+type Fahrenheit float64
+
+func TestFromIso_Success(t *testing.T) {
+	t.Run("decodes using iso.Get", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		result := codec.Decode(UserId(42))
+
+		// Assert
+		assert.Equal(t, validation.Success(42), result)
+	})
+
+	t.Run("encodes using iso.ReverseGet", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		encoded := codec.Encode(42)
+
+		// Assert
+		assert.Equal(t, UserId(42), encoded)
+	})
+
+	t.Run("round-trip preserves value", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+		original := UserId(123)
+
+		// Act
+		decoded := codec.Decode(original)
+
+		// Assert
+		assert.True(t, either.IsRight(decoded))
+		roundTrip := either.Fold[validation.Errors, int, UserId](
+			func(validation.Errors) UserId { return UserId(0) },
+			codec.Encode,
+		)(decoded)
+		assert.Equal(t, original, roundTrip)
+	})
+}
+
+func TestFromIso_StringTypes(t *testing.T) {
+	t.Run("handles string newtype", func(t *testing.T) {
+		// Arrange
+		emailIso := iso.MakeIso(
+			func(e Email) string { return string(e) },
+			func(s string) Email { return Email(s) },
+		)
+		codec := FromIso[string, Email](emailIso)
+
+		// Act
+		result := codec.Decode(Email("user@example.com"))
+
+		// Assert
+		assert.Equal(t, validation.Success("user@example.com"), result)
+	})
+
+	t.Run("encodes string newtype", func(t *testing.T) {
+		// Arrange
+		emailIso := iso.MakeIso(
+			func(e Email) string { return string(e) },
+			func(s string) Email { return Email(s) },
+		)
+		codec := FromIso[string, Email](emailIso)
+
+		// Act
+		encoded := codec.Encode("admin@example.com")
+
+		// Assert
+		assert.Equal(t, Email("admin@example.com"), encoded)
+	})
+
+	t.Run("handles empty string", func(t *testing.T) {
+		// Arrange
+		emailIso := iso.MakeIso(
+			func(e Email) string { return string(e) },
+			func(s string) Email { return Email(s) },
+		)
+		codec := FromIso[string, Email](emailIso)
+
+		// Act
+		result := codec.Decode(Email(""))
+
+		// Assert
+		assert.Equal(t, validation.Success(""), result)
+	})
+}
+
+func TestFromIso_NumericConversions(t *testing.T) {
+	t.Run("converts Celsius to Fahrenheit", func(t *testing.T) {
+		// Arrange
+		tempIso := iso.MakeIso(
+			func(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) },
+			func(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) },
+		)
+		codec := FromIso[Fahrenheit, Celsius](tempIso)
+
+		// Act
+		result := codec.Decode(Celsius(0))
+
+		// Assert
+		assert.Equal(t, validation.Success(Fahrenheit(32)), result)
+	})
+
+	t.Run("converts Fahrenheit to Celsius", func(t *testing.T) {
+		// Arrange
+		tempIso := iso.MakeIso(
+			func(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) },
+			func(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) },
+		)
+		codec := FromIso[Fahrenheit, Celsius](tempIso)
+
+		// Act
+		encoded := codec.Encode(Fahrenheit(68))
+
+		// Assert
+		assert.Equal(t, Celsius(20), encoded)
+	})
+
+	t.Run("handles negative temperatures", func(t *testing.T) {
+		// Arrange
+		tempIso := iso.MakeIso(
+			func(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) },
+			func(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) },
+		)
+		codec := FromIso[Fahrenheit, Celsius](tempIso)
+
+		// Act
+		result := codec.Decode(Celsius(-40))
+
+		// Assert
+		assert.Equal(t, validation.Success(Fahrenheit(-40)), result)
+	})
+
+	t.Run("temperature round-trip", func(t *testing.T) {
+		// Arrange
+		tempIso := iso.MakeIso(
+			func(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) },
+			func(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) },
+		)
+		codec := FromIso[Fahrenheit, Celsius](tempIso)
+		original := Celsius(25)
+
+		// Act
+		decoded := codec.Decode(original)
+
+		// Assert
+		assert.True(t, either.IsRight(decoded))
+		roundTrip := either.Fold[validation.Errors, Fahrenheit, Celsius](
+			func(validation.Errors) Celsius { return Celsius(0) },
+			codec.Encode,
+		)(decoded)
+		// Allow small floating point error
+		diff := float64(original - roundTrip)
+		if diff < 0 {
+			diff = -diff
+		}
+		assert.True(t, diff < 0.0001)
+	})
+}
+
+func TestFromIso_EdgeCases(t *testing.T) {
+	t.Run("handles zero values", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		result := codec.Decode(UserId(0))
+
+		// Assert
+		assert.Equal(t, validation.Success(0), result)
+	})
+
+	t.Run("handles negative values", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		result := codec.Decode(UserId(-1))
+
+		// Assert
+		assert.Equal(t, validation.Success(-1), result)
+	})
+
+	t.Run("handles large values", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		result := codec.Decode(UserId(999999999))
+
+		// Assert
+		assert.Equal(t, validation.Success(999999999), result)
+	})
+}
+
+func TestFromIso_TypeChecking(t *testing.T) {
+	t.Run("Is checks target type", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		isResult := codec.Is(42)
+
+		// Assert
+		assert.True(t, either.IsRight(isResult))
+	})
+
+	t.Run("Is rejects wrong type", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		isResult := codec.Is("not an int")
+
+		// Assert
+		assert.True(t, either.IsLeft(isResult))
+	})
+}
+
+func TestFromIso_Name(t *testing.T) {
+	t.Run("includes iso in name", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		name := codec.Name()
+
+		// Assert
+		assert.True(t, len(name) > 0)
+		assert.True(t, name[:7] == "FromIso")
+	})
+}
+
+func TestFromIso_Composition(t *testing.T) {
+	t.Run("composes with Pipe", func(t *testing.T) {
+		// Arrange
+		type PositiveInt int
+
+		// First iso: UserId -> int
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+
+		// Second iso: int -> PositiveInt (no validation, just type conversion)
+		positiveIso := iso.MakeIso(
+			func(i int) PositiveInt { return PositiveInt(i) },
+			func(p PositiveInt) int { return int(p) },
+		)
+
+		// Compose codecs
+		codec := F.Pipe1(
+			FromIso[int, UserId](userIdIso),
+			Pipe[UserId, UserId](FromIso[PositiveInt, int](positiveIso)),
+		)
+
+		// Act
+		result := codec.Decode(UserId(42))
+
+		// Assert
+		assert.Equal(t, validation.Of(PositiveInt(42)), result)
+	})
+
+	t.Run("composed codec encodes correctly", func(t *testing.T) {
+		// Arrange
+		type PositiveInt int
+
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+
+		positiveIso := iso.MakeIso(
+			func(i int) PositiveInt { return PositiveInt(i) },
+			func(p PositiveInt) int { return int(p) },
+		)
+
+		codec := F.Pipe1(
+			FromIso[int, UserId](userIdIso),
+			Pipe[UserId, UserId](FromIso[PositiveInt, int](positiveIso)),
+		)
+
+		// Act
+		encoded := codec.Encode(PositiveInt(42))
+
+		// Assert
+		assert.Equal(t, UserId(42), encoded)
+	})
+}
+
+func TestFromIso_Integration(t *testing.T) {
+	t.Run("works with Array codec", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		userIdCodec := FromIso[int, UserId](userIdIso)
+		arrayCodec := TranscodeArray(userIdCodec)
+
+		// Act
+		result := arrayCodec.Decode([]UserId{UserId(1), UserId(2), UserId(3)})
+
+		// Assert
+		assert.Equal(t, validation.Success([]int{1, 2, 3}), result)
+	})
+
+	t.Run("encodes array correctly", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		userIdCodec := FromIso[int, UserId](userIdIso)
+		arrayCodec := TranscodeArray(userIdCodec)
+
+		// Act
+		encoded := arrayCodec.Encode([]int{1, 2, 3})
+
+		// Assert
+		assert.Equal(t, []UserId{UserId(1), UserId(2), UserId(3)}, encoded)
+	})
+
+	t.Run("handles empty array", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		userIdCodec := FromIso[int, UserId](userIdIso)
+		arrayCodec := TranscodeArray(userIdCodec)
+
+		// Act
+		result := arrayCodec.Decode([]UserId{})
+
+		// Assert
+		assert.True(t, either.IsRight(result))
+		decoded := either.Fold[validation.Errors, []int, []int](
+			func(validation.Errors) []int { return nil },
+			func(arr []int) []int { return arr },
+		)(result)
+		assert.Equal(t, 0, len(decoded))
+	})
+}
+
+func TestFromIso_ComplexTypes(t *testing.T) {
+	t.Run("handles struct wrapping", func(t *testing.T) {
+		// Arrange
+		type Wrapper struct{ Value int }
+
+		wrapperIso := iso.MakeIso(
+			func(w Wrapper) int { return w.Value },
+			func(i int) Wrapper { return Wrapper{Value: i} },
+		)
+		codec := FromIso[int, Wrapper](wrapperIso)
+
+		// Act
+		result := codec.Decode(Wrapper{Value: 42})
+
+		// Assert
+		assert.Equal(t, validation.Success(42), result)
+	})
+
+	t.Run("encodes struct wrapping", func(t *testing.T) {
+		// Arrange
+		type Wrapper struct{ Value int }
+
+		wrapperIso := iso.MakeIso(
+			func(w Wrapper) int { return w.Value },
+			func(i int) Wrapper { return Wrapper{Value: i} },
+		)
+		codec := FromIso[int, Wrapper](wrapperIso)
+
+		// Act
+		encoded := codec.Encode(42)
+
+		// Assert
+		assert.Equal(t, Wrapper{Value: 42}, encoded)
+	})
+}
+
+func TestFromIso_AsDecoder(t *testing.T) {
+	t.Run("returns decoder interface", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		decoder := codec.AsDecoder()
+
+		// Assert
+		result := decoder.Decode(UserId(42))
+		assert.Equal(t, validation.Success(42), result)
+	})
+}
+
+func TestFromIso_AsEncoder(t *testing.T) {
+	t.Run("returns encoder interface", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		encoder := codec.AsEncoder()
+
+		// Assert
+		encoded := encoder.Encode(42)
+		assert.Equal(t, UserId(42), encoded)
+	})
+}
+
+func TestFromIso_Validate(t *testing.T) {
+	t.Run("validate method works correctly", func(t *testing.T) {
+		// Arrange
+		userIdIso := iso.MakeIso(
+			func(id UserId) int { return int(id) },
+			func(i int) UserId { return UserId(i) },
+		)
+		codec := FromIso[int, UserId](userIdIso)
+
+		// Act
+		validateFn := codec.Validate(UserId(42))
+		result := validateFn([]validation.ContextEntry{})
+
+		// Assert
+		assert.Equal(t, validation.Success(42), result)
+	})
+}

v2/optics/codec/types.go

@@ -11,6 +11,7 @@ import (
 	"github.com/IBM/fp-go/v2/optics/codec/validation"
 	"github.com/IBM/fp-go/v2/optics/decoder"
 	"github.com/IBM/fp-go/v2/optics/encoder"
+	"github.com/IBM/fp-go/v2/optics/iso"
 	"github.com/IBM/fp-go/v2/optics/lens"
 	"github.com/IBM/fp-go/v2/optics/optional"
 	"github.com/IBM/fp-go/v2/optics/prism"
@@ -494,4 +495,7 @@ type (
 	//   - function.VOID: The single value of type Void
 	//   - Empty: Codec function that uses Void for unit types
 	Void = function.Void
+
+	// Iso represents an isomorphism - a bidirectional transformation between two types.
+	Iso[S, A any] = iso.Iso[S, A]
 )