fix: add inline annotations

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

.github/workflows/build.yml

@@ -4,9 +4,7 @@ on:
   push:
     branches:
       - main
-
   pull_request:
-
   workflow_dispatch:
     inputs:
       dryRun:
@@ -15,35 +13,80 @@ on:
         required: false
 
 env:
-  # Currently no way to detect automatically
   DEFAULT_BRANCH: main
-  GO_VERSION: 1.21.6 # renovate: datasource=golang-version depName=golang
-  NODE_VERSION: 20
+  LATEST_GO_VERSION: 1.25.2 # renovate: datasource=golang-version depName=golang
+  NODE_VERSION: 24
   DRY_RUN: true
 
 jobs:
-  build:
+  build-v1:
+    name: Build v1 (Go ${{ matrix.go-version }})
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: [ '1.20.x', '1.21.x', '1.22.x']
+        go-version: ['1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x', '1.25.x']
+      fail-fast: false  # Continue with other versions if one fails
     steps:
       # full checkout for semantic-release
-      - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
         with:
           fetch-depth: 0
-      - name: Set up go ${{ matrix.go-version }}
+      - name: Set up Go ${{ matrix.go-version }}
         uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
-      -
-        name: Tests
+          cache: true  # Enable Go module caching
+      - name: Run tests
         run: |
           go mod tidy
-          go test -v ./...
+          go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v5
+      #   with:
+      #     file: ./coverage.txt
+      #     flags: v1,go-${{ matrix.go-version }}
+      #     name: v1-go-${{ matrix.go-version }}
+      #     fail_ci_if_error: false
+      #   env:
+      #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  build-v2:
+    name: Build v2 (Go ${{ matrix.go-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: ['1.24.x', '1.25.x']
+    steps:
+      - uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
+        with:
+          fetch-depth: 0
+      - name: Set up Go ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+          cache: true  # Enable Go module caching
+      - name: Run tests
+        run: |
+          cd v2
+          go mod tidy
+          go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      
+      # - name: Upload coverage to Codecov
+      #   uses: codecov/codecov-action@v5
+      #   with:
+      #     file: ./v2/coverage.txt
+      #     flags: v2,go-${{ matrix.go-version }}
+      #     name: v2-go-${{ matrix.go-version }}
+      #     fail_ci_if_error: false
+      #   env:
+      #     CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   release:
-    needs: [build]
+    name: Release
+    needs: 
+      - build-v1
+      - build-v2
     if: github.repository == 'IBM/fp-go' && github.event_name != 'pull_request'
     runs-on: ubuntu-latest
     timeout-minutes: 15
@@ -51,38 +94,37 @@ jobs:
       contents: write
       issues: write
       pull-requests: write
-
     steps:
       # full checkout for semantic-release
       - name: Full checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0
         with:
           fetch-depth: 0
 
       - name: Set up Node.js ${{ env.NODE_VERSION }}
-        uses: actions/setup-node@60edb5dd545a775178f52524783378180af0d1f8 # v4.0.2
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
           node-version: ${{ env.NODE_VERSION }}
 
-      - name: Set up go ${{env.GO_VERSION}}
+      - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: ${{env.GO_VERSION}}
+          go-version: ${{ env.LATEST_GO_VERSION }}
+          cache: true  # Enable Go module caching
 
-      # The dry-run evaluation is only made for non PR events. Manual trigger w/dryRun true, main branch and any tagged branches will set DRY run to false
-      - name: Check dry run
+      - name: Determine release mode
+        id: release-mode
         run: |
-          if [[ "${{github.event_name}}" == "workflow_dispatch" && "${{ github.event.inputs.dryRun }}" != "true"  ]]; then
-              echo "DRY_RUN=false" >> $GITHUB_ENV
-          elif [[ "${{github.ref}}" == "refs/heads/${{env.DEFAULT_BRANCH}}" ]]; then
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" && "${{ github.event.inputs.dryRun }}" != "true" ]]; then
             echo "DRY_RUN=false" >> $GITHUB_ENV
-          elif [[ "${{github.ref}}" =~ ^refs/heads/v[0-9]+(\.[0-9]+)?$ ]]; then
+          elif [[ "${{ github.ref }}" == "refs/heads/${{ env.DEFAULT_BRANCH }}" ]]; then
+            echo "DRY_RUN=false" >> $GITHUB_ENV
+          elif [[ "${{ github.ref }}" =~ ^refs/heads/v[0-9]+(\.[0-9]+)?$ ]]; then
             echo "DRY_RUN=false" >> $GITHUB_ENV
           fi
 
-      - name: Semantic Release
+      - name: Run semantic release
         run: |
-          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{env.DRY_RUN}}
+          npx -p conventional-changelog-conventionalcommits -p semantic-release semantic-release --dry-run ${{ env.DRY_RUN }}
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,4 +1,5 @@
 fp-go.exe
+fp-go
 main.exe
 build/
 .idea

.whitesource

@@ -0,0 +1,3 @@
+{
+  "settingsInheritedFrom": "ibm-mend-config/mend-config@main"
+}

README.md

@@ -29,9 +29,9 @@ This library aims to provide a set of data types and functions that make it easy
 
 ### How does this play with the [🧘🏽 Zen Of Go](https://the-zen-of-go.netlify.app/)?
 
-#### 🧘🏽 Each package fulfils a single purpose
+#### 🧘🏽 Each package fulfills a single purpose
 
-✔️ Each of the top level packages (e.g. Option, Either, ReaderIOEither, ...) fulfils the purpose of defining the respective data type and implementing the set of common operations for this data type.
+✔️ Each of the top level packages (e.g. Option, Either, ReaderIOEither, ...) fulfills the purpose of defining the respective data type and implementing the set of common operations for this data type.
 
 #### 🧘🏽 Handle errors explicitly
 
@@ -199,9 +199,9 @@ For that reason these implementations are kept in the `internal` package. These
 
 The following table lists the relationship between some selected operators
 
-| Opertator | Parameter        | Monad           | Result   |
-| --------  | ---------------- | --------------- | -------- |
-| Map       | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
-| Chain     | `func(A) HKT[B]` | `HKT[A]` | `HKT[B]` |
-| Ap        | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
-| Flap      | `A`              | `HKT[func(A)B]` | `HKT[B]` |
+| Operator | Parameter        | Monad           | Result   |
+| -------- | ---------------- | --------------- | -------- |
+| Map      | `func(A) B`      | `HKT[A]`        | `HKT[B]` |
+| Chain    | `func(A) HKT[B]` | `HKT[A]`        | `HKT[B]` |
+| Ap       | `HKT[A]`         | `HKT[func(A)B]` | `HKT[B]` |
+| Flap     | `A`              | `HKT[func(A)B]` | `HKT[B]` |

array/array.go

@@ -141,6 +141,10 @@ func reduceRef[A, B any](fa []A, f func(B, *A) B, initial B) B {
 	return current
 }
 
+func MonadReduce[A, B any](fa []A, f func(B, A) B, initial B) B {
+	return G.MonadReduce(fa, f, initial)
+}
+
 func Reduce[A, B any](f func(B, A) B, initial B) func([]A) B {
 	return G.Reduce[[]A](f, initial)
 }

cli/contextreaderioeither.go

@@ -365,6 +365,70 @@ func generateContextReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintln(fg, "}")
 }
 
+func generateContextReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", R any](f F) func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[R]", i)
+
+	fmt.Fprintf(f, ", func(context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the [context.Context].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(context.Context) GIOA, F ~func(context.Context", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c context.Context")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateContextReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -420,10 +484,12 @@ import (
 `)
 
 	generateContextReaderIOEitherEitherize(f, fg, 0)
+	generateContextReaderIOEitherUneitherize(f, fg, 0)
 
 	for i := 1; i <= count; i++ {
 		// eitherize
 		generateContextReaderIOEitherEitherize(f, fg, i)
+		generateContextReaderIOEitherUneitherize(f, fg, i)
 		// sequenceT
 		generateContextReaderIOEitherSequenceT("")(f, fg, i)
 		generateContextReaderIOEitherSequenceT("Seq")(f, fg, i)

cli/readerioeither.go

@@ -136,6 +136,70 @@ func generateReaderIOEitherEitherize(f, fg *os.File, i int) {
 	fmt.Fprintf(fg, "}\n")
 }
 
+func generateReaderIOEitherUneitherize(f, fg *os.File, i int) {
+	// non generic version
+	fmt.Fprintf(f, "\n// Uneitherize%d converts a function with %d parameters returning a [ReaderIOEither[C, error, R]] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i+1, i)
+	fmt.Fprintf(f, "func Uneitherize%d[F ~func(", i)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j)
+	}
+	fmt.Fprintf(f, ") ReaderIOEither[C, error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ", C, R any](f F) func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ") (R, error) {\n")
+	fmt.Fprintf(f, "  return G.Uneitherize%d[ReaderIOEither[C, error, R]", i)
+
+	fmt.Fprintf(f, ", func(C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(f, ", T%d", j)
+	}
+	fmt.Fprintf(f, ")(R, error)](f)\n")
+	fmt.Fprintln(f, "}")
+
+	// generic version
+	fmt.Fprintf(fg, "\n// Uneitherize%d converts a function with %d parameters returning a [GRA] into a function with %d parameters returning a tuple.\n// The first parameter is considered to be the context [C].\n", i, i, i)
+	fmt.Fprintf(fg, "func Uneitherize%d[GRA ~func(C) GIOA, F ~func(C", i)
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ") (R, error), GIOA ~func() E.Either[error, R]")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", T%d", j)
+	}
+	fmt.Fprintf(fg, ", C, R any](f func(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "T%d", j)
+	}
+	fmt.Fprintf(fg, ") GRA) F {\n")
+
+	fmt.Fprintf(fg, "  return func(c C")
+	for j := 0; j < i; j++ {
+		fmt.Fprintf(fg, ", t%d T%d", j, j)
+	}
+	fmt.Fprintf(fg, ") (R, error) {\n")
+	fmt.Fprintf(fg, "    return E.UnwrapError(f(")
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(fg, ", ")
+		}
+		fmt.Fprintf(fg, "t%d", j)
+	}
+	fmt.Fprintf(fg, ")(c)())\n")
+	fmt.Fprintf(fg, "  }\n")
+	fmt.Fprintf(fg, "}\n")
+}
+
 func generateReaderIOEitherHelpers(filename string, count int) error {
 	dir, err := os.Getwd()
 	if err != nil {
@@ -197,12 +261,16 @@ import (
 	generateReaderIOEitherFrom(f, fg, 0)
 	// eitherize
 	generateReaderIOEitherEitherize(f, fg, 0)
+	// uneitherize
+	generateReaderIOEitherUneitherize(f, fg, 0)
 
 	for i := 1; i <= count; i++ {
 		// from
 		generateReaderIOEitherFrom(f, fg, i)
 		// eitherize
 		generateReaderIOEitherEitherize(f, fg, i)
+		// uneitherize
+		generateReaderIOEitherUneitherize(f, fg, i)
 	}
 
 	return nil

cli/templates/functions.go

@@ -0,0 +1,15 @@
+package templates
+
+import (
+	"text/template"
+
+	E "github.com/IBM/fp-go/either"
+)
+
+var (
+	templateFunctions = template.FuncMap{}
+)
+
+func Parse(name, tmpl string) E.Either[error, *template.Template] {
+	return E.TryCatchError(template.New(name).Funcs(templateFunctions).Parse(tmpl))
+}

context/readerioeither/gen.go

@@ -2,7 +2,7 @@ package readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:18:46.1201552 +0100 CET m=+0.020664901
+// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
 
 import (
 	"context"
@@ -17,12 +17,24 @@ func Eitherize0[F ~func(context.Context) (R, error), R any](f F) func() ReaderIO
 	return G.Eitherize0[ReaderIOEither[R]](f)
 }
 
+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[F ~func() ReaderIOEither[R], R any](f F) func(context.Context) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[R], func(context.Context) (R, error)](f)
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The inverse function is [Uneitherize1]
 func Eitherize1[F ~func(context.Context, T0) (R, error), T0, R any](f F) func(T0) ReaderIOEither[R] {
 	return G.Eitherize1[ReaderIOEither[R]](f)
 }
 
+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[F ~func(T0) ReaderIOEither[R], T0, R any](f F) func(context.Context, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[R], func(context.Context, T0) (R, error)](f)
+}
+
 // SequenceT1 converts 1 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple1].
 func SequenceT1[T1 any](t1 ReaderIOEither[T1]) ReaderIOEither[T.Tuple1[T1]] {
 	return G.SequenceT1[ReaderIOEither[T.Tuple1[T1]]](t1)
@@ -74,6 +86,12 @@ func Eitherize2[F ~func(context.Context, T0, T1) (R, error), T0, T1, R any](f F)
 	return G.Eitherize2[ReaderIOEither[R]](f)
 }
 
+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[R], T0, T1, R any](f F) func(context.Context, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[R], func(context.Context, T0, T1) (R, error)](f)
+}
+
 // SequenceT2 converts 2 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple2].
 func SequenceT2[T1, T2 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2]) ReaderIOEither[T.Tuple2[T1, T2]] {
 	return G.SequenceT2[ReaderIOEither[T.Tuple2[T1, T2]]](t1, t2)
@@ -125,6 +143,12 @@ func Eitherize3[F ~func(context.Context, T0, T1, T2) (R, error), T0, T1, T2, R a
 	return G.Eitherize3[ReaderIOEither[R]](f)
 }
 
+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[R], T0, T1, T2, R any](f F) func(context.Context, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[R], func(context.Context, T0, T1, T2) (R, error)](f)
+}
+
 // SequenceT3 converts 3 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple3].
 func SequenceT3[T1, T2, T3 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3]) ReaderIOEither[T.Tuple3[T1, T2, T3]] {
 	return G.SequenceT3[ReaderIOEither[T.Tuple3[T1, T2, T3]]](t1, t2, t3)
@@ -176,6 +200,12 @@ func Eitherize4[F ~func(context.Context, T0, T1, T2, T3) (R, error), T0, T1, T2,
 	return G.Eitherize4[ReaderIOEither[R]](f)
 }
 
+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[R], T0, T1, T2, T3, R any](f F) func(context.Context, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3) (R, error)](f)
+}
+
 // SequenceT4 converts 4 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple4].
 func SequenceT4[T1, T2, T3, T4 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4]) ReaderIOEither[T.Tuple4[T1, T2, T3, T4]] {
 	return G.SequenceT4[ReaderIOEither[T.Tuple4[T1, T2, T3, T4]]](t1, t2, t3, t4)
@@ -227,6 +257,12 @@ func Eitherize5[F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), T0, T1,
 	return G.Eitherize5[ReaderIOEither[R]](f)
 }
 
+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[R], T0, T1, T2, T3, T4, R any](f F) func(context.Context, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // SequenceT5 converts 5 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple5].
 func SequenceT5[T1, T2, T3, T4, T5 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5]) ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]] {
 	return G.SequenceT5[ReaderIOEither[T.Tuple5[T1, T2, T3, T4, T5]]](t1, t2, t3, t4, t5)
@@ -278,6 +314,12 @@ func Eitherize6[F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), T0,
 	return G.Eitherize6[ReaderIOEither[R]](f)
 }
 
+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // SequenceT6 converts 6 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple6].
 func SequenceT6[T1, T2, T3, T4, T5, T6 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6]) ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]] {
 	return G.SequenceT6[ReaderIOEither[T.Tuple6[T1, T2, T3, T4, T5, T6]]](t1, t2, t3, t4, t5, t6)
@@ -329,6 +371,12 @@ func Eitherize7[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error),
 	return G.Eitherize7[ReaderIOEither[R]](f)
 }
 
+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // SequenceT7 converts 7 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple7].
 func SequenceT7[T1, T2, T3, T4, T5, T6, T7 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7]) ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]] {
 	return G.SequenceT7[ReaderIOEither[T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]](t1, t2, t3, t4, t5, t6, t7)
@@ -380,6 +428,12 @@ func Eitherize8[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, err
 	return G.Eitherize8[ReaderIOEither[R]](f)
 }
 
+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // SequenceT8 converts 8 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple8].
 func SequenceT8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8]) ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] {
 	return G.SequenceT8[ReaderIOEither[T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]](t1, t2, t3, t4, t5, t6, t7, t8)
@@ -431,6 +485,12 @@ func Eitherize9[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R,
 	return G.Eitherize9[ReaderIOEither[R]](f)
 }
 
+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // SequenceT9 converts 9 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple9].
 func SequenceT9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9]) ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] {
 	return G.SequenceT9[ReaderIOEither[T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]](t1, t2, t3, t4, t5, t6, t7, t8, t9)
@@ -482,6 +542,12 @@ func Eitherize10[F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
 	return G.Eitherize10[ReaderIOEither[R]](f)
 }
 
+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[R], func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}
+
 // SequenceT10 converts 10 [ReaderIOEither] into a [ReaderIOEither] of a [T.Tuple10].
 func SequenceT10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 ReaderIOEither[T1], t2 ReaderIOEither[T2], t3 ReaderIOEither[T3], t4 ReaderIOEither[T4], t5 ReaderIOEither[T5], t6 ReaderIOEither[T6], t7 ReaderIOEither[T7], t8 ReaderIOEither[T8], t9 ReaderIOEither[T9], t10 ReaderIOEither[T10]) ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] {
 	return G.SequenceT10[ReaderIOEither[T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]](t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)

context/readerioeither/generic/gen.go

@@ -2,7 +2,7 @@ package generic
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:18:46.1217523 +0100 CET m=+0.022262001
+// 2024-05-24 22:24:01.4250895 +0200 CEST m=+0.014515801
 
 import (
 	"context"
@@ -19,12 +19,28 @@ func Eitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, er
 	return RE.Eitherize0[GRA](f)
 }
 
+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize0[GRA ~func(context.Context) GIOA, F ~func(context.Context) (R, error), GIOA ~func() E.Either[error, R], R any](f func() GRA) F {
+	return func(c context.Context) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The inverse function is [Uneitherize1]
 func Eitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f F) func(T0) GRA {
 	return RE.Eitherize1[GRA](f)
 }
 
+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize1[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0) (R, error), GIOA ~func() E.Either[error, R], T0, R any](f func(T0) GRA) F {
+	return func(c context.Context, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // SequenceT1 converts 1 readers into a reader of a [T.Tuple1].
 func SequenceT1[
 	GR_TUPLE1 ~func(context.Context) GIO_TUPLE1,
@@ -169,6 +185,14 @@ func Eitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize2[GRA](f)
 }
 
+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize2[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, R any](f func(T0, T1) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // SequenceT2 converts 2 readers into a reader of a [T.Tuple2].
 func SequenceT2[
 	GR_TUPLE2 ~func(context.Context) GIO_TUPLE2,
@@ -364,6 +388,14 @@ func Eitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize3[GRA](f)
 }
 
+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize3[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, R any](f func(T0, T1, T2) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // SequenceT3 converts 3 readers into a reader of a [T.Tuple3].
 func SequenceT3[
 	GR_TUPLE3 ~func(context.Context) GIO_TUPLE3,
@@ -610,6 +642,14 @@ func Eitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize4[GRA](f)
 }
 
+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize4[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // SequenceT4 converts 4 readers into a reader of a [T.Tuple4].
 func SequenceT4[
 	GR_TUPLE4 ~func(context.Context) GIO_TUPLE4,
@@ -907,6 +947,14 @@ func Eitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize5[GRA](f)
 }
 
+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize5[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // SequenceT5 converts 5 readers into a reader of a [T.Tuple5].
 func SequenceT5[
 	GR_TUPLE5 ~func(context.Context) GIO_TUPLE5,
@@ -1255,6 +1303,14 @@ func Eitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize6[GRA](f)
 }
 
+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize6[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // SequenceT6 converts 6 readers into a reader of a [T.Tuple6].
 func SequenceT6[
 	GR_TUPLE6 ~func(context.Context) GIO_TUPLE6,
@@ -1654,6 +1710,14 @@ func Eitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize7[GRA](f)
 }
 
+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize7[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // SequenceT7 converts 7 readers into a reader of a [T.Tuple7].
 func SequenceT7[
 	GR_TUPLE7 ~func(context.Context) GIO_TUPLE7,
@@ -2104,6 +2168,14 @@ func Eitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize8[GRA](f)
 }
 
+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize8[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // SequenceT8 converts 8 readers into a reader of a [T.Tuple8].
 func SequenceT8[
 	GR_TUPLE8 ~func(context.Context) GIO_TUPLE8,
@@ -2605,6 +2677,14 @@ func Eitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1
 	return RE.Eitherize9[GRA](f)
 }
 
+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize9[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // SequenceT9 converts 9 readers into a reader of a [T.Tuple9].
 func SequenceT9[
 	GR_TUPLE9 ~func(context.Context) GIO_TUPLE9,
@@ -3157,6 +3237,14 @@ func Eitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T
 	return RE.Eitherize10[GRA](f)
 }
 
+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the [context.Context].
+func Uneitherize10[GRA ~func(context.Context) GIOA, F ~func(context.Context, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c context.Context, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}
+
 // SequenceT10 converts 10 readers into a reader of a [T.Tuple10].
 func SequenceT10[
 	GR_TUPLE10 ~func(context.Context) GIO_TUPLE10,

context/readerioeither/reader.go

@@ -25,6 +25,7 @@ import (
 	IOE "github.com/IBM/fp-go/ioeither"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
+	RIO "github.com/IBM/fp-go/readerio"
 )
 
 func FromEither[A any](e ET.Either[error, A]) ReaderIOEither[A] {
@@ -192,8 +193,7 @@ func Memoize[A any](rdr ReaderIOEither[A]) ReaderIOEither[A] {
 }
 
 // Flatten converts a nested [ReaderIOEither] into a [ReaderIOEither]
-func Flatten[
-	A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
+func Flatten[A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
 	return G.Flatten[ReaderIOEither[ReaderIOEither[A]]](rdr)
 }
 
@@ -204,3 +204,15 @@ func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
 func Flap[B, A any](a A) func(ReaderIOEither[func(A) B]) ReaderIOEither[B] {
 	return G.Flap[ReaderIOEither[func(A) B], ReaderIOEither[B]](a)
 }
+
+func Fold[A, B any](onLeft func(error) ReaderIOEither[B], onRight func(A) ReaderIOEither[B]) func(ReaderIOEither[A]) ReaderIOEither[B] {
+	return G.Fold[ReaderIOEither[B], ReaderIOEither[A]](onLeft, onRight)
+}
+
+func GetOrElse[A any](onLeft func(error) RIO.ReaderIO[context.Context, A]) func(ReaderIOEither[A]) RIO.ReaderIO[context.Context, A] {
+	return G.GetOrElse[RIO.ReaderIO[context.Context, A], ReaderIOEither[A]](onLeft)
+}
+
+func OrLeft[A any](onLeft func(error) RIO.ReaderIO[context.Context, error]) func(ReaderIOEither[A]) ReaderIOEither[A] {
+	return G.OrLeft[ReaderIOEither[A]](onLeft)
+}

coverage.bat

@@ -1,2 +1,3 @@
 @echo off
-go tool cover -html=build/cover.out -o build/cover.html
+go tool cover -html=build/cover.out -o build/cover.html
+cov-report -ex ".*/cli/.*.go|.*/gen.go|.*/binds.go" build\cover.out

either/array_test.go

@@ -1,8 +1,10 @@
 package either
 
 import (
+	"fmt"
 	"testing"
 
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -16,3 +18,33 @@ func TestCompactArray(t *testing.T) {
 	res := CompactArray(ar)
 	assert.Equal(t, 2, len(res))
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[error, bool](),
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[error, bool](),
+		Left[string, error],
+		Left[bool, error],
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}

either/core.go

@@ -31,7 +31,7 @@ type (
 
 // String prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func eitherString(s *either) string {
 	if s.isLeft {
 		return fmt.Sprintf("Left[%T](%v)", s.value, s.value)
@@ -41,7 +41,7 @@ func eitherString(s *either) string {
 
 // Format prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func eitherFormat(e *either, f fmt.State, c rune) {
 	switch c {
 	case 's':

either/either.go

@@ -33,7 +33,7 @@ func Of[E, A any](value A) Either[E, A] {
 	return F.Pipe1(value, Right[E, A])
 }
 
-func FromIO[E, IO ~func() A, A any](f IO) Either[E, A] {
+func FromIO[E any, IO ~func() A, A any](f IO) Either[E, A] {
 	return F.Pipe1(f(), Right[E, A])
 }
 

either/either_test.go

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

either/functor.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type eitherFunctor[E, A, B any] struct{}
+
+func (o *eitherFunctor[E, A, B]) Map(f func(A) B) func(Either[E, A]) Either[E, B] {
+	return Map[E, A, B](f)
+}
+
+// Functor implements the functoric operations for [Either]
+func Functor[E, A, B any]() functor.Functor[A, B, Either[E, A], Either[E, B]] {
+	return &eitherFunctor[E, A, B]{}
+}

either/pointed.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package either
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type eitherPointed[E, A any] struct{}
+
+func (o *eitherPointed[E, A]) Of(a A) Either[E, A] {
+	return Of[E, A](a)
+}
+
+// Pointed implements the pointedic operations for [Either]
+func Pointed[E, A any]() pointed.Pointed[A, Either[E, A]] {
+	return &eitherPointed[E, A]{}
+}

go.mod

@@ -3,15 +3,15 @@ module github.com/IBM/fp-go
 go 1.20
 
 require (
-	github.com/stretchr/testify v1.9.0
-	github.com/urfave/cli/v2 v2.27.1
+	github.com/stretchr/testify v1.11.1
+	github.com/urfave/cli/v2 v2.27.7
 )
 
 require (
-	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e // indirect
+	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,19 +1,33 @@
-github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
-github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc=
+github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo=
+github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/urfave/cli/v2 v2.27.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho=
-github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e h1:+SOyEddqYF09QP7vr7CgJ1eti3pY9Fn3LHO1M1r/0sI=
-github.com/xrash/smetrics v0.0.0-20231213231151-1d8dd44e695e/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.0 h1:ib4sjIrwZKxE5u/Japgo/7SJV3PvgjGiRNAvTVGqQl8=
+github.com/stretchr/testify v1.11.0/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/urfave/cli/v2 v2.27.4 h1:o1owoI+02Eb+K107p27wEX9Bb8eqIoZCfLXloLUSWJ8=
+github.com/urfave/cli/v2 v2.27.4/go.mod h1:m4QzxcD2qpra4z7WhzEGn74WZLViBnMpb1ToCAKdGRQ=
+github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w=
+github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/urfave/cli/v2 v2.27.6 h1:VdRdS98FNhKZ8/Az8B7MTyGQmpIr36O1EHybx/LaZ4g=
+github.com/urfave/cli/v2 v2.27.6/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ=
+github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU=
+github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
+github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
 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=

internal/array/array.go

@@ -17,6 +17,37 @@ package array
 
 func Slice[GA ~[]A, A any](low, high int) func(as GA) GA {
 	return func(as GA) GA {
+		length := len(as)
+
+		// Handle negative indices - count backward from the end
+		if low < 0 {
+			low = length + low
+			if low < 0 {
+				low = 0
+			}
+		}
+		if high < 0 {
+			high = length + high
+			if high < 0 {
+				high = 0
+			}
+		}
+
+		// Start index > array length: return empty array
+		if low > length {
+			return Empty[GA, A]()
+		}
+
+		// End index > array length: slice to the end
+		if high > length {
+			high = length
+		}
+
+		// Start >= end: return empty array
+		if low >= high {
+			return Empty[GA, A]()
+		}
+
 		return as[low:high]
 	}
 }

internal/bracket/bracket.go

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package file
+package bracket
 
 import (
 	F "github.com/IBM/fp-go/function"

internal/testing/sequence.go

@@ -0,0 +1,183 @@
+// Copyright (c) 2023 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 testing
+
+import (
+	"fmt"
+	"testing"
+
+	EQ "github.com/IBM/fp-go/eq"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/pointed"
+	"github.com/stretchr/testify/assert"
+)
+
+// SequenceArrayTest tests if the sequence operation works in case the operation cannot error
+func SequenceArrayTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[[]A]
+](
+	eq EQ.Eq[HKTB],
+
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[[]string, bool, HKTAA, HKTB],
+	seq func([]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		exp := make([]string, count)
+		good := make([]HKTA, count)
+		for i := 0; i < count; i++ {
+			val := fmt.Sprintf("TestData %d", i)
+			exp[i] = val
+			good[i] = pa.Of(val)
+		}
+
+		return func(t *testing.T) {
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act []string) bool {
+					return assert.Equal(t, exp, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+		}
+	}
+}
+
+// SequenceArrayErrorTest tests if the sequence operation works in case the operation can error
+func SequenceArrayErrorTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[[]A]
+](
+	eq EQ.Eq[HKTB],
+
+	left func(error) HKTA,
+	leftB func(error) HKTB,
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[[]string, bool, HKTAA, HKTB],
+	seq func([]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		expGood := make([]string, count)
+		good := make([]HKTA, count)
+		expBad := make([]error, count)
+		bad := make([]HKTA, count)
+
+		for i := 0; i < count; i++ {
+			goodVal := fmt.Sprintf("TestData %d", i)
+			badVal := fmt.Errorf("ErrorData %d", i)
+			expGood[i] = goodVal
+			good[i] = pa.Of(goodVal)
+			expBad[i] = badVal
+			bad[i] = left(badVal)
+		}
+
+		total := 1 << count
+
+		return func(t *testing.T) {
+			// test the good case
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act []string) bool {
+					return assert.Equal(t, expGood, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+			// iterate and test the bad cases
+			for i := 1; i < total; i++ {
+				// run the test
+				t.Run(fmt.Sprintf("Bitmask test %d", i), func(t1 *testing.T) {
+					// the actual
+					act := make([]HKTA, count)
+					// the expected error
+					var exp error
+					// prepare the values bases on the bit mask
+					mask := 1
+					for j := 0; j < count; j++ {
+						if (i & mask) == 0 {
+							act[j] = good[j]
+						} else {
+							act[j] = bad[j]
+							if exp == nil {
+								exp = expBad[j]
+							}
+						}
+						mask <<= 1
+					}
+					// test the good case
+					res := F.Pipe2(
+						act,
+						seq,
+						faa.Map(func(act []string) bool {
+							return assert.Equal(t, expGood, act)
+						}),
+					)
+					// validate the error
+					assert.True(t, eq.Equals(res, leftB(exp)))
+				})
+			}
+		}
+	}
+}
+
+// SequenceRecordTest tests if the sequence operation works in case the operation cannot error
+func SequenceRecordTest[
+	HKTA,
+	HKTB,
+	HKTAA any, // HKT[map[string]string]
+](
+	eq EQ.Eq[HKTB],
+
+	pa pointed.Pointed[string, HKTA],
+	pb pointed.Pointed[bool, HKTB],
+	faa functor.Functor[map[string]string, bool, HKTAA, HKTB],
+	seq func(map[string]HKTA) HKTAA,
+) func(count int) func(t *testing.T) {
+
+	return func(count int) func(t *testing.T) {
+
+		exp := make(map[string]string)
+		good := make(map[string]HKTA)
+		for i := 0; i < count; i++ {
+			key := fmt.Sprintf("KeyData %d", i)
+			val := fmt.Sprintf("ValueData %d", i)
+			exp[key] = val
+			good[key] = pa.Of(val)
+		}
+
+		return func(t *testing.T) {
+			res := F.Pipe2(
+				good,
+				seq,
+				faa.Map(func(act map[string]string) bool {
+					return assert.Equal(t, exp, act)
+				}),
+			)
+			assert.True(t, eq.Equals(res, pb.Of(true)))
+		}
+	}
+}

io/eq.go

@@ -24,3 +24,8 @@ import (
 func Eq[A any](e EQ.Eq[A]) EQ.Eq[IO[A]] {
 	return G.Eq[IO[A]](e)
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[A comparable]() EQ.Eq[IO[A]] {
+	return G.FromStrictEquals[IO[A]]()
+}

io/functor.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Functor returns the monadic operations for [IO]
+func Functor[A, B any]() functor.Functor[A, B, IO[A], IO[B]] {
+	return G.Functor[A, B, IO[A], IO[B]]()
+}

io/generic/eq.go

@@ -33,3 +33,8 @@ func Eq[GA ~func() A, A any](e EQ.Eq[A]) EQ.Eq[GA] {
 		return eq(l, r)()
 	})
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[GA ~func() A, A comparable]() EQ.Eq[GA] {
+	return Eq[GA](EQ.FromStrictEquals[A]())
+}

io/generic/functor.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 generic
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type ioFunctor[A, B any, GA ~func() A, GB ~func() B] struct{}
+
+func (o *ioFunctor[A, B, GA, GB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+// Functor implements the functoric operations for [IO]
+func Functor[A, B any, GA ~func() A, GB ~func() B]() functor.Functor[A, B, GA, GB] {
+	return &ioFunctor[A, B, GA, GB]{}
+}

io/generic/pointed.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 generic
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type ioPointed[A any, GA ~func() A] struct{}
+
+func (o *ioPointed[A, GA]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+// Pointed implements the pointedic operations for [IO]
+func Pointed[A any, GA ~func() A]() pointed.Pointed[A, GA] {
+	return &ioPointed[A, GA]{}
+}

io/pointed.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2024 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 io
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/io/generic"
+)
+
+// Pointed returns the monadic operations for [IO]
+func Pointed[A any]() pointed.Pointed[A, IO[A]] {
+	return G.Pointed[A, IO[A]]()
+}

io/sequence_test.go

@@ -16,8 +16,11 @@
 package io
 
 import (
+	"fmt"
+
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 
 	"testing"
@@ -45,3 +48,18 @@ func TestMapSeq(t *testing.T) {
 
 	assert.True(t, res())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}

ioeither/generic/monad.go

@@ -17,6 +17,7 @@ package generic
 
 import (
 	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/functor"
 	"github.com/IBM/fp-go/internal/monad"
 	"github.com/IBM/fp-go/internal/pointed"
 )
@@ -25,6 +26,8 @@ type ioEitherPointed[E, A any, GA ~func() ET.Either[E, A]] struct{}
 
 type ioEitherMonad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]] struct{}
 
+type ioEitherFunctor[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B]] struct{}
+
 func (o *ioEitherPointed[E, A, GA]) Of(a A) GA {
 	return Of[GA, E, A](a)
 }
@@ -45,11 +48,20 @@ func (o *ioEitherMonad[E, A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
 	return Ap[GB, GAB, GA, E, A, B](fa)
 }
 
+func (o *ioEitherFunctor[E, A, B, GA, GB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, E, A, B](f)
+}
+
 // Pointed implements the pointed operations for [IOEither]
 func Pointed[E, A any, GA ~func() ET.Either[E, A]]() pointed.Pointed[A, GA] {
 	return &ioEitherPointed[E, A, GA]{}
 }
 
+// Functor implements the monadic operations for [IOEither]
+func Functor[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B]]() functor.Functor[A, B, GA, GB] {
+	return &ioEitherFunctor[E, A, B, GA, GB]{}
+}
+
 // Monad implements the monadic operations for [IOEither]
 func Monad[E, A, B any, GA ~func() ET.Either[E, A], GB ~func() ET.Either[E, B], GAB ~func() ET.Either[E, func(A) B]]() monad.Monad[A, B, GA, GB, GAB] {
 	return &ioEitherMonad[E, A, B, GA, GB, GAB]{}

ioeither/monad.go

@@ -16,6 +16,7 @@
 package ioeither
 
 import (
+	"github.com/IBM/fp-go/internal/functor"
 	"github.com/IBM/fp-go/internal/monad"
 	"github.com/IBM/fp-go/internal/pointed"
 	G "github.com/IBM/fp-go/ioeither/generic"
@@ -26,6 +27,11 @@ func Pointed[E, A any]() pointed.Pointed[A, IOEither[E, A]] {
 	return G.Pointed[E, A, IOEither[E, A]]()
 }
 
+// Functor returns the functor operations for [IOEither]
+func Functor[E, A, B any]() functor.Functor[A, B, IOEither[E, A], IOEither[E, B]] {
+	return G.Functor[E, A, B, IOEither[E, A], IOEither[E, B]]()
+}
+
 // Monad returns the monadic operations for [IOEither]
 func Monad[E, A, B any]() monad.Monad[A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]] {
 	return G.Monad[E, A, B, IOEither[E, A], IOEither[E, B], IOEither[E, func(A) B]]()

ioeither/sequence_test.go

@@ -16,11 +16,15 @@
 package ioeither
 
 import (
+	"fmt"
+
 	A "github.com/IBM/fp-go/array"
 	E "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
 	"github.com/stretchr/testify/assert"
 
+	TST "github.com/IBM/fp-go/internal/testing"
+
 	"testing"
 )
 
@@ -46,3 +50,33 @@ func TestMapSeq(t *testing.T) {
 
 	assert.Equal(t, E.Of[error](true), res())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[error, bool](),
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[error, bool](),
+		Left[string, error],
+		Left[bool, error],
+		Pointed[error, string](),
+		Pointed[error, bool](),
+		Functor[error, []string, bool](),
+		SequenceArray[error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}

iterator/stateless/cycle.go

@@ -19,8 +19,7 @@ import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 )
 
-// DropWhile creates an [Iterator] that drops elements from the [Iterator] as long as the predicate is true; afterwards, returns every element.
-// Note, the [Iterator] does not produce any output until the predicate first becomes false
+// Cycle creates an [Iterator] containing an [Iterator] repeated an infinite number of times.
 func Cycle[U any](ma Iterator[U]) Iterator[U] {
 	return G.Cycle[Iterator[U]](ma)
 }

option/array_test.go

@@ -16,25 +16,13 @@
 package option
 
 import (
+	"fmt"
 	"testing"
 
-	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSequenceArray(t *testing.T) {
-
-	one := Of(1)
-	two := Of(2)
-
-	res := F.Pipe1(
-		[]Option[int]{one, two},
-		SequenceArray[int],
-	)
-
-	assert.Equal(t, res, Of([]int{1, 2}))
-}
-
 func TestCompactArray(t *testing.T) {
 	ar := []Option[string]{
 		Of("ok"),
@@ -45,3 +33,18 @@ func TestCompactArray(t *testing.T) {
 	res := CompactArray(ar)
 	assert.Equal(t, 2, len(res))
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[[]string, bool](),
+		SequenceArray[string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}

option/core.go

@@ -35,7 +35,7 @@ type Option[A any] struct {
 
 // optString prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func optString(isSome bool, value any) string {
 	if isSome {
 		return fmt.Sprintf("Some[%T](%v)", value, value)
@@ -45,7 +45,7 @@ func optString(isSome bool, value any) string {
 
 // optFormat prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func optFormat(isSome bool, value any, f fmt.State, c rune) {
 	switch c {
 	case 's':
@@ -78,7 +78,7 @@ func (s Option[A]) MarshalJSON() ([]byte, error) {
 
 // optUnmarshalJSON unmarshals the [Option] from a JSON string
 //
-// go:noinline
+//go:noinline
 func optUnmarshalJSON(isSome *bool, value any, data []byte) error {
 	// decode the value
 	if bytes.Equal(data, jsonNull) {

option/functor.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 option
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+)
+
+type optionFunctor[A, B any] struct{}
+
+func (o *optionFunctor[A, B]) Map(f func(A) B) func(Option[A]) Option[B] {
+	return Map[A, B](f)
+}
+
+// Functor implements the functoric operations for [Option]
+func Functor[A, B any]() functor.Functor[A, B, Option[A], Option[B]] {
+	return &optionFunctor[A, B]{}
+}

option/pointed.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 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 option
+
+import (
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type optionPointed[A any] struct{}
+
+func (o *optionPointed[A]) Of(a A) Option[A] {
+	return Of[A](a)
+}
+
+// Pointed implements the Pointed operations for [Option]
+func Pointed[A any]() pointed.Pointed[A, Option[A]] {
+	return &optionPointed[A]{}
+}

option/record_test.go

@@ -16,21 +16,13 @@
 package option
 
 import (
+	"fmt"
 	"testing"
 
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSequenceRecord(t *testing.T) {
-	assert.Equal(t, Of(map[string]string{
-		"a": "A",
-		"b": "B",
-	}), SequenceRecord(map[string]Option[string]{
-		"a": Of("A"),
-		"b": Of("B"),
-	}))
-}
-
 func TestCompactRecord(t *testing.T) {
 	// make the map
 	m := make(map[string]Option[int])
@@ -45,3 +37,18 @@ func TestCompactRecord(t *testing.T) {
 
 	assert.Equal(t, exp, m1)
 }
+
+func TestSequenceRecord(t *testing.T) {
+
+	s := TST.SequenceRecordTest(
+		FromStrictEquals[bool](),
+		Pointed[string](),
+		Pointed[bool](),
+		Functor[map[string]string, bool](),
+		SequenceRecord[string, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceRecord %d", i), s(i))
+	}
+}

ord/ord.go

@@ -64,7 +64,7 @@ func Reverse[T any](o Ord[T]) Ord[T] {
 	}, o.Equals)
 }
 
-// Contramap creates an odering under a transformation function
+// Contramap creates an ordering under a transformation function
 func Contramap[A, B any](f func(B) A) func(Ord[A]) Ord[B] {
 	return func(o Ord[A]) Ord[B] {
 		return MakeOrd(func(x, y B) int {

pair/pair.go

@@ -34,14 +34,14 @@ type (
 
 // String prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func pairString(s *pair) string {
-	return fmt.Sprintf("Pair[%T, %t](%v, %v)", s.h, s.t, s.h, s.t)
+	return fmt.Sprintf("Pair[%T, %T](%v, %v)", s.h, s.t, s.h, s.t)
 }
 
 // Format prints some debug info for the object
 //
-// go:noinline
+//go:noinline
 func pairFormat(e *pair, f fmt.State, c rune) {
 	switch c {
 	case 's':

readerioeither/array_test.go

@@ -17,11 +17,13 @@ package readerioeither
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	A "github.com/IBM/fp-go/array"
 	ET "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
+	TST "github.com/IBM/fp-go/internal/testing"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -37,3 +39,33 @@ func TestTraverseArray(t *testing.T) {
 	assert.Equal(t, ET.Right[string]([]string{"aa", "bb"}), F.Pipe1([]string{"a", "b"}, f)(ctx)())
 	assert.Equal(t, ET.Left[[]string]("e"), F.Pipe1([]string{"a", ""}, f)(ctx)())
 }
+
+func TestSequenceArray(t *testing.T) {
+
+	s := TST.SequenceArrayTest(
+		FromStrictEquals[context.Context, error, bool]()(context.Background()),
+		Pointed[context.Context, error, string](),
+		Pointed[context.Context, error, bool](),
+		Functor[context.Context, error, []string, bool](),
+		SequenceArray[context.Context, error, string],
+	)
+
+	for i := 0; i < 10; i++ {
+		t.Run(fmt.Sprintf("TestSequenceArray %d", i), s(i))
+	}
+}
+
+func TestSequenceArrayError(t *testing.T) {
+
+	s := TST.SequenceArrayErrorTest(
+		FromStrictEquals[context.Context, error, bool]()(context.Background()),
+		Left[context.Context, string, error],
+		Left[context.Context, bool, error],
+		Pointed[context.Context, error, string](),
+		Pointed[context.Context, error, bool](),
+		Functor[context.Context, error, []string, bool](),
+		SequenceArray[context.Context, error, string],
+	)
+	// run across four bits
+	s(4)(t)
+}

readerioeither/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:19:28.6907128 +0100 CET m=+0.032796101
+// 2024-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301
 
 package readerioeither
 
@@ -20,6 +20,12 @@ func Eitherize0[F ~func(C) (R, error), C, R any](f F) func() ReaderIOEither[C, e
 	return G.Eitherize0[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize0 converts a function with 1 parameters returning a [ReaderIOEither[C, error, R]] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[F ~func() ReaderIOEither[C, error, R], C, R any](f F) func(C) (R, error) {
+	return G.Uneitherize0[ReaderIOEither[C, error, R], func(C) (R, error)](f)
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From1[F ~func(C, T0) func() (R, error), T0, C, R any](f F) func(T0) ReaderIOEither[C, error, R] {
@@ -32,6 +38,12 @@ func Eitherize1[F ~func(C, T0) (R, error), T0, C, R any](f F) func(T0) ReaderIOE
 	return G.Eitherize1[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize1 converts a function with 2 parameters returning a [ReaderIOEither[C, error, R]] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[F ~func(T0) ReaderIOEither[C, error, R], T0, C, R any](f F) func(C, T0) (R, error) {
+	return G.Uneitherize1[ReaderIOEither[C, error, R], func(C, T0) (R, error)](f)
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From2[F ~func(C, T0, T1) func() (R, error), T0, T1, C, R any](f F) func(T0, T1) ReaderIOEither[C, error, R] {
@@ -44,6 +56,12 @@ func Eitherize2[F ~func(C, T0, T1) (R, error), T0, T1, C, R any](f F) func(T0, T
 	return G.Eitherize2[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize2 converts a function with 3 parameters returning a [ReaderIOEither[C, error, R]] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[F ~func(T0, T1) ReaderIOEither[C, error, R], T0, T1, C, R any](f F) func(C, T0, T1) (R, error) {
+	return G.Uneitherize2[ReaderIOEither[C, error, R], func(C, T0, T1) (R, error)](f)
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From3[F ~func(C, T0, T1, T2) func() (R, error), T0, T1, T2, C, R any](f F) func(T0, T1, T2) ReaderIOEither[C, error, R] {
@@ -56,6 +74,12 @@ func Eitherize3[F ~func(C, T0, T1, T2) (R, error), T0, T1, T2, C, R any](f F) fu
 	return G.Eitherize3[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize3 converts a function with 4 parameters returning a [ReaderIOEither[C, error, R]] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[F ~func(T0, T1, T2) ReaderIOEither[C, error, R], T0, T1, T2, C, R any](f F) func(C, T0, T1, T2) (R, error) {
+	return G.Uneitherize3[ReaderIOEither[C, error, R], func(C, T0, T1, T2) (R, error)](f)
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From4[F ~func(C, T0, T1, T2, T3) func() (R, error), T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) ReaderIOEither[C, error, R] {
@@ -68,6 +92,12 @@ func Eitherize4[F ~func(C, T0, T1, T2, T3) (R, error), T0, T1, T2, T3, C, R any]
 	return G.Eitherize4[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize4 converts a function with 5 parameters returning a [ReaderIOEither[C, error, R]] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[F ~func(T0, T1, T2, T3) ReaderIOEither[C, error, R], T0, T1, T2, T3, C, R any](f F) func(C, T0, T1, T2, T3) (R, error) {
+	return G.Uneitherize4[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3) (R, error)](f)
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From5[F ~func(C, T0, T1, T2, T3, T4) func() (R, error), T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R] {
@@ -80,6 +110,12 @@ func Eitherize5[F ~func(C, T0, T1, T2, T3, T4) (R, error), T0, T1, T2, T3, T4, C
 	return G.Eitherize5[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize5 converts a function with 6 parameters returning a [ReaderIOEither[C, error, R]] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[F ~func(T0, T1, T2, T3, T4) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, C, R any](f F) func(C, T0, T1, T2, T3, T4) (R, error) {
+	return G.Uneitherize5[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4) (R, error)](f)
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From6[F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R] {
@@ -92,6 +128,12 @@ func Eitherize6[F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), T0, T1, T2, T3, T
 	return G.Eitherize6[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize6 converts a function with 7 parameters returning a [ReaderIOEither[C, error, R]] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[F ~func(T0, T1, T2, T3, T4, T5) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5) (R, error) {
+	return G.Uneitherize6[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5) (R, error)](f)
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R] {
@@ -104,6 +146,12 @@ func Eitherize7[F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), T0, T1, T2, T
 	return G.Eitherize7[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize7 converts a function with 8 parameters returning a [ReaderIOEither[C, error, R]] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[F ~func(T0, T1, T2, T3, T4, T5, T6) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6) (R, error) {
+	return G.Uneitherize7[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6) (R, error)](f)
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R] {
@@ -116,6 +164,12 @@ func Eitherize8[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), T0, T1, T
 	return G.Eitherize8[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize8 converts a function with 9 parameters returning a [ReaderIOEither[C, error, R]] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[F ~func(T0, T1, T2, T3, T4, T5, T6, T7) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error) {
+	return G.Uneitherize8[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error)](f)
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R] {
@@ -128,6 +182,12 @@ func Eitherize9[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T0, T
 	return G.Eitherize9[ReaderIOEither[C, error, R]](f)
 }
 
+// Uneitherize9 converts a function with 10 parameters returning a [ReaderIOEither[C, error, R]] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+	return G.Uneitherize9[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error)](f)
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [ReaderIOEither[R]]
 // The first parameter is considered to be the context [C].
 func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
@@ -139,3 +199,9 @@ func From10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error)
 func Eitherize10[F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R] {
 	return G.Eitherize10[ReaderIOEither[C, error, R]](f)
 }
+
+// Uneitherize10 converts a function with 11 parameters returning a [ReaderIOEither[C, error, R]] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[F ~func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) ReaderIOEither[C, error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+	return G.Uneitherize10[ReaderIOEither[C, error, R], func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error)](f)
+}

readerioeither/generic/gen.go

@@ -1,6 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2024-02-29 16:19:28.691247 +0100 CET m=+0.033330301
+// 2024-05-24 17:26:07.2835624 +0200 CEST m=+0.011499301
 package generic
 
 import (
@@ -26,6 +26,14 @@ func Eitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[
 	})
 }
 
+// Uneitherize0 converts a function with 0 parameters returning a [GRA] into a function with 0 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Either[error, R], C, R any](f func() GRA) F {
+	return func(c C) (R, error) {
+		return E.UnwrapError(f()(c)())
+	}
+}
+
 // From1 converts a function with 2 parameters returning a tuple into a function with 1 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From1[GRA ~func(C) GIOA, F ~func(C, T0) func() (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f F) func(T0) GRA {
@@ -44,6 +52,14 @@ func Eitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Eit
 	})
 }
 
+// Uneitherize1 converts a function with 1 parameters returning a [GRA] into a function with 1 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.Either[error, R], T0, C, R any](f func(T0) GRA) F {
+	return func(c C, t0 T0) (R, error) {
+		return E.UnwrapError(f(t0)(c)())
+	}
+}
+
 // From2 converts a function with 3 parameters returning a tuple into a function with 2 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From2[GRA ~func(C) GIOA, F ~func(C, T0, T1) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f F) func(T0, T1) GRA {
@@ -62,6 +78,14 @@ func Eitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E
 	})
 }
 
+// Uneitherize2 converts a function with 2 parameters returning a [GRA] into a function with 2 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func() E.Either[error, R], T0, T1, C, R any](f func(T0, T1) GRA) F {
+	return func(c C, t0 T0, t1 T1) (R, error) {
+		return E.UnwrapError(f(t0, t1)(c)())
+	}
+}
+
 // From3 converts a function with 4 parameters returning a tuple into a function with 3 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f F) func(T0, T1, T2) GRA {
@@ -80,6 +104,14 @@ func Eitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func
 	})
 }
 
+// Uneitherize3 converts a function with 3 parameters returning a [GRA] into a function with 3 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, C, R any](f func(T0, T1, T2) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2)(c)())
+	}
+}
+
 // From4 converts a function with 5 parameters returning a tuple into a function with 4 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f F) func(T0, T1, T2, T3) GRA {
@@ -98,6 +130,14 @@ func Eitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~
 	})
 }
 
+// Uneitherize4 converts a function with 4 parameters returning a [GRA] into a function with 4 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, C, R any](f func(T0, T1, T2, T3) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3)(c)())
+	}
+}
+
 // From5 converts a function with 6 parameters returning a tuple into a function with 5 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f F) func(T0, T1, T2, T3, T4) GRA {
@@ -116,6 +156,14 @@ func Eitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GI
 	})
 }
 
+// Uneitherize5 converts a function with 5 parameters returning a [GRA] into a function with 5 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, C, R any](f func(T0, T1, T2, T3, T4) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4)(c)())
+	}
+}
+
 // From6 converts a function with 7 parameters returning a tuple into a function with 6 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f F) func(T0, T1, T2, T3, T4, T5) GRA {
@@ -134,6 +182,14 @@ func Eitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error)
 	})
 }
 
+// Uneitherize6 converts a function with 6 parameters returning a [GRA] into a function with 6 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, C, R any](f func(T0, T1, T2, T3, T4, T5) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5)(c)())
+	}
+}
+
 // From7 converts a function with 8 parameters returning a tuple into a function with 7 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6) GRA {
@@ -152,6 +208,14 @@ func Eitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, er
 	})
 }
 
+// Uneitherize7 converts a function with 7 parameters returning a [GRA] into a function with 7 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, C, R any](f func(T0, T1, T2, T3, T4, T5, T6) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6)(c)())
+	}
+}
+
 // From8 converts a function with 9 parameters returning a tuple into a function with 8 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7) GRA {
@@ -170,6 +234,14 @@ func Eitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R
 	})
 }
 
+// Uneitherize8 converts a function with 8 parameters returning a [GRA] into a function with 8 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7)(c)())
+	}
+}
+
 // From9 converts a function with 10 parameters returning a tuple into a function with 9 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA {
@@ -188,6 +260,14 @@ func Eitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8
 	})
 }
 
+// Uneitherize9 converts a function with 9 parameters returning a [GRA] into a function with 9 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8)(c)())
+	}
+}
+
 // From10 converts a function with 11 parameters returning a tuple into a function with 10 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) func() (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f F) func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA {
@@ -205,3 +285,11 @@ func Eitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T
 		}
 	})
 }
+
+// Uneitherize10 converts a function with 10 parameters returning a [GRA] into a function with 10 parameters returning a tuple.
+// The first parameter is considered to be the context [C].
+func Uneitherize10[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), GIOA ~func() E.Either[error, R], T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, C, R any](f func(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) GRA) F {
+	return func(c C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
+		return E.UnwrapError(f(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9)(c)())
+	}
+}

readerioeither/generic/monad.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2024 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 generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+)
+
+type readerIOEitherPointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() ET.Either[E, A]] struct{}
+
+type readerIOEitherMonad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIOAB ~func() ET.Either[E, func(A) B]] struct{}
+
+type readerIOEitherFunctor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B]] struct{}
+
+func (o *readerIOEitherPointed[R, E, A, GRA, GIOA]) Of(a A) GRA {
+	return Of[GRA, GIOA, R, E, A](a)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Of(a A) GRA {
+	return Of[GRA, GIOA, R, E, A](a)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Map(f func(A) B) func(GRA) GRB {
+	return Map[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Chain(f func(A) GRB) func(GRA) GRB {
+	return Chain[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+func (o *readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]) Ap(fa GRA) func(GRAB) GRB {
+	return Ap[GRA, GRB, GRAB, GIOA, GIOB, GIOAB, R, E, A, B](fa)
+}
+
+func (o *readerIOEitherFunctor[R, E, A, B, GRA, GRB, GIOA, GIOB]) Map(f func(A) B) func(GRA) GRB {
+	return Map[GRA, GRB, GIOA, GIOB, R, E, A, B](f)
+}
+
+// Pointed implements the pointed operations for [ReaderIOEither]
+func Pointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() ET.Either[E, A]]() pointed.Pointed[A, GRA] {
+	return &readerIOEitherPointed[R, E, A, GRA, GIOA]{}
+}
+
+// Functor implements the monadic operations for [ReaderIOEither]
+func Functor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B]]() functor.Functor[A, B, GRA, GRB] {
+	return &readerIOEitherFunctor[R, E, A, B, GRA, GRB, GIOA, GIOB]{}
+}
+
+// Monad implements the monadic operations for [ReaderIOEither]
+func Monad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIOAB ~func() ET.Either[E, func(A) B]]() monad.Monad[A, B, GRA, GRB, GRAB] {
+	return &readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]{}
+}

readerioeither/monad.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 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 readerioeither
+
+import (
+	"github.com/IBM/fp-go/internal/functor"
+	"github.com/IBM/fp-go/internal/monad"
+	"github.com/IBM/fp-go/internal/pointed"
+	G "github.com/IBM/fp-go/readerioeither/generic"
+)
+
+// Pointed returns the pointed operations for [ReaderIOEither]
+func Pointed[R, E, A any]() pointed.Pointed[A, ReaderIOEither[R, E, A]] {
+	return G.Pointed[R, E, A, ReaderIOEither[R, E, A]]()
+}
+
+// Functor returns the functor operations for [ReaderIOEither]
+func Functor[R, E, A, B any]() functor.Functor[A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]] {
+	return G.Functor[R, E, A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]]()
+}
+
+// Monad returns the monadic operations for [ReaderIOEither]
+func Monad[R, E, A, B any]() monad.Monad[A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B], ReaderIOEither[R, E, func(A) B]] {
+	return G.Monad[R, E, A, B, ReaderIOEither[R, E, A], ReaderIOEither[R, E, B], ReaderIOEither[R, E, func(A) B]]()
+}

record/eq.go

@@ -23,3 +23,8 @@ import (
 func Eq[K comparable, V any](e E.Eq[V]) E.Eq[map[K]V] {
 	return G.Eq[map[K]V, K, V](e)
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[K, V comparable]() E.Eq[map[K]V] {
+	return G.FromStrictEquals[map[K]V]()
+}

record/eq_test.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 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 record
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFromStrictEquals(t *testing.T) {
+	m1 := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	m2 := map[string]string{
+		"a": "A",
+		"b": "C",
+	}
+	m3 := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	m4 := map[string]string{
+		"a": "A",
+		"b": "B",
+		"c": "C",
+	}
+
+	e := FromStrictEquals[string, string]()
+	assert.True(t, e.Equals(m1, m1))
+	assert.True(t, e.Equals(m1, m3))
+	assert.False(t, e.Equals(m1, m2))
+	assert.False(t, e.Equals(m1, m4))
+}

record/generic/eq.go

@@ -37,3 +37,8 @@ func Eq[M ~map[K]V, K comparable, V any](e E.Eq[V]) E.Eq[M] {
 		return equals(left, right, eq)
 	})
 }
+
+// FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
+func FromStrictEquals[M ~map[K]V, K, V comparable]() E.Eq[M] {
+	return Eq[M](E.FromStrictEquals[V]())
+}

record/monoid_test.go

@@ -54,3 +54,69 @@ func TestUnionMonoid(t *testing.T) {
 
 	assert.Equal(t, res, m.Concat(x, y))
 }
+
+func TestUnionFirstMonoid(t *testing.T) {
+	m := UnionFirstMonoid[string, string]()
+
+	e := Empty[string, string]()
+
+	x := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+	}
+
+	y := map[string]string{
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	res := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+		"d": "d2",
+	}
+
+	assert.Equal(t, x, m.Concat(x, m.Empty()))
+	assert.Equal(t, x, m.Concat(m.Empty(), x))
+
+	assert.Equal(t, x, m.Concat(x, e))
+	assert.Equal(t, x, m.Concat(e, x))
+
+	assert.Equal(t, res, m.Concat(x, y))
+}
+
+func TestUnionLastMonoid(t *testing.T) {
+	m := UnionLastMonoid[string, string]()
+
+	e := Empty[string, string]()
+
+	x := map[string]string{
+		"a": "a1",
+		"b": "b1",
+		"c": "c1",
+	}
+
+	y := map[string]string{
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	res := map[string]string{
+		"a": "a1",
+		"b": "b2",
+		"c": "c2",
+		"d": "d2",
+	}
+
+	assert.Equal(t, x, m.Concat(x, m.Empty()))
+	assert.Equal(t, x, m.Concat(m.Empty(), x))
+
+	assert.Equal(t, x, m.Concat(x, e))
+	assert.Equal(t, x, m.Concat(e, x))
+
+	assert.Equal(t, res, m.Concat(x, y))
+}

record/record_test.go

@@ -176,3 +176,25 @@ func TestFromArrayMap(t *testing.T) {
 		"C": "C",
 	}, res2)
 }
+
+func TestEmpty(t *testing.T) {
+	nonEmpty := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	empty := Empty[string, string]()
+
+	assert.True(t, IsEmpty(empty))
+	assert.False(t, IsEmpty(nonEmpty))
+	assert.False(t, IsNonEmpty(empty))
+	assert.True(t, IsNonEmpty(nonEmpty))
+}
+
+func TestHas(t *testing.T) {
+	nonEmpty := map[string]string{
+		"a": "A",
+		"b": "B",
+	}
+	assert.True(t, Has("a", nonEmpty))
+	assert.False(t, Has("c", nonEmpty))
+}

renovate.json

@@ -25,6 +25,15 @@
             ],
             "automerge": true,
             "groupName": "go dependencies"
+        },
+        {
+            "matchPackageNames": [
+                "conventional-changelog-conventionalcommits"
+            ],
+            "matchUpdateTypes": [
+                "major"
+            ],
+            "enabled": false
         }
     ]
 }

v2/README.md

@@ -0,0 +1,43 @@
+# Functional programming library for golang V2
+
+Go 1.24 introduces [generic type aliases](https://github.com/golang/go/issues/46477) which are leveraged by V2.
+
+## ⚠️ Breaking Changes
+
+- use of [generic type aliases](https://github.com/golang/go/issues/46477) which requires [go1.24](https://tip.golang.org/doc/go1.24)
+- order of generic type arguments adjusted such that types that _cannot_ be inferred by the method argument come first, e.g. in the `Ap` methods
+- monadic operations for `Pair` operate on the second argument, to be compatible with the [Haskell](https://hackage.haskell.org/package/TypeCompose-0.9.14/docs/Data-Pair.html) definition
+
+## Simplifications
+
+- use type aliases to get rid of namespace imports for type declarations, e.g. instead of
+
+```go
+import (
+    ET "github.com/IBM/fp-go/v2/either"
+)
+
+func doSth() ET.Either[error, string] {
+    ...
+}
+```
+
+you can declare your type once 
+
+```go
+import (
+    "github.com/IBM/fp-go/v2/either"
+)
+
+type Either[A any] = either.Either[error, A]
+```
+
+and then use it across your codebase
+
+```go
+func doSth() Either[string] {
+    ...
+}
+```
+
+- library implementation does no longer need to use the `generic` subpackage, this simplifies reading and understanding of the code

v2/array/any.go

@@ -0,0 +1,50 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate.
+// The predicate receives both the index and the element.
+// Returns true if at least one element satisfies the predicate, false otherwise.
+//
+// Example:
+//
+//	hasEvenAtEvenIndex := array.AnyWithIndex(func(i, x int) bool {
+//	    return i%2 == 0 && x%2 == 0
+//	})
+//	result := hasEvenAtEvenIndex([]int{1, 3, 4, 5}) // true (4 is at index 2)
+//
+//go:inline
+func AnyWithIndex[A any](pred func(int, A) bool) func([]A) bool {
+	return G.AnyWithIndex[[]A](pred)
+}
+
+// Any tests if any of the elements in the array matches the predicate.
+// Returns true if at least one element satisfies the predicate, false otherwise.
+// Returns false for an empty array.
+//
+// Example:
+//
+//	hasEven := array.Any(func(x int) bool { return x%2 == 0 })
+//	result := hasEven([]int{1, 3, 4, 5}) // true
+//
+//go:inline
+func Any[A any](pred func(A) bool) func([]A) bool {
+	return G.Any[[]A](pred)
+}

v2/array/any_test.go

@@ -0,0 +1,30 @@
+// 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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAny(t *testing.T) {
+	anyBool := Any(F.Identity[bool])
+
+	assert.True(t, anyBool(From(false, true, false)))
+	assert.False(t, anyBool(From(false, false, false)))
+}

v2/array/array.go

@@ -0,0 +1,538 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	EM "github.com/IBM/fp-go/v2/endomorphism"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	M "github.com/IBM/fp-go/v2/monoid"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/tuple"
+)
+
+// From constructs an array from a set of variadic arguments
+//
+//go:inline
+func From[A any](data ...A) []A {
+	return G.From[[]A](data...)
+}
+
+// MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
+//
+//go:inline
+func MakeBy[F ~func(int) A, A any](n int, f F) []A {
+	return G.MakeBy[[]A](n, f)
+}
+
+// Replicate creates a `Array` containing a value repeated the specified number of times.
+//
+//go:inline
+func Replicate[A any](n int, a A) []A {
+	return G.Replicate[[]A](n, a)
+}
+
+// MonadMap applies a function to each element of an array, returning a new array with the results.
+// This is the monadic version of Map that takes the array as the first parameter.
+//
+//go:inline
+func MonadMap[A, B any](as []A, f func(a A) B) []B {
+	return G.MonadMap[[]A, []B](as, f)
+}
+
+// MonadMapRef applies a function to a pointer to each element of an array, returning a new array with the results.
+// This is useful when you need to access elements by reference without copying.
+func MonadMapRef[A, B any](as []A, f func(a *A) B) []B {
+	count := len(as)
+	bs := make([]B, count)
+	for i := count - 1; i >= 0; i-- {
+		bs[i] = f(&as[i])
+	}
+	return bs
+}
+
+// MapWithIndex applies a function to each element and its index in an array, returning a new array with the results.
+//
+//go:inline
+func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
+	return G.MapWithIndex[[]A, []B](f)
+}
+
+// Map applies a function to each element of an array, returning a new array with the results.
+// This is the curried version that returns a function.
+//
+// Example:
+//
+//	double := array.Map(func(x int) int { return x * 2 })
+//	result := double([]int{1, 2, 3}) // [2, 4, 6]
+//
+//go:inline
+func Map[A, B any](f func(a A) B) func([]A) []B {
+	return G.Map[[]A, []B, A, B](f)
+}
+
+// MapRef applies a function to a pointer to each element of an array, returning a new array with the results.
+// This is the curried version that returns a function.
+func MapRef[A, B any](f func(a *A) B) func([]A) []B {
+	return F.Bind2nd(MonadMapRef[A, B], f)
+}
+
+func filterRef[A any](fa []A, pred func(a *A) bool) []A {
+	var result []A
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		a := fa[i]
+		if pred(&a) {
+			result = append(result, a)
+		}
+	}
+	return result
+}
+
+func filterMapRef[A, B any](fa []A, pred func(a *A) bool, f func(a *A) B) []B {
+	var result []B
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		a := fa[i]
+		if pred(&a) {
+			result = append(result, f(&a))
+		}
+	}
+	return result
+}
+
+// Filter returns a new array with all elements from the original array that match a predicate
+//
+//go:inline
+func Filter[A any](pred func(A) bool) EM.Endomorphism[[]A] {
+	return G.Filter[[]A](pred)
+}
+
+// FilterWithIndex returns a new array with all elements from the original array that match a predicate
+//
+//go:inline
+func FilterWithIndex[A any](pred func(int, A) bool) EM.Endomorphism[[]A] {
+	return G.FilterWithIndex[[]A](pred)
+}
+
+// FilterRef returns a new array with all elements from the original array that match a predicate operating on pointers.
+func FilterRef[A any](pred func(*A) bool) EM.Endomorphism[[]A] {
+	return F.Bind2nd(filterRef[A], pred)
+}
+
+// MonadFilterMap maps an array with a function that returns an Option and keeps only the Some values.
+// This is the monadic version that takes the array as the first parameter.
+//
+//go:inline
+func MonadFilterMap[A, B any](fa []A, f func(A) O.Option[B]) []B {
+	return G.MonadFilterMap[[]A, []B](fa, f)
+}
+
+// MonadFilterMapWithIndex maps an array with a function that takes an index and returns an Option,
+// keeping only the Some values. This is the monadic version that takes the array as the first parameter.
+//
+//go:inline
+func MonadFilterMapWithIndex[A, B any](fa []A, f func(int, A) O.Option[B]) []B {
+	return G.MonadFilterMapWithIndex[[]A, []B](fa, f)
+}
+
+// FilterMap maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+//
+//go:inline
+func FilterMap[A, B any](f func(A) O.Option[B]) func([]A) []B {
+	return G.FilterMap[[]A, []B](f)
+}
+
+// FilterMapWithIndex maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
+//
+//go:inline
+func FilterMapWithIndex[A, B any](f func(int, A) O.Option[B]) func([]A) []B {
+	return G.FilterMapWithIndex[[]A, []B](f)
+}
+
+// FilterChain maps an array with an iterating function that returns an [O.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 func(A) O.Option[[]B]) func([]A) []B {
+	return G.FilterChain[[]A](f)
+}
+
+// FilterMapRef filters an array using a predicate on pointers and maps the matching elements using a function on pointers.
+func FilterMapRef[A, B any](pred func(a *A) bool, f func(a *A) B) func([]A) []B {
+	return func(fa []A) []B {
+		return filterMapRef(fa, pred, f)
+	}
+}
+
+func reduceRef[A, B any](fa []A, f func(B, *A) B, initial B) B {
+	current := initial
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		current = f(current, &fa[i])
+	}
+	return current
+}
+
+//go:inline
+func MonadReduce[A, B any](fa []A, f func(B, A) B, initial B) B {
+	return G.MonadReduce(fa, f, initial)
+}
+
+// Reduce folds an array from left to right, applying a function to accumulate a result.
+//
+// Example:
+//
+//	sum := array.Reduce(func(acc, x int) int { return acc + x }, 0)
+//	result := sum([]int{1, 2, 3, 4, 5}) // 15
+//
+//go:inline
+func Reduce[A, B any](f func(B, A) B, initial B) func([]A) B {
+	return G.Reduce[[]A](f, initial)
+}
+
+// ReduceWithIndex folds an array from left to right with access to the index,
+// applying a function to accumulate a result.
+//
+//go:inline
+func ReduceWithIndex[A, B any](f func(int, B, A) B, initial B) func([]A) B {
+	return G.ReduceWithIndex[[]A](f, initial)
+}
+
+// ReduceRight folds an array from right to left, applying a function to accumulate a result.
+//
+//go:inline
+func ReduceRight[A, B any](f func(A, B) B, initial B) func([]A) B {
+	return G.ReduceRight[[]A](f, initial)
+}
+
+// ReduceRightWithIndex folds an array from right to left with access to the index,
+// applying a function to accumulate a result.
+//
+//go:inline
+func ReduceRightWithIndex[A, B any](f func(int, A, B) B, initial B) func([]A) B {
+	return G.ReduceRightWithIndex[[]A](f, initial)
+}
+
+// ReduceRef folds an array from left to right using pointers to elements,
+// applying a function to accumulate a result.
+func ReduceRef[A, B any](f func(B, *A) B, initial B) func([]A) B {
+	return func(as []A) B {
+		return reduceRef(as, f, initial)
+	}
+}
+
+// Append adds an element to the end of an array, returning a new array.
+//
+//go:inline
+func Append[A any](as []A, a A) []A {
+	return G.Append(as, a)
+}
+
+// IsEmpty checks if an array has no elements.
+//
+//go:inline
+func IsEmpty[A any](as []A) bool {
+	return G.IsEmpty(as)
+}
+
+// IsNonEmpty checks if an array has at least one element.
+func IsNonEmpty[A any](as []A) bool {
+	return len(as) > 0
+}
+
+// Empty returns an empty array of type A.
+//
+//go:inline
+func Empty[A any]() []A {
+	return G.Empty[[]A]()
+}
+
+// Zero returns an empty array of type A (alias for Empty).
+func Zero[A any]() []A {
+	return Empty[A]()
+}
+
+// Of constructs a single element array
+//
+//go:inline
+func Of[A any](a A) []A {
+	return G.Of[[]A](a)
+}
+
+// MonadChain applies a function that returns an array to each element and flattens the results.
+// This is the monadic version that takes the array as the first parameter (also known as FlatMap).
+//
+//go:inline
+func MonadChain[A, B any](fa []A, f func(a A) []B) []B {
+	return G.MonadChain[[]A, []B](fa, f)
+}
+
+// Chain applies a function that returns an array to each element and flattens the results.
+// This is the curried version (also known as FlatMap).
+//
+// Example:
+//
+//	duplicate := array.Chain(func(x int) []int { return []int{x, x} })
+//	result := duplicate([]int{1, 2, 3}) // [1, 1, 2, 2, 3, 3]
+//
+//go:inline
+func Chain[A, B any](f func(A) []B) func([]A) []B {
+	return G.Chain[[]A, []B](f)
+}
+
+// MonadAp applies an array of functions to an array of values, producing all combinations.
+// This is the monadic version that takes both arrays as parameters.
+//
+//go:inline
+func MonadAp[B, A any](fab []func(A) B, fa []A) []B {
+	return G.MonadAp[[]B](fab, fa)
+}
+
+// Ap applies an array of functions to an array of values, producing all combinations.
+// This is the curried version.
+//
+//go:inline
+func Ap[B, A any](fa []A) func([]func(A) B) []B {
+	return G.Ap[[]B, []func(A) B](fa)
+}
+
+// Match performs pattern matching on an array, calling onEmpty if empty or onNonEmpty if not.
+//
+//go:inline
+func Match[A, B any](onEmpty func() B, onNonEmpty func([]A) B) func([]A) B {
+	return G.Match[[]A](onEmpty, onNonEmpty)
+}
+
+// MatchLeft performs pattern matching on an array, calling onEmpty if empty or onNonEmpty with head and tail if not.
+//
+//go:inline
+func MatchLeft[A, B any](onEmpty func() B, onNonEmpty func(A, []A) B) func([]A) B {
+	return G.MatchLeft[[]A](onEmpty, onNonEmpty)
+}
+
+// Tail returns all elements except the first, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Tail[A any](as []A) O.Option[[]A] {
+	return G.Tail(as)
+}
+
+// Head returns the first element of an array, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Head[A any](as []A) O.Option[A] {
+	return G.Head(as)
+}
+
+// First returns the first element of an array, wrapped in an Option (alias for Head).
+// Returns None if the array is empty.
+//
+//go:inline
+func First[A any](as []A) O.Option[A] {
+	return G.First(as)
+}
+
+// Last returns the last element of an array, wrapped in an Option.
+// Returns None if the array is empty.
+//
+//go:inline
+func Last[A any](as []A) O.Option[A] {
+	return G.Last(as)
+}
+
+// PrependAll inserts a separator before each element of an array.
+func PrependAll[A any](middle A) EM.Endomorphism[[]A] {
+	return func(as []A) []A {
+		count := len(as)
+		dst := count * 2
+		result := make([]A, dst)
+		for i := count - 1; i >= 0; i-- {
+			dst--
+			result[dst] = as[i]
+			dst--
+			result[dst] = middle
+		}
+		return result
+	}
+}
+
+// Intersperse inserts a separator between each element of an array.
+//
+// Example:
+//
+//	result := array.Intersperse(0)([]int{1, 2, 3}) // [1, 0, 2, 0, 3]
+func Intersperse[A any](middle A) EM.Endomorphism[[]A] {
+	prepend := PrependAll(middle)
+	return func(as []A) []A {
+		if IsEmpty(as) {
+			return as
+		}
+		return prepend(as)[1:]
+	}
+}
+
+// Intercalate inserts a separator between elements and concatenates them using a Monoid.
+func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
+	return func(middle A) func([]A) A {
+		return Match(m.Empty, F.Flow2(Intersperse(middle), ConcatAll[A](m)))
+	}
+}
+
+// Flatten converts a nested array into a flat array by concatenating all inner arrays.
+//
+// Example:
+//
+//	result := array.Flatten([][]int{{1, 2}, {3, 4}, {5}}) // [1, 2, 3, 4, 5]
+//
+//go:inline
+func Flatten[A any](mma [][]A) []A {
+	return G.Flatten(mma)
+}
+
+// Slice extracts a subarray from index low (inclusive) to high (exclusive).
+func Slice[A any](low, high int) func(as []A) []A {
+	return array.Slice[[]A](low, high)
+}
+
+// Lookup returns the element at the specified index, wrapped in an Option.
+// Returns None if the index is out of bounds.
+//
+//go:inline
+func Lookup[A any](idx int) func([]A) O.Option[A] {
+	return G.Lookup[[]A](idx)
+}
+
+// UpsertAt returns a function that inserts or updates an element at a specific index.
+// If the index is out of bounds, the element is appended.
+//
+//go:inline
+func UpsertAt[A any](a A) EM.Endomorphism[[]A] {
+	return G.UpsertAt[[]A](a)
+}
+
+// Size returns the number of elements in an array.
+//
+//go:inline
+func Size[A any](as []A) int {
+	return G.Size(as)
+}
+
+// MonadPartition splits an array into two arrays based on a predicate.
+// The first array contains elements for which the predicate returns false,
+// 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] {
+	return G.MonadPartition(as, pred)
+}
+
+// Partition creates two new arrays out of one, the left result contains the elements
+// 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] {
+	return G.Partition[[]A](pred)
+}
+
+// IsNil checks if the array is set to nil
+func IsNil[A any](as []A) bool {
+	return array.IsNil(as)
+}
+
+// IsNonNil checks if the array is set to nil
+func IsNonNil[A any](as []A) bool {
+	return array.IsNonNil(as)
+}
+
+// ConstNil returns a nil array
+func ConstNil[A any]() []A {
+	return array.ConstNil[[]A]()
+}
+
+// SliceRight extracts a subarray from the specified start index to the end.
+//
+//go:inline
+func SliceRight[A any](start int) EM.Endomorphism[[]A] {
+	return G.SliceRight[[]A](start)
+}
+
+// Copy creates a shallow copy of the array
+//
+//go:inline
+func Copy[A any](b []A) []A {
+	return G.Copy(b)
+}
+
+// Clone creates a deep copy of the array using the provided endomorphism to clone the values
+//
+//go:inline
+func Clone[A any](f func(A) A) func(as []A) []A {
+	return G.Clone[[]A](f)
+}
+
+// FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+//
+//go:inline
+func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
+	return G.FoldMap[[]A](m)
+}
+
+// FoldMapWithIndex maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+//
+//go:inline
+func FoldMapWithIndex[A, B any](m M.Monoid[B]) func(func(int, A) B) func([]A) B {
+	return G.FoldMapWithIndex[[]A](m)
+}
+
+// Fold folds the array using the provided Monoid.
+//
+//go:inline
+func Fold[A any](m M.Monoid[A]) func([]A) A {
+	return G.Fold[[]A](m)
+}
+
+// Push adds an element to the end of an array (alias for Append).
+//
+//go:inline
+func Push[A any](a A) EM.Endomorphism[[]A] {
+	return G.Push[EM.Endomorphism[[]A]](a)
+}
+
+// MonadFlap applies a value to an array of functions, producing an array of results.
+// This is the monadic version that takes both parameters.
+//
+//go:inline
+func MonadFlap[B, A any](fab []func(A) B, a A) []B {
+	return G.MonadFlap[func(A) B, []func(A) B, []B, A, B](fab, a)
+}
+
+// Flap applies a value to an array of functions, producing an array of results.
+// This is the curried version.
+//
+//go:inline
+func Flap[B, A any](a A) func([]func(A) B) []B {
+	return G.Flap[func(A) B, []func(A) B, []B, A, B](a)
+}
+
+// Prepend adds an element to the beginning of an array, returning a new array.
+//
+//go:inline
+func Prepend[A any](head A) EM.Endomorphism[[]A] {
+	return G.Prepend[EM.Endomorphism[[]A]](head)
+}

v2/array/array_extended_test.go

@@ -0,0 +1,323 @@
+// 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 array
+
+import (
+	"fmt"
+	"testing"
+
+	N "github.com/IBM/fp-go/v2/number"
+	O "github.com/IBM/fp-go/v2/option"
+	S "github.com/IBM/fp-go/v2/string"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReplicate(t *testing.T) {
+	result := Replicate(3, "a")
+	assert.Equal(t, []string{"a", "a", "a"}, result)
+
+	empty := Replicate(0, 42)
+	assert.Equal(t, []int{}, empty)
+}
+
+func TestMonadMap(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadMap(src, func(x int) int { return x * 2 })
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMonadMapRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadMapRef(src, func(x *int) int { return *x * 2 })
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	mapper := MapWithIndex(func(i int, s string) string {
+		return fmt.Sprintf("%d:%s", i, s)
+	})
+	result := mapper(src)
+	assert.Equal(t, []string{"0:a", "1:b", "2:c"}, result)
+}
+
+func TestMapRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	mapper := MapRef(func(x *int) int { return *x * 2 })
+	result := mapper(src)
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestFilterWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterWithIndex(func(i, x int) bool {
+		return i%2 == 0 && x > 2
+	})
+	result := filter(src)
+	assert.Equal(t, []int{3, 5}, result)
+}
+
+func TestFilterRef(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterRef(func(x *int) bool { return *x > 2 })
+	result := filter(src)
+	assert.Equal(t, []int{3, 4, 5}, result)
+}
+
+func TestMonadFilterMap(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	result := MonadFilterMap(src, func(x int) O.Option[string] {
+		if x%2 == 0 {
+			return O.Some(fmt.Sprintf("even:%d", x))
+		}
+		return O.None[string]()
+	})
+	assert.Equal(t, []string{"even:2", "even:4"}, result)
+}
+
+func TestMonadFilterMapWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	result := MonadFilterMapWithIndex(src, func(i, x int) O.Option[string] {
+		if i%2 == 0 {
+			return O.Some(fmt.Sprintf("%d:%d", i, x))
+		}
+		return O.None[string]()
+	})
+	assert.Equal(t, []string{"0:1", "2:3"}, result)
+}
+
+func TestFilterMapWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4}
+	filter := FilterMapWithIndex(func(i, x int) O.Option[string] {
+		if i%2 == 0 {
+			return O.Some(fmt.Sprintf("%d:%d", i, x))
+		}
+		return O.None[string]()
+	})
+	result := filter(src)
+	assert.Equal(t, []string{"0:1", "2:3"}, result)
+}
+
+func TestFilterMapRef(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	filter := FilterMapRef(
+		func(x *int) bool { return *x > 2 },
+		func(x *int) string { return fmt.Sprintf("val:%d", *x) },
+	)
+	result := filter(src)
+	assert.Equal(t, []string{"val:3", "val:4", "val:5"}, result)
+}
+
+func TestReduceWithIndex(t *testing.T) {
+	src := []int{1, 2, 3}
+	reducer := ReduceWithIndex(func(i, acc, x int) int {
+		return acc + i + x
+	}, 0)
+	result := reducer(src)
+	assert.Equal(t, 9, result) // 0 + (0+1) + (1+2) + (2+3) = 9
+}
+
+func TestReduceRightWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	reducer := ReduceRightWithIndex(func(i int, x, acc string) string {
+		return fmt.Sprintf("%s%d:%s", acc, i, x)
+	}, "")
+	result := reducer(src)
+	assert.Equal(t, "2:c1:b0:a", result)
+}
+
+func TestReduceRef(t *testing.T) {
+	src := []int{1, 2, 3}
+	reducer := ReduceRef(func(acc int, x *int) int {
+		return acc + *x
+	}, 0)
+	result := reducer(src)
+	assert.Equal(t, 6, result)
+}
+
+func TestZero(t *testing.T) {
+	result := Zero[int]()
+	assert.Equal(t, []int{}, result)
+	assert.True(t, IsEmpty(result))
+}
+
+func TestMonadChain(t *testing.T) {
+	src := []int{1, 2, 3}
+	result := MonadChain(src, func(x int) []int {
+		return []int{x, x * 10}
+	})
+	assert.Equal(t, []int{1, 10, 2, 20, 3, 30}, result)
+}
+
+func TestChain(t *testing.T) {
+	src := []int{1, 2, 3}
+	chain := Chain(func(x int) []int {
+		return []int{x, x * 10}
+	})
+	result := chain(src)
+	assert.Equal(t, []int{1, 10, 2, 20, 3, 30}, result)
+}
+
+func TestMonadAp(t *testing.T) {
+	fns := []func(int) int{
+		func(x int) int { return x * 2 },
+		func(x int) int { return x + 10 },
+	}
+	values := []int{1, 2}
+	result := MonadAp(fns, values)
+	assert.Equal(t, []int{2, 4, 11, 12}, result)
+}
+
+func TestMatchLeft(t *testing.T) {
+	matcher := MatchLeft(
+		func() string { return "empty" },
+		func(head int, tail []int) string {
+			return fmt.Sprintf("head:%d,tail:%v", head, tail)
+		},
+	)
+
+	assert.Equal(t, "empty", matcher([]int{}))
+	assert.Equal(t, "head:1,tail:[2 3]", matcher([]int{1, 2, 3}))
+}
+
+func TestTail(t *testing.T) {
+	assert.Equal(t, O.None[[]int](), Tail([]int{}))
+	assert.Equal(t, O.Some([]int{2, 3}), Tail([]int{1, 2, 3}))
+	assert.Equal(t, O.Some([]int{}), Tail([]int{1}))
+}
+
+func TestFirst(t *testing.T) {
+	assert.Equal(t, O.None[int](), First([]int{}))
+	assert.Equal(t, O.Some(1), First([]int{1, 2, 3}))
+}
+
+func TestLast(t *testing.T) {
+	assert.Equal(t, O.None[int](), Last([]int{}))
+	assert.Equal(t, O.Some(3), Last([]int{1, 2, 3}))
+	assert.Equal(t, O.Some(1), Last([]int{1}))
+}
+
+func TestUpsertAt(t *testing.T) {
+	src := []int{1, 2, 3}
+	upsert := UpsertAt(99)
+
+	result1 := upsert(src)
+	assert.Equal(t, []int{1, 2, 3, 99}, result1)
+}
+
+func TestSize(t *testing.T) {
+	assert.Equal(t, 0, Size([]int{}))
+	assert.Equal(t, 3, Size([]int{1, 2, 3}))
+}
+
+func TestMonadPartition(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	result := MonadPartition(src, func(x int) bool { return x > 2 })
+	assert.Equal(t, []int{1, 2}, result.F1)
+	assert.Equal(t, []int{3, 4, 5}, result.F2)
+}
+
+func TestIsNil(t *testing.T) {
+	var nilSlice []int
+	assert.True(t, IsNil(nilSlice))
+	assert.False(t, IsNil([]int{}))
+	assert.False(t, IsNil([]int{1}))
+}
+
+func TestIsNonNil(t *testing.T) {
+	var nilSlice []int
+	assert.False(t, IsNonNil(nilSlice))
+	assert.True(t, IsNonNil([]int{}))
+	assert.True(t, IsNonNil([]int{1}))
+}
+
+func TestConstNil(t *testing.T) {
+	result := ConstNil[int]()
+	assert.True(t, IsNil(result))
+}
+
+func TestSliceRight(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	slicer := SliceRight[int](2)
+	result := slicer(src)
+	assert.Equal(t, []int{3, 4, 5}, result)
+}
+
+func TestCopy(t *testing.T) {
+	src := []int{1, 2, 3}
+	copied := Copy(src)
+	assert.Equal(t, src, copied)
+	// Verify it's a different slice
+	copied[0] = 99
+	assert.Equal(t, 1, src[0])
+	assert.Equal(t, 99, copied[0])
+}
+
+func TestClone(t *testing.T) {
+	src := []int{1, 2, 3}
+	cloner := Clone(func(x int) int { return x * 2 })
+	result := cloner(src)
+	assert.Equal(t, []int{2, 4, 6}, result)
+}
+
+func TestFoldMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c"}
+	folder := FoldMapWithIndex[string](S.Monoid)(func(i int, s string) string {
+		return fmt.Sprintf("%d:%s", i, s)
+	})
+	result := folder(src)
+	assert.Equal(t, "0:a1:b2:c", result)
+}
+
+func TestFold(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	folder := Fold(N.MonoidSum[int]())
+	result := folder(src)
+	assert.Equal(t, 15, result)
+}
+
+func TestPush(t *testing.T) {
+	src := []int{1, 2, 3}
+	pusher := Push(4)
+	result := pusher(src)
+	assert.Equal(t, []int{1, 2, 3, 4}, result)
+}
+
+func TestMonadFlap(t *testing.T) {
+	fns := []func(int) string{
+		func(x int) string { return fmt.Sprintf("a%d", x) },
+		func(x int) string { return fmt.Sprintf("b%d", x) },
+	}
+	result := MonadFlap(fns, 5)
+	assert.Equal(t, []string{"a5", "b5"}, result)
+}
+
+func TestFlap(t *testing.T) {
+	fns := []func(int) string{
+		func(x int) string { return fmt.Sprintf("a%d", x) },
+		func(x int) string { return fmt.Sprintf("b%d", x) },
+	}
+	flapper := Flap[string](5)
+	result := flapper(fns)
+	assert.Equal(t, []string{"a5", "b5"}, result)
+}
+
+func TestPrepend(t *testing.T) {
+	src := []int{2, 3, 4}
+	prepender := Prepend(1)
+	result := prepender(src)
+	assert.Equal(t, []int{1, 2, 3, 4}, result)
+}

v2/array/array_test.go

@@ -0,0 +1,216 @@
+// 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 array
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/utils"
+	O "github.com/IBM/fp-go/v2/option"
+	S "github.com/IBM/fp-go/v2/string"
+	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMap1(t *testing.T) {
+
+	src := []string{"a", "b", "c"}
+
+	up := Map(strings.ToUpper)(src)
+
+	var up1 = []string{}
+	for _, s := range src {
+		up1 = append(up1, strings.ToUpper(s))
+	}
+
+	var up2 = []string{}
+	for i := range src {
+		up2 = append(up2, strings.ToUpper(src[i]))
+	}
+
+	assert.Equal(t, up, up1)
+	assert.Equal(t, up, up2)
+}
+
+func TestMap(t *testing.T) {
+
+	mapper := Map(utils.Upper)
+
+	src := []string{"a", "b", "c"}
+
+	dst := mapper(src)
+
+	assert.Equal(t, dst, []string{"A", "B", "C"})
+}
+
+func TestReduceRight(t *testing.T) {
+	values := From("a", "b", "c")
+	f := func(a, acc string) string {
+		return fmt.Sprintf("%s%s", acc, a)
+	}
+	b := ""
+
+	assert.Equal(t, "cba", ReduceRight(f, b)(values))
+	assert.Equal(t, "", ReduceRight(f, b)(Empty[string]()))
+}
+
+func TestReduce(t *testing.T) {
+
+	values := MakeBy(101, F.Identity[int])
+
+	sum := func(val int, current int) int {
+		return val + current
+	}
+	reducer := Reduce(sum, 0)
+
+	result := reducer(values)
+	assert.Equal(t, result, 5050)
+
+}
+
+func TestEmpty(t *testing.T) {
+	assert.True(t, IsNonEmpty(MakeBy(101, F.Identity[int])))
+	assert.True(t, IsEmpty([]int{}))
+}
+
+func TestAp(t *testing.T) {
+	assert.Equal(t,
+		[]int{2, 4, 6, 3, 6, 9},
+		F.Pipe1(
+			[]func(int) int{
+				utils.Double,
+				utils.Triple,
+			},
+			Ap[int, int]([]int{1, 2, 3}),
+		),
+	)
+}
+
+func TestIntercalate(t *testing.T) {
+	is := Intercalate(S.Monoid)("-")
+
+	assert.Equal(t, "", is(Empty[string]()))
+	assert.Equal(t, "a", is([]string{"a"}))
+	assert.Equal(t, "a-b-c", is([]string{"a", "b", "c"}))
+	assert.Equal(t, "a--c", is([]string{"a", "", "c"}))
+	assert.Equal(t, "a-b", is([]string{"a", "b"}))
+	assert.Equal(t, "a-b-c-d", is([]string{"a", "b", "c", "d"}))
+}
+
+func TestIntersperse(t *testing.T) {
+	// Test with empty array
+	assert.Equal(t, []int{}, Intersperse(0)([]int{}))
+
+	// Test with single element
+	assert.Equal(t, []int{1}, Intersperse(0)([]int{1}))
+
+	// Test with multiple elements
+	assert.Equal(t, []int{1, 0, 2, 0, 3}, Intersperse(0)([]int{1, 2, 3}))
+}
+
+func TestPrependAll(t *testing.T) {
+	empty := Empty[int]()
+	prep := PrependAll(0)
+	assert.Equal(t, empty, prep(empty))
+	assert.Equal(t, []int{0, 1, 0, 2, 0, 3}, prep([]int{1, 2, 3}))
+	assert.Equal(t, []int{0, 1}, prep([]int{1}))
+	assert.Equal(t, []int{0, 1, 0, 2, 0, 3, 0, 4}, prep([]int{1, 2, 3, 4}))
+}
+
+func TestFlatten(t *testing.T) {
+	assert.Equal(t, []int{1, 2, 3}, Flatten([][]int{{1}, {2}, {3}}))
+}
+
+func TestLookup(t *testing.T) {
+	data := []int{0, 1, 2}
+	none := O.None[int]()
+
+	assert.Equal(t, none, Lookup[int](-1)(data))
+	assert.Equal(t, none, Lookup[int](10)(data))
+	assert.Equal(t, O.Some(1), Lookup[int](1)(data))
+}
+
+func TestSlice(t *testing.T) {
+	data := []int{0, 1, 2, 3}
+
+	assert.Equal(t, []int{1, 2}, Slice[int](1, 3)(data))
+}
+
+func TestFrom(t *testing.T) {
+	assert.Equal(t, []int{1, 2, 3}, From(1, 2, 3))
+}
+
+func TestPartition(t *testing.T) {
+
+	pred := func(n int) bool {
+		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)))
+}
+
+func TestFilterChain(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[[]string] {
+		if i%2 != 0 {
+			return O.Of(From(fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i)))
+		}
+		return O.None[[]string]()
+	}
+
+	res := FilterChain(f)(src)
+
+	assert.Equal(t, From("a1", "b1", "a3", "b3"), res)
+}
+
+func TestFilterMap(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[string] {
+		if i%2 != 0 {
+			return O.Of(fmt.Sprintf("a%d", i))
+		}
+		return O.None[string]()
+	}
+
+	res := FilterMap(f)(src)
+
+	assert.Equal(t, From("a1", "a3"), res)
+}
+
+func TestFoldMap(t *testing.T) {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	assert.Equal(t, "ABC", fold(src))
+}
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}

v2/array/bind.go

@@ -0,0 +1,148 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+)
+
+// Do creates an empty context of type S to be used with the Bind operation.
+// This is the starting point for monadic do-notation style computations.
+//
+// Example:
+//
+//	type State struct {
+//	    X int
+//	    Y int
+//	}
+//	result := array.Do(State{})
+//
+//go:inline
+func Do[S any](
+	empty S,
+) []S {
+	return G.Do[[]S, S](empty)
+}
+
+// Bind attaches the result of a computation to a context S1 to produce a context S2.
+// The setter function defines how to update the context with the computation result.
+// This enables monadic composition where each step can produce multiple results.
+//
+// Example:
+//
+//	result := F.Pipe2(
+//	    array.Do(struct{ X, Y int }{}),
+//	    array.Bind(
+//	        func(x int) func(s struct{}) struct{ X int } {
+//	            return func(s struct{}) struct{ X int } { return struct{ X int }{x} }
+//	        },
+//	        func(s struct{}) []int { return []int{1, 2} },
+//	    ),
+//	)
+//
+//go:inline
+func Bind[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) []T,
+) func([]S1) []S2 {
+	return G.Bind[[]S1, []S2, []T, S1, S2, T](setter, f)
+}
+
+// Let attaches the result of a pure computation to a context S1 to produce a context S2.
+// Unlike Bind, the computation function returns a plain value T rather than []T.
+//
+// Example:
+//
+//	result := array.Let(
+//	    func(sum int) func(s struct{ X int }) struct{ X, Sum int } {
+//	        return func(s struct{ X int }) struct{ X, Sum int } {
+//	            return struct{ X, Sum int }{s.X, sum}
+//	        }
+//	    },
+//	    func(s struct{ X int }) int { return s.X * 2 },
+//	)
+//
+//go:inline
+func Let[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) T,
+) func([]S1) []S2 {
+	return G.Let[[]S1, []S2, S1, S2, T](setter, f)
+}
+
+// LetTo attaches a constant value to a context S1 to produce a context S2.
+// This is useful for adding constant values to the context.
+//
+// Example:
+//
+//	result := array.LetTo(
+//	    func(name string) func(s struct{ X int }) struct{ X int; Name string } {
+//	        return func(s struct{ X int }) struct{ X int; Name string } {
+//	            return struct{ X int; Name string }{s.X, name}
+//	        }
+//	    },
+//	    "constant",
+//	)
+//
+//go:inline
+func LetTo[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	b T,
+) func([]S1) []S2 {
+	return G.LetTo[[]S1, []S2, S1, S2, T](setter, b)
+}
+
+// BindTo initializes a new state S1 from a value T.
+// This is typically the first operation after Do to start building the context.
+//
+// Example:
+//
+//	result := F.Pipe2(
+//	    []int{1, 2, 3},
+//	    array.BindTo(func(x int) struct{ X int } {
+//	        return struct{ X int }{x}
+//	    }),
+//	)
+//
+//go:inline
+func BindTo[S1, T any](
+	setter func(T) S1,
+) func([]T) []S1 {
+	return G.BindTo[[]S1, []T, S1, T](setter)
+}
+
+// ApS attaches a value to a context S1 to produce a context S2 by considering
+// the context and the value concurrently (using applicative semantics).
+// This produces all combinations of context values and array values.
+//
+// Example:
+//
+//	result := array.ApS(
+//	    func(y int) func(s struct{ X int }) struct{ X, Y int } {
+//	        return func(s struct{ X int }) struct{ X, Y int } {
+//	            return struct{ X, Y int }{s.X, y}
+//	        }
+//	    },
+//	    []int{10, 20},
+//	)
+//
+//go:inline
+func ApS[S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa []T,
+) func([]S1) []S2 {
+	return G.ApS[[]S1, []S2, []T, S1, S2, T](setter, fa)
+}

v2/array/bind_extended_test.go

@@ -0,0 +1,78 @@
+// 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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/stretchr/testify/assert"
+)
+
+type TestState1 struct {
+	X int
+}
+
+type TestState2 struct {
+	X int
+	Y int
+}
+
+func TestLet(t *testing.T) {
+	result := F.Pipe2(
+		Do(TestState1{}),
+		Let(
+			func(y int) func(s TestState1) TestState2 {
+				return func(s TestState1) TestState2 {
+					return TestState2{X: s.X, Y: y}
+				}
+			},
+			func(s TestState1) int { return s.X * 2 },
+		),
+		Map(func(s TestState2) int { return s.X + s.Y }),
+	)
+
+	assert.Equal(t, []int{0}, result)
+}
+
+func TestLetTo(t *testing.T) {
+	result := F.Pipe2(
+		Do(TestState1{X: 5}),
+		LetTo(
+			func(y int) func(s TestState1) TestState2 {
+				return func(s TestState1) TestState2 {
+					return TestState2{X: s.X, Y: y}
+				}
+			},
+			42,
+		),
+		Map(func(s TestState2) int { return s.X + s.Y }),
+	)
+
+	assert.Equal(t, []int{47}, result)
+}
+
+func TestBindTo(t *testing.T) {
+	result := F.Pipe1(
+		[]int{1, 2, 3},
+		BindTo(func(x int) TestState1 {
+			return TestState1{X: x}
+		}),
+	)
+
+	expected := []TestState1{{X: 1}, {X: 2}, {X: 3}}
+	assert.Equal(t, expected, result)
+}

v2/array/bind_test.go

@@ -0,0 +1,56 @@
+// 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 array
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func getLastName(s utils.Initial) []string {
+	return Of("Doe")
+}
+
+func getGivenName(s utils.WithLastName) []string {
+	return Of("John")
+}
+
+func TestBind(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		Bind(utils.SetLastName, getLastName),
+		Bind(utils.SetGivenName, getGivenName),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}
+
+func TestApS(t *testing.T) {
+
+	res := F.Pipe3(
+		Do(utils.Empty),
+		ApS(utils.SetLastName, Of("Doe")),
+		ApS(utils.SetGivenName, Of("John")),
+		Map(utils.GetFullName),
+	)
+
+	assert.Equal(t, res, Of("John Doe"))
+}

v2/array/doc.go

@@ -0,0 +1,251 @@
+// 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 array provides functional programming utilities for working with Go slices.
+//
+// This package treats Go slices as immutable arrays and provides a rich set of operations
+// for transforming, filtering, folding, and combining arrays in a functional style.
+// All operations return new arrays rather than modifying existing ones.
+//
+// # Core Concepts
+//
+// The array package implements several functional programming abstractions:
+//   - Functor: Transform array elements with Map
+//   - Applicative: Apply functions in arrays to values in arrays
+//   - Monad: Chain operations that produce arrays with Chain/FlatMap
+//   - Foldable: Reduce arrays to single values with Reduce/Fold
+//   - Traversable: Transform arrays while preserving structure
+//
+// # Basic Operations
+//
+//	// Creating arrays
+//	arr := array.From(1, 2, 3, 4, 5)
+//	repeated := array.Replicate(3, "hello")
+//	generated := array.MakeBy(5, func(i int) int { return i * 2 })
+//
+//	// Transforming arrays
+//	doubled := array.Map(func(x int) int { return x * 2 })(arr)
+//	filtered := array.Filter(func(x int) bool { return x > 2 })(arr)
+//
+//	// Combining arrays
+//	combined := array.Flatten([][]int{{1, 2}, {3, 4}})
+//	zipped := array.Zip([]string{"a", "b"})([]int{1, 2})
+//
+// # Mapping and Filtering
+//
+// Transform array elements with Map, or filter elements with Filter:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Map transforms each element
+//	doubled := array.Map(func(x int) int { return x * 2 })(numbers)
+//	// Result: [2, 4, 6, 8, 10]
+//
+//	// Filter keeps elements matching a predicate
+//	evens := array.Filter(func(x int) bool { return x%2 == 0 })(numbers)
+//	// Result: [2, 4]
+//
+//	// FilterMap combines both operations
+//	import "github.com/IBM/fp-go/v2/option"
+//	result := array.FilterMap(func(x int) option.Option[int] {
+//	    if x%2 == 0 {
+//	        return option.Some(x * 2)
+//	    }
+//	    return option.None[int]()
+//	})(numbers)
+//	// Result: [4, 8]
+//
+// # Folding and Reducing
+//
+// Reduce arrays to single values:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Sum all elements
+//	sum := array.Reduce(func(acc, x int) int { return acc + x }, 0)(numbers)
+//	// Result: 15
+//
+//	// Using a Monoid
+//	import "github.com/IBM/fp-go/v2/monoid"
+//	sum := array.Fold(monoid.MonoidSum[int]())(numbers)
+//	// Result: 15
+//
+// # Chaining Operations
+//
+// Chain operations that produce arrays (also known as FlatMap):
+//
+//	numbers := []int{1, 2, 3}
+//	result := array.Chain(func(x int) []int {
+//	    return []int{x, x * 10}
+//	})(numbers)
+//	// Result: [1, 10, 2, 20, 3, 30]
+//
+// # Finding Elements
+//
+// Search for elements matching predicates:
+//
+//	numbers := []int{1, 2, 3, 4, 5}
+//
+//	// Find first element > 3
+//	first := array.FindFirst(func(x int) bool { return x > 3 })(numbers)
+//	// Result: Some(4)
+//
+//	// Find last element > 3
+//	last := array.FindLast(func(x int) bool { return x > 3 })(numbers)
+//	// Result: Some(5)
+//
+//	// Get head and tail
+//	head := array.Head(numbers) // Some(1)
+//	tail := array.Tail(numbers) // Some([2, 3, 4, 5])
+//
+// # Sorting
+//
+// Sort arrays using Ord instances:
+//
+//	import "github.com/IBM/fp-go/v2/ord"
+//
+//	numbers := []int{3, 1, 4, 1, 5}
+//	sorted := array.Sort(ord.FromStrictCompare[int]())(numbers)
+//	// Result: [1, 1, 3, 4, 5]
+//
+//	// Sort by extracted key
+//	type Person struct { Name string; Age int }
+//	people := []Person{{"Alice", 30}, {"Bob", 25}}
+//	byAge := array.SortByKey(ord.FromStrictCompare[int](), func(p Person) int {
+//	    return p.Age
+//	})(people)
+//
+// # Uniqueness
+//
+// Remove duplicate elements:
+//
+//	numbers := []int{1, 2, 2, 3, 3, 3}
+//	unique := array.StrictUniq(numbers)
+//	// Result: [1, 2, 3]
+//
+//	// Unique by key
+//	type Person struct { Name string; Age int }
+//	people := []Person{{"Alice", 30}, {"Bob", 25}, {"Alice", 35}}
+//	uniqueByName := array.Uniq(func(p Person) string { return p.Name })(people)
+//	// Result: [{"Alice", 30}, {"Bob", 25}]
+//
+// # Zipping
+//
+// Combine multiple arrays:
+//
+//	names := []string{"Alice", "Bob", "Charlie"}
+//	ages := []int{30, 25, 35}
+//
+//	// Zip into tuples
+//	pairs := array.Zip(ages)(names)
+//	// Result: [(Alice, 30), (Bob, 25), (Charlie, 35)]
+//
+//	// Zip with custom function
+//	result := array.ZipWith(names, ages, func(name string, age int) string {
+//	    return fmt.Sprintf("%s is %d", name, age)
+//	})
+//
+// # Monadic Do Notation
+//
+// Build complex array computations using do-notation style:
+//
+//	result := array.Do(
+//	    struct{ X, Y int }{},
+//	)(
+//	    array.Bind(
+//	        func(x int) func(s struct{}) struct{ X int } {
+//	            return func(s struct{}) struct{ X int } { return struct{ X int }{x} }
+//	        },
+//	        func(s struct{}) []int { return []int{1, 2, 3} },
+//	    ),
+//	    array.Bind(
+//	        func(y int) func(s struct{ X int }) struct{ X, Y int } {
+//	            return func(s struct{ X int }) struct{ X, Y int } {
+//	                return struct{ X, Y int }{s.X, y}
+//	            }
+//	        },
+//	        func(s struct{ X int }) []int { return []int{4, 5} },
+//	    ),
+//	)
+//	// Produces all combinations: [{1,4}, {1,5}, {2,4}, {2,5}, {3,4}, {3,5}]
+//
+// # Sequence and Traverse
+//
+// Transform arrays of effects into effects of arrays:
+//
+//	import "github.com/IBM/fp-go/v2/option"
+//
+//	// Sequence: []Option[A] -> Option[[]A]
+//	opts := []option.Option[int]{
+//	    option.Some(1),
+//	    option.Some(2),
+//	    option.Some(3),
+//	}
+//	result := array.ArrayOption[int]()(opts)
+//	// Result: Some([1, 2, 3])
+//
+//	// If any is None, result is None
+//	opts2 := []option.Option[int]{
+//	    option.Some(1),
+//	    option.None[int](),
+//	    option.Some(3),
+//	}
+//	result2 := array.ArrayOption[int]()(opts2)
+//	// Result: None
+//
+// # Equality and Comparison
+//
+// Compare arrays for equality:
+//
+//	import "github.com/IBM/fp-go/v2/eq"
+//
+//	eq := array.Eq(eq.FromStrictEquals[int]())
+//	equal := eq.Equals([]int{1, 2, 3}, []int{1, 2, 3})
+//	// Result: true
+//
+// # Monoid Operations
+//
+// Combine arrays using monoid operations:
+//
+//	import "github.com/IBM/fp-go/v2/monoid"
+//
+//	// Concatenate arrays
+//	m := array.Monoid[int]()
+//	result := m.Concat([]int{1, 2}, []int{3, 4})
+//	// Result: [1, 2, 3, 4]
+//
+//	// Concatenate multiple arrays efficiently
+//	result := array.ArrayConcatAll(
+//	    []int{1, 2},
+//	    []int{3, 4},
+//	    []int{5, 6},
+//	)
+//	// Result: [1, 2, 3, 4, 5, 6]
+//
+// # Performance Considerations
+//
+// Most operations create new arrays rather than modifying existing ones. For performance-critical
+// code, consider:
+//   - Using Copy for shallow copies when needed
+//   - Using Clone with a custom cloning function for deep copies
+//   - Batching operations to minimize intermediate allocations
+//   - Using ArrayConcatAll for efficient concatenation of multiple arrays
+//
+// # Subpackages
+//
+//   - array/generic: Generic implementations for custom array-like types
+//   - array/nonempty: Operations for non-empty arrays with compile-time guarantees
+//   - array/testing: Testing utilities for array laws and properties
+package array

v2/array/eq.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	E "github.com/IBM/fp-go/v2/eq"
+)
+
+func equals[T any](left []T, right []T, eq func(T, T) bool) bool {
+	if len(left) != len(right) {
+		return false
+	}
+	for i, v1 := range left {
+		v2 := right[i]
+		if !eq(v1, v2) {
+			return false
+		}
+	}
+	return true
+}
+
+// Eq creates an equality checker for arrays given an equality checker for elements.
+// Two arrays are considered equal if they have the same length and all corresponding
+// elements are equal according to the provided Eq instance.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/eq"
+//
+//	intArrayEq := array.Eq(eq.FromStrictEquals[int]())
+//	result := intArrayEq.Equals([]int{1, 2, 3}, []int{1, 2, 3}) // true
+//	result2 := intArrayEq.Equals([]int{1, 2, 3}, []int{1, 2, 4}) // false
+func Eq[T any](e E.Eq[T]) E.Eq[[]T] {
+	eq := e.Equals
+	return E.FromEquals(func(left, right []T) bool {
+		return equals(left, right, eq)
+	})
+}

v2/array/eq_test.go

@@ -0,0 +1,44 @@
+// 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 array
+
+import (
+	"testing"
+
+	E "github.com/IBM/fp-go/v2/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEq(t *testing.T) {
+	intEq := Eq(E.FromStrictEquals[int]())
+
+	// Test equal arrays
+	assert.True(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2, 3}))
+
+	// Test different lengths
+	assert.False(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2}))
+
+	// Test different values
+	assert.False(t, intEq.Equals([]int{1, 2, 3}, []int{1, 2, 4}))
+
+	// Test empty arrays
+	assert.True(t, intEq.Equals([]int{}, []int{}))
+
+	// Test string arrays
+	stringEq := Eq(E.FromStrictEquals[string]())
+	assert.True(t, stringEq.Equals([]string{"a", "b"}, []string{"a", "b"}))
+	assert.False(t, stringEq.Equals([]string{"a", "b"}, []string{"a", "c"}))
+}

v2/array/example_any_test.go

@@ -0,0 +1,77 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+func Example_any() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(Any(pred)(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		Filter(pred),
+		IsNonEmpty[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}
+
+func Example_any_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	// Any tests if any of the entries in the array matches the condition
+	Any := F.Flow2(
+		FindFirst(pred),
+		O.IsSome[int],
+	)
+
+	fmt.Println(Any(data1))
+
+	// Output:
+	// true
+}

v2/array/example_find_test.go

@@ -0,0 +1,55 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+)
+
+func Example_find() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	fmt.Println(FindFirst(pred)(data1))
+
+	// Output:
+	// Some[int](1)
+}
+
+func Example_find_filter() {
+
+	pred := func(val int) bool {
+		return val&2 == 0
+	}
+
+	data1 := From(1, 2, 3)
+
+	Find := F.Flow2(
+		Filter(pred),
+		Head[int],
+	)
+
+	fmt.Println(Find(data1))
+
+	// Output:
+	// Some[int](1)
+}

v2/array/examples_basic_test.go

@@ -0,0 +1,59 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// Example_basic adapts examples from [https://github.com/inato/fp-ts-cheatsheet#basic-manipulation]
+func Example_basic() {
+
+	someArray := From(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) // []int
+
+	isEven := func(num int) bool {
+		return num%2 == 0
+	}
+
+	square := func(num int) int {
+		return num * num
+	}
+
+	// filter and map
+	result := F.Pipe2(
+		someArray,
+		Filter(isEven),
+		Map(square),
+	) // [0 4 16 36 64]
+
+	// or in one go with filterMap
+	resultFilterMap := F.Pipe1(
+		someArray,
+		FilterMap(
+			F.Flow2(O.FromPredicate(isEven), O.Map(square)),
+		),
+	)
+
+	fmt.Println(result)
+	fmt.Println(resultFilterMap)
+
+	// Output:
+	// [0 4 16 36 64]
+	// [0 4 16 36 64]
+}

v2/array/examples_sort_test.go

@@ -0,0 +1,92 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/v2/function"
+	I "github.com/IBM/fp-go/v2/number/integer"
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/IBM/fp-go/v2/ord"
+	S "github.com/IBM/fp-go/v2/string"
+)
+
+type user struct {
+	name string
+	age  O.Option[int]
+}
+
+func (user user) GetName() string {
+	return user.name
+}
+
+func (user user) GetAge() O.Option[int] {
+	return user.age
+}
+
+// Example_sort adapts examples from [https://github.com/inato/fp-ts-cheatsheet#sort-elements-with-ord]
+func Example_sort() {
+
+	strings := From("zyx", "abc", "klm")
+
+	sortedStrings := F.Pipe1(
+		strings,
+		Sort(S.Ord),
+	) // => ['abc', 'klm', 'zyx']
+
+	// reverse sort
+	reverseSortedStrings := F.Pipe1(
+		strings,
+		Sort(ord.Reverse(S.Ord)),
+	) // => ['zyx', 'klm', 'abc']
+
+	// sort Option
+	optionalNumbers := From(O.Some(1337), O.None[int](), O.Some(42))
+
+	sortedNums := F.Pipe1(
+		optionalNumbers,
+		Sort(O.Ord(I.Ord)),
+	)
+
+	// complex object with different rules
+	byName := F.Pipe1(
+		S.Ord,
+		ord.Contramap(user.GetName),
+	) // ord.Ord[user]
+
+	byAge := F.Pipe1(
+		O.Ord(I.Ord),
+		ord.Contramap(user.GetAge),
+	) // ord.Ord[user]
+
+	sortedUsers := F.Pipe1(
+		From(user{name: "a", age: O.Of(30)}, user{name: "d", age: O.Of(10)}, user{name: "c"}, user{name: "b", age: O.Of(10)}),
+		SortBy(From(byAge, byName)),
+	)
+
+	fmt.Println(sortedStrings)
+	fmt.Println(reverseSortedStrings)
+	fmt.Println(sortedNums)
+	fmt.Println(sortedUsers)
+
+	// Output:
+	// [abc klm zyx]
+	// [zyx klm abc]
+	// [None[int] Some[int](42) Some[int](1337)]
+	// [{c {false 0}} {b {true 10}} {d {true 10}} {a {true 30}}]
+
+}

v2/array/find.go

@@ -0,0 +1,115 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// FindFirst finds the first element which satisfies a predicate function.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findGreaterThan3 := array.FindFirst(func(x int) bool { return x > 3 })
+//	result := findGreaterThan3([]int{1, 2, 4, 5}) // Some(4)
+//	result2 := findGreaterThan3([]int{1, 2, 3}) // None
+//
+//go:inline
+func FindFirst[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindFirst[[]A](pred)
+}
+
+// FindFirstWithIndex finds the first element which satisfies a predicate function that also receives the index.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findEvenAtEvenIndex := array.FindFirstWithIndex(func(i, x int) bool {
+//	    return i%2 == 0 && x%2 == 0
+//	})
+//	result := findEvenAtEvenIndex([]int{1, 3, 4, 5}) // Some(4)
+//
+//go:inline
+func FindFirstWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindFirstWithIndex[[]A](pred)
+}
+
+// FindFirstMap finds the first element for which the selector function returns Some.
+// This combines finding and mapping in a single operation.
+//
+// Example:
+//
+//	import "strconv"
+//
+//	parseFirst := array.FindFirstMap(func(s string) option.Option[int] {
+//	    if n, err := strconv.Atoi(s); err == nil {
+//	        return option.Some(n)
+//	    }
+//	    return option.None[int]()
+//	})
+//	result := parseFirst([]string{"a", "42", "b"}) // Some(42)
+//
+//go:inline
+func FindFirstMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMap[[]A](sel)
+}
+
+// FindFirstMapWithIndex finds the first element for which the selector function returns Some.
+// The selector receives both the index and the element.
+//
+//go:inline
+func FindFirstMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindFirstMapWithIndex[[]A](sel)
+}
+
+// FindLast finds the last element which satisfies a predicate function.
+// Returns Some(element) if found, None if no element matches.
+//
+// Example:
+//
+//	findGreaterThan3 := array.FindLast(func(x int) bool { return x > 3 })
+//	result := findGreaterThan3([]int{1, 4, 2, 5}) // Some(5)
+//
+//go:inline
+func FindLast[A any](pred func(A) bool) func([]A) O.Option[A] {
+	return G.FindLast[[]A](pred)
+}
+
+// FindLastWithIndex finds the last element which satisfies a predicate function that also receives the index.
+// Returns Some(element) if found, None if no element matches.
+//
+//go:inline
+func FindLastWithIndex[A any](pred func(int, A) bool) func([]A) O.Option[A] {
+	return G.FindLastWithIndex[[]A](pred)
+}
+
+// FindLastMap finds the last element for which the selector function returns Some.
+// This combines finding and mapping in a single operation, searching from the end.
+//
+//go:inline
+func FindLastMap[A, B any](sel func(A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMap[[]A](sel)
+}
+
+// FindLastMapWithIndex finds the last element for which the selector function returns Some.
+// The selector receives both the index and the element, searching from the end.
+//
+//go:inline
+func FindLastMapWithIndex[A, B any](sel func(int, A) O.Option[B]) func([]A) O.Option[B] {
+	return G.FindLastMapWithIndex[[]A](sel)
+}

v2/array/find_test.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	"fmt"
+	"testing"
+
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFindFirstWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindFirstWithIndex(func(i, x int) bool {
+		return i > 2 && x%2 == 0
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(4), result)
+
+	notFound := FindFirstWithIndex(func(i, x int) bool {
+		return i > 10
+	})
+	assert.Equal(t, O.None[int](), notFound(src))
+}
+
+func TestFindFirstMap(t *testing.T) {
+	src := []string{"a", "42", "b", "100"}
+	finder := FindFirstMap(func(s string) O.Option[int] {
+		if len(s) > 1 {
+			return O.Some(len(s))
+		}
+		return O.None[int]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(2), result)
+}
+
+func TestFindFirstMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c", "d"}
+	finder := FindFirstMapWithIndex(func(i int, s string) O.Option[string] {
+		if i > 1 {
+			return O.Some(fmt.Sprintf("%d:%s", i, s))
+		}
+		return O.None[string]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some("2:c"), result)
+}
+
+func TestFindLast(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindLast(func(x int) bool { return x%2 == 0 })
+	result := finder(src)
+	assert.Equal(t, O.Some(4), result)
+
+	notFound := FindLast(func(x int) bool { return x > 10 })
+	assert.Equal(t, O.None[int](), notFound(src))
+}
+
+func TestFindLastWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	finder := FindLastWithIndex(func(i, x int) bool {
+		return i < 3 && x%2 == 0
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(2), result)
+}
+
+func TestFindLastMap(t *testing.T) {
+	src := []string{"a", "42", "b", "100"}
+	finder := FindLastMap(func(s string) O.Option[int] {
+		if len(s) > 1 {
+			return O.Some(len(s))
+		}
+		return O.None[int]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some(3), result)
+}
+
+func TestFindLastMapWithIndex(t *testing.T) {
+	src := []string{"a", "b", "c", "d"}
+	finder := FindLastMapWithIndex(func(i int, s string) O.Option[string] {
+		if i < 3 {
+			return O.Some(fmt.Sprintf("%d:%s", i, s))
+		}
+		return O.None[string]()
+	})
+	result := finder(src)
+	assert.Equal(t, O.Some("2:c"), result)
+}

v2/array/generic/any.go

@@ -0,0 +1,34 @@
+// 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 generic
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// AnyWithIndex tests if any of the elements in the array matches the predicate
+func AnyWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) bool {
+	return F.Flow2(
+		FindFirstWithIndex[AS](pred),
+		O.IsSome[A],
+	)
+}
+
+// Any tests if any of the elements in the array matches the predicate
+func Any[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) bool {
+	return AnyWithIndex[AS](F.Ignore1of2[int](pred))
+}

v2/array/generic/array.go

@@ -0,0 +1,366 @@
+// 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 generic
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	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"
+)
+
+// Of constructs a single element array
+func Of[GA ~[]A, A any](value A) GA {
+	return GA{value}
+}
+
+func Reduce[GA ~[]A, A, B any](f func(B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduce[GA](as, f, initial)
+	}
+}
+
+func ReduceWithIndex[GA ~[]A, A, B any](f func(int, B, A) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceWithIndex[GA](as, f, initial)
+	}
+}
+
+func ReduceRight[GA ~[]A, A, B any](f func(A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRight[GA](as, f, initial)
+	}
+}
+
+func ReduceRightWithIndex[GA ~[]A, A, B any](f func(int, A, B) B, initial B) func(GA) B {
+	return func(as GA) B {
+		return MonadReduceRightWithIndex[GA](as, f, initial)
+	}
+}
+
+func MonadReduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
+	return array.Reduce(fa, f, initial)
+}
+
+func MonadReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
+	return array.ReduceWithIndex(fa, f, initial)
+}
+
+func MonadReduceRight[GA ~[]A, A, B any](fa GA, f func(A, B) B, initial B) B {
+	return array.ReduceRight(fa, f, initial)
+}
+
+func MonadReduceRightWithIndex[GA ~[]A, A, B any](fa GA, f func(int, A, B) B, initial B) B {
+	return array.ReduceRightWithIndex(fa, f, initial)
+}
+
+// From constructs an array from a set of variadic arguments
+func From[GA ~[]A, A any](data ...A) GA {
+	return data
+}
+
+// MakeBy returns a `Array` of length `n` with element `i` initialized with `f(i)`.
+func MakeBy[AS ~[]A, F ~func(int) A, A any](n int, f F) AS {
+	// sanity check
+	if n <= 0 {
+		return Empty[AS]()
+	}
+	// run the generator function across the input
+	as := make(AS, n)
+	for i := n - 1; i >= 0; i-- {
+		as[i] = f(i)
+	}
+	return as
+}
+
+func Replicate[AS ~[]A, A any](n int, a A) AS {
+	return MakeBy[AS](n, F.Constant1[int](a))
+}
+
+func Lookup[GA ~[]A, A any](idx int) func(GA) O.Option[A] {
+	none := O.None[A]()
+	if idx < 0 {
+		return F.Constant1[GA](none)
+	}
+	return func(as GA) O.Option[A] {
+		if idx < len(as) {
+			return O.Some(as[idx])
+		}
+		return none
+	}
+}
+
+func Tail[GA ~[]A, A any](as GA) O.Option[GA] {
+	if array.IsEmpty(as) {
+		return O.None[GA]()
+	}
+	return O.Some(as[1:])
+}
+
+func Head[GA ~[]A, A any](as GA) O.Option[A] {
+	if array.IsEmpty(as) {
+		return O.None[A]()
+	}
+	return O.Some(as[0])
+}
+
+func First[GA ~[]A, A any](as GA) O.Option[A] {
+	return Head(as)
+}
+
+func Last[GA ~[]A, A any](as GA) O.Option[A] {
+	if array.IsEmpty(as) {
+		return O.None[A]()
+	}
+	return O.Some(as[len(as)-1])
+}
+
+func Append[GA ~[]A, A any](as GA, a A) GA {
+	return array.Append(as, a)
+}
+
+func Empty[GA ~[]A, A any]() GA {
+	return array.Empty[GA]()
+}
+
+func UpsertAt[GA ~[]A, A any](a A) func(GA) GA {
+	return array.UpsertAt[GA](a)
+}
+
+func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
+	return array.MonadMap[GA, GB](as, f)
+}
+
+func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
+	return array.Map[GA, GB](f)
+}
+
+func MonadMapWithIndex[GA ~[]A, GB ~[]B, A, B any](as GA, f func(int, A) B) GB {
+	return array.MonadMapWithIndex[GA, GB](as, f)
+}
+
+func MapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) B) func(GA) GB {
+	return F.Bind2nd(MonadMapWithIndex[GA, GB, A, B], f)
+}
+
+func Size[GA ~[]A, A any](as GA) int {
+	return len(as)
+}
+
+func filterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
+	result := make(GB, 0, len(fa))
+	for _, a := range fa {
+		O.Map(func(b B) B {
+			result = append(result, b)
+			return b
+		})(f(a))
+	}
+	return result
+}
+
+func filterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	result := make(GB, 0, len(fa))
+	for i, a := range fa {
+		O.Map(func(b B) B {
+			result = append(result, b)
+			return b
+		})(f(i, a))
+	}
+	return result
+}
+
+func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(A) O.Option[B]) GB {
+	return filterMap[GA, GB](fa, f)
+}
+
+func MonadFilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(int, A) O.Option[B]) GB {
+	return filterMapWithIndex[GA, GB](fa, f)
+}
+
+func filterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](fa AS, pred PRED) AS {
+	result := make(AS, 0, len(fa))
+	for i, a := range fa {
+		if pred(i, a) {
+			result = append(result, a)
+		}
+	}
+	return result
+}
+
+func FilterWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) AS {
+	return F.Bind2nd(filterWithIndex[AS, PRED, A], pred)
+}
+
+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 {
+	return F.Flow2(
+		FilterMap[GA, []GB](f),
+		Flatten[[]GB],
+	)
+}
+
+func Flatten[GAA ~[]GA, GA ~[]A, A any](mma GAA) GA {
+	return MonadChain(mma, F.Identity[GA])
+}
+
+func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(A) O.Option[B]) func(GA) GB {
+	return F.Bind2nd(MonadFilterMap[GA, GB, A, B], f)
+}
+
+func FilterMapWithIndex[GA ~[]A, GB ~[]B, A, B any](f func(int, A) O.Option[B]) func(GA) GB {
+	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] {
+	left := Empty[GA]()
+	right := Empty[GA]()
+	array.Reduce(as, func(c bool, a A) bool {
+		if pred(a) {
+			right = append(right, a)
+		} else {
+			left = append(left, a)
+		}
+		return c
+	}, true)
+	// returns the partition
+	return tuple.MakeTuple2(left, right)
+}
+
+func Partition[GA ~[]A, A any](pred func(A) bool) func(GA) tuple.Tuple2[GA, GA] {
+	return F.Bind2nd(MonadPartition[GA, A], pred)
+}
+
+func MonadChain[AS ~[]A, BS ~[]B, A, B any](fa AS, f func(a A) BS) BS {
+	return array.Reduce(fa, func(bs BS, a A) BS {
+		return append(bs, f(a)...)
+	}, Empty[BS]())
+}
+
+func Chain[AS ~[]A, BS ~[]B, A, B any](f func(A) BS) func(AS) BS {
+	return F.Bind2nd(MonadChain[AS, BS, A, B], f)
+}
+
+func MonadAp[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fab ABS, fa AS) BS {
+	return MonadChain(fab, F.Bind1st(MonadMap[AS, BS, A, B], fa))
+}
+
+func Ap[BS ~[]B, ABS ~[]func(A) B, AS ~[]A, B, A any](fa AS) func(ABS) BS {
+	return F.Bind2nd(MonadAp[BS, ABS, AS], fa)
+}
+
+func IsEmpty[AS ~[]A, A any](as AS) bool {
+	return array.IsEmpty(as)
+}
+
+func IsNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNil(as)
+}
+
+func IsNonNil[GA ~[]A, A any](as GA) bool {
+	return array.IsNonNil(as)
+}
+
+func Match[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as)
+	}
+}
+
+func MatchLeft[AS ~[]A, A, B any](onEmpty func() B, onNonEmpty func(A, AS) B) func(AS) B {
+	return func(as AS) B {
+		if IsEmpty(as) {
+			return onEmpty()
+		}
+		return onNonEmpty(as[0], as[1:])
+	}
+}
+
+//go:inline
+func Slice[AS ~[]A, A any](start int, end int) func(AS) AS {
+	return array.Slice[AS](start, end)
+}
+
+//go:inline
+func SliceRight[AS ~[]A, A any](start int) func(AS) AS {
+	return array.SliceRight[AS](start)
+}
+
+func Copy[AS ~[]A, A any](b AS) AS {
+	buf := make(AS, len(b))
+	copy(buf, b)
+	return buf
+}
+
+func Clone[AS ~[]A, A any](f func(A) A) func(as AS) AS {
+	// implementation assumes that map does not optimize for the empty array
+	return Map[AS, AS](f)
+}
+
+func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(f func(A) B) func(AS) B {
+		return func(as AS) B {
+			return array.Reduce(as, func(cur B, a A) B {
+				return concat(cur, f(a))
+			}, empty)
+		}
+	}
+}
+
+func FoldMapWithIndex[AS ~[]A, A, B any](m M.Monoid[B]) func(func(int, A) B) func(AS) B {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(f func(int, A) B) func(AS) B {
+		return func(as AS) B {
+			return array.ReduceWithIndex(as, func(idx int, cur B, a A) B {
+				return concat(cur, f(idx, a))
+			}, empty)
+		}
+	}
+}
+
+func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
+	empty := m.Empty()
+	concat := m.Concat
+	return func(as AS) A {
+		return array.Reduce(as, concat, empty)
+	}
+}
+
+func Push[ENDO ~func(GA) GA, GA ~[]A, A any](a A) ENDO {
+	return F.Bind2nd(array.Push[GA, A], a)
+}
+
+func MonadFlap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](fab GFAB, a A) GB {
+	return FC.MonadFlap(MonadMap[GFAB, GB], fab, a)
+}
+
+func Flap[FAB ~func(A) B, GFAB ~[]FAB, GB ~[]B, A, B any](a A) func(GFAB) GB {
+	return FC.Flap(Map[GFAB, GB], a)
+}
+
+func Prepend[ENDO ~func(AS) AS, AS []A, A any](head A) ENDO {
+	return array.Prepend[ENDO](head)
+}

v2/array/generic/bind.go

@@ -0,0 +1,89 @@
+// 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 generic
+
+import (
+	A "github.com/IBM/fp-go/v2/internal/apply"
+	C "github.com/IBM/fp-go/v2/internal/chain"
+	F "github.com/IBM/fp-go/v2/internal/functor"
+)
+
+// Bind creates an empty context of type [S] to be used with the [Bind] operation
+func Do[GS ~[]S, S any](
+	empty S,
+) GS {
+	return Of[GS](empty)
+}
+
+// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
+func Bind[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	f func(S1) GT,
+) func(GS1) GS2 {
+	return C.Bind(
+		Chain[GS1, GS2, S1, S2],
+		Map[GT, GS2, T, S2],
+		setter,
+		f,
+	)
+}
+
+// Let attaches the result of a computation to a context [S1] to produce a context [S2]
+func Let[GS1 ~[]S1, GS2 ~[]S2, S1, S2, T any](
+	key func(T) func(S1) S2,
+	f func(S1) T,
+) func(GS1) GS2 {
+	return F.Let(
+		Map[GS1, GS2, S1, S2],
+		key,
+		f,
+	)
+}
+
+// LetTo attaches the a value to a context [S1] to produce a context [S2]
+func LetTo[GS1 ~[]S1, GS2 ~[]S2, S1, S2, B any](
+	key func(B) func(S1) S2,
+	b B,
+) func(GS1) GS2 {
+	return F.LetTo(
+		Map[GS1, GS2, S1, S2],
+		key,
+		b,
+	)
+}
+
+// BindTo initializes a new state [S1] from a value [T]
+func BindTo[GS1 ~[]S1, GT ~[]T, S1, T any](
+	setter func(T) S1,
+) func(GT) GS1 {
+	return C.BindTo(
+		Map[GT, GS1, T, S1],
+		setter,
+	)
+}
+
+// ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
+func ApS[GS1 ~[]S1, GS2 ~[]S2, GT ~[]T, S1, S2, T any](
+	setter func(T) func(S1) S2,
+	fa GT,
+) func(GS1) GS2 {
+	return A.ApS(
+		Ap[GS2, []func(T) S2, GT, S2, T],
+		Map[GS1, []func(T) S2, S1, func(T) S2],
+		setter,
+		fa,
+	)
+}

v2/array/generic/find.go

@@ -0,0 +1,97 @@
+// 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 generic
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// FindFirstWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindFirstWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i, a := range as {
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindFirst finds the first element which satisfies a predicate (or a refinement) function
+func FindFirst[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindFirstWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindFirstMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindFirstMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		count := len(as)
+		for i := 0; i < count; i++ {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindFirstMap finds the first element returned by an [O.Option] based selector function
+func FindFirstMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindFirstMapWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastWithIndex finds the first element which satisfies a predicate (or a refinement) function
+func FindLastWithIndex[AS ~[]A, PRED ~func(int, A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	none := O.None[A]()
+	return func(as AS) O.Option[A] {
+		for i := len(as) - 1; i >= 0; i-- {
+			a := as[i]
+			if pred(i, a) {
+				return O.Some(a)
+			}
+		}
+		return none
+	}
+}
+
+// FindLast finds the first element which satisfies a predicate (or a refinement) function
+func FindLast[AS ~[]A, PRED ~func(A) bool, A any](pred PRED) func(AS) O.Option[A] {
+	return FindLastWithIndex[AS](F.Ignore1of2[int](pred))
+}
+
+// FindLastMapWithIndex finds the first element returned by an [O.Option] based selector function
+func FindLastMapWithIndex[AS ~[]A, PRED ~func(int, A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	none := O.None[B]()
+	return func(as AS) O.Option[B] {
+		for i := len(as) - 1; i >= 0; i-- {
+			out := pred(i, as[i])
+			if O.IsSome(out) {
+				return out
+			}
+		}
+		return none
+	}
+}
+
+// FindLastMap finds the first element returned by an [O.Option] based selector function
+func FindLastMap[AS ~[]A, PRED ~func(A) O.Option[B], A, B any](pred PRED) func(AS) O.Option[B] {
+	return FindLastMapWithIndex[AS](F.Ignore1of2[int](pred))
+}

v2/array/generic/monad.go

@@ -0,0 +1,43 @@
+// Copyright (c) 2024 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import (
+	"github.com/IBM/fp-go/v2/internal/monad"
+)
+
+type arrayMonad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B] struct{}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Of(a A) GA {
+	return Of[GA, A](a)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Map(f func(A) B) func(GA) GB {
+	return Map[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Chain(f func(A) GB) func(GA) GB {
+	return Chain[GA, GB, A, B](f)
+}
+
+func (o *arrayMonad[A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
+	return Ap[GB, GAB, GA, B, A](fa)
+}
+
+// Monad implements the monadic operations for an array
+func Monad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B]() monad.Monad[A, B, GA, GB, GAB] {
+	return &arrayMonad[A, B, GA, GB, GAB]{}
+}

v2/array/generic/sort.go

@@ -0,0 +1,56 @@
+// 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 generic
+
+import (
+	"sort"
+
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/ord"
+)
+
+// Sort implements a stable sort on the array given the provided ordering
+func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
+	return SortByKey[GA](ord, F.Identity[T])
+}
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[GA ~[]T, K, T any](ord O.Ord[K], f func(T) K) func(ma GA) GA {
+
+	return func(ma GA) GA {
+		// nothing to sort
+		l := len(ma)
+		if l < 2 {
+			return ma
+		}
+		// copy
+		cpy := make(GA, l)
+		copy(cpy, ma)
+		sort.Slice(cpy, func(i, j int) bool {
+			return ord.Compare(f(cpy[i]), f(cpy[j])) < 0
+		})
+		return cpy
+	}
+}
+
+// SortBy implements a stable sort on the array given the provided ordering
+func SortBy[GA ~[]T, GO ~[]O.Ord[T], T any](ord GO) func(ma GA) GA {
+	return F.Pipe2(
+		ord,
+		Fold[GO](O.Monoid[T]()),
+		Sort[GA, T],
+	)
+}

v2/array/generic/uniq.go

@@ -0,0 +1,32 @@
+package generic
+
+import F "github.com/IBM/fp-go/v2/function"
+
+// StrictUniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined by the built-in uniqueness constraint
+func StrictUniq[AS ~[]A, A comparable](as AS) AS {
+	return Uniq[AS](F.Identity[A])(as)
+}
+
+// uniquePredUnsafe returns a predicate on a map for uniqueness
+func uniquePredUnsafe[PRED ~func(A) K, A any, K comparable](f PRED) func(int, A) bool {
+	lookup := make(map[K]bool)
+	return func(_ int, a A) bool {
+		k := f(a)
+		_, has := lookup[k]
+		if has {
+			return false
+		}
+		lookup[k] = true
+		return true
+	}
+}
+
+// Uniq converts an array of arbitrary items into an array or unique items
+// where uniqueness is determined based on a key extractor function
+func Uniq[AS ~[]A, PRED ~func(A) K, A any, K comparable](f PRED) func(as AS) AS {
+	return func(as AS) AS {
+		// we need to create a new predicate for each iteration
+		return filterWithIndex(as, uniquePredUnsafe(f))
+	}
+}

v2/array/generic/zip.go

@@ -0,0 +1,52 @@
+// 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 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"
+)
+
+// ZipWith applies a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one
+// input array is short, excess elements of the longer array are discarded.
+func ZipWith[AS ~[]A, BS ~[]B, CS ~[]C, FCT ~func(A, B) C, A, B, C any](fa AS, fb BS, f FCT) CS {
+	l := N.Min(len(fa), len(fb))
+	res := make(CS, l)
+	for i := l - 1; i >= 0; i-- {
+		res[i] = f(fa[i], fb[i])
+	}
+	return res
+}
+
+// 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])
+}
+
+// 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] {
+	l := len(cs)
+	as := make(AS, l)
+	bs := make(BS, l)
+	for i := l - 1; i >= 0; i-- {
+		t := cs[i]
+		as[i] = t.F1
+		bs[i] = t.F2
+	}
+	return T.MakeTuple2(as, bs)
+}

v2/array/magma.go

@@ -0,0 +1,40 @@
+// 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 array
+
+import (
+	M "github.com/IBM/fp-go/v2/monoid"
+)
+
+// ConcatAll concatenates all elements of an array using the provided Monoid.
+// This reduces the array to a single value by repeatedly applying the Monoid's concat operation.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/monoid"
+//
+//	// Sum all numbers
+//	sumAll := array.ConcatAll(monoid.MonoidSum[int]())
+//	result := sumAll([]int{1, 2, 3, 4, 5}) // 15
+//
+//	// Concatenate all strings
+//	concatStrings := array.ConcatAll(monoid.MonoidString())
+//	result2 := concatStrings([]string{"Hello", " ", "World"}) // "Hello World"
+//
+//go:inline
+func ConcatAll[A any](m M.Monoid[A]) func([]A) A {
+	return Reduce(m.Concat, m.Empty())
+}

v2/array/magma_test.go

@@ -0,0 +1,36 @@
+// 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 array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	M "github.com/IBM/fp-go/v2/monoid"
+)
+
+var subInt = M.MakeMonoid(func(first int, second int) int {
+	return first - second
+}, 0)
+
+func TestConcatAll(t *testing.T) {
+
+	var subAll = ConcatAll(subInt)
+
+	assert.Equal(t, subAll([]int{1, 2, 3}), -6)
+
+}

v2/array/misc_test.go

@@ -0,0 +1,161 @@
+// 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 array
+
+import (
+	"testing"
+
+	O "github.com/IBM/fp-go/v2/option"
+	OR "github.com/IBM/fp-go/v2/ord"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAnyWithIndex(t *testing.T) {
+	src := []int{1, 2, 3, 4, 5}
+	checker := AnyWithIndex(func(i, x int) bool {
+		return i == 2 && x == 3
+	})
+	assert.True(t, checker(src))
+
+	checker2 := AnyWithIndex(func(i, x int) bool {
+		return i == 10
+	})
+	assert.False(t, checker2(src))
+}
+
+func TestSemigroup(t *testing.T) {
+	sg := Semigroup[int]()
+	result := sg.Concat([]int{1, 2}, []int{3, 4})
+	assert.Equal(t, []int{1, 2, 3, 4}, result)
+}
+
+func TestArrayConcatAll(t *testing.T) {
+	result := ArrayConcatAll(
+		[]int{1, 2},
+		[]int{3, 4},
+		[]int{5, 6},
+	)
+	assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, result)
+
+	// Test with empty arrays
+	result2 := ArrayConcatAll(
+		[]int{},
+		[]int{1},
+		[]int{},
+	)
+	assert.Equal(t, []int{1}, result2)
+}
+
+func TestMonad(t *testing.T) {
+	m := Monad[int, string]()
+
+	// Test Map
+	mapFn := m.Map(func(x int) string {
+		return string(rune('a' + x - 1))
+	})
+	mapped := mapFn([]int{1, 2, 3})
+	assert.Equal(t, []string{"a", "b", "c"}, mapped)
+
+	// Test Chain
+	chainFn := m.Chain(func(x int) []string {
+		return []string{string(rune('a' + x - 1))}
+	})
+	chained := chainFn([]int{1, 2})
+	assert.Equal(t, []string{"a", "b"}, chained)
+
+	// Test Of
+	ofResult := m.Of(42)
+	assert.Equal(t, []int{42}, ofResult)
+}
+
+func TestSortByKey(t *testing.T) {
+	type Person struct {
+		Name string
+		Age  int
+	}
+
+	people := []Person{
+		{"Alice", 30},
+		{"Bob", 25},
+		{"Charlie", 35},
+	}
+
+	sorter := SortByKey(OR.FromStrictCompare[int](), func(p Person) int {
+		return p.Age
+	})
+	result := sorter(people)
+
+	assert.Equal(t, "Bob", result[0].Name)
+	assert.Equal(t, "Alice", result[1].Name)
+	assert.Equal(t, "Charlie", result[2].Name)
+}
+
+func TestMonadTraverse(t *testing.T) {
+	result := MonadTraverse(
+		O.Of[[]int],
+		O.Map[[]int, func(int) []int],
+		O.Ap[[]int, int],
+		[]int{1, 3, 5},
+		func(n int) O.Option[int] {
+			if n%2 == 1 {
+				return O.Some(n * 2)
+			}
+			return O.None[int]()
+		},
+	)
+
+	assert.Equal(t, O.Some([]int{2, 6, 10}), result)
+
+	// Test with None case
+	result2 := MonadTraverse(
+		O.Of[[]int],
+		O.Map[[]int, func(int) []int],
+		O.Ap[[]int, int],
+		[]int{1, 2, 3},
+		func(n int) O.Option[int] {
+			if n%2 == 1 {
+				return O.Some(n * 2)
+			}
+			return O.None[int]()
+		},
+	)
+
+	assert.Equal(t, O.None[[]int](), result2)
+}
+
+func TestUniqByKey(t *testing.T) {
+	type Person struct {
+		Name string
+		Age  int
+	}
+
+	people := []Person{
+		{"Alice", 30},
+		{"Bob", 25},
+		{"Alice", 35},
+		{"Charlie", 30},
+	}
+
+	uniquer := Uniq(func(p Person) string {
+		return p.Name
+	})
+	result := uniquer(people)
+
+	assert.Equal(t, 3, len(result))
+	assert.Equal(t, "Alice", result[0].Name)
+	assert.Equal(t, "Bob", result[1].Name)
+	assert.Equal(t, "Charlie", result[2].Name)
+}

v2/array/monad.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2024 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	"github.com/IBM/fp-go/v2/internal/monad"
+)
+
+// Monad returns the monadic operations for an array.
+// This provides a structured way to access all monad operations (Map, Chain, Ap, Of)
+// for arrays in a single interface.
+//
+// The Monad interface is useful when you need to pass monadic operations as parameters
+// or when working with generic code that operates on any monad.
+//
+// Example:
+//
+//	m := array.Monad[int, string]()
+//	result := m.Chain([]int{1, 2, 3}, func(x int) []string {
+//	    return []string{fmt.Sprintf("%d", x), fmt.Sprintf("%d!", x)}
+//	})
+//	// Result: ["1", "1!", "2", "2!", "3", "3!"]
+//
+//go:inline
+func Monad[A, B any]() monad.Monad[A, B, []A, []B, []func(A) B] {
+	return G.Monad[A, B, []A, []B, []func(A) B]()
+}

v2/array/monoid.go

@@ -0,0 +1,89 @@
+// 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 array
+
+import (
+	"github.com/IBM/fp-go/v2/internal/array"
+	M "github.com/IBM/fp-go/v2/monoid"
+	S "github.com/IBM/fp-go/v2/semigroup"
+)
+
+func concat[T any](left, right []T) []T {
+	// some performance checks
+	ll := len(left)
+	if ll == 0 {
+		return right
+	}
+	lr := len(right)
+	if lr == 0 {
+		return left
+	}
+	// need to copy
+	buf := make([]T, ll+lr)
+	copy(buf[copy(buf, left):], right)
+	return buf
+}
+
+// Monoid returns a Monoid instance for arrays.
+// The Monoid combines arrays through concatenation, with an empty array as the identity element.
+//
+// Example:
+//
+//	m := array.Monoid[int]()
+//	result := m.Concat([]int{1, 2}, []int{3, 4}) // [1, 2, 3, 4]
+//	empty := m.Empty() // []
+func Monoid[T any]() M.Monoid[[]T] {
+	return M.MakeMonoid(concat[T], Empty[T]())
+}
+
+// Semigroup returns a Semigroup instance for arrays.
+// The Semigroup combines arrays through concatenation.
+//
+// Example:
+//
+//	s := array.Semigroup[int]()
+//	result := s.Concat([]int{1, 2}, []int{3, 4}) // [1, 2, 3, 4]
+func Semigroup[T any]() S.Semigroup[[]T] {
+	return S.MakeSemigroup(concat[T])
+}
+
+func addLen[A any](count int, data []A) int {
+	return count + len(data)
+}
+
+// ArrayConcatAll efficiently concatenates multiple arrays into a single array.
+// This function pre-allocates the exact amount of memory needed and performs
+// a single copy operation for each input array, making it more efficient than
+// repeated concatenations.
+//
+// Example:
+//
+//	result := array.ArrayConcatAll(
+//	    []int{1, 2},
+//	    []int{3, 4},
+//	    []int{5, 6},
+//	) // [1, 2, 3, 4, 5, 6]
+func ArrayConcatAll[A any](data ...[]A) []A {
+	// get the full size
+	count := array.Reduce(data, addLen[A], 0)
+	buf := make([]A, count)
+	// copy
+	array.Reduce(data, func(idx int, seg []A) int {
+		return idx + copy(buf[idx:], seg)
+	}, 0)
+	// returns the final array
+	return buf
+}

v2/array/monoid_test.go

@@ -0,0 +1,26 @@
+// 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 array
+
+import (
+	"testing"
+
+	M "github.com/IBM/fp-go/v2/monoid/testing"
+)
+
+func TestMonoid(t *testing.T) {
+	M.AssertLaws(t, Monoid[int]())([][]int{{}, {1}, {1, 2}})
+}

v2/array/nonempty/array.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2023 - 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package nonempty
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	EM "github.com/IBM/fp-go/v2/endomorphism"
+	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	S "github.com/IBM/fp-go/v2/semigroup"
+)
+
+// NonEmptyArray represents an array with at least one element
+type NonEmptyArray[A any] []A
+
+// Of constructs a single element array
+func Of[A any](first A) NonEmptyArray[A] {
+	return G.Of[NonEmptyArray[A]](first)
+}
+
+// From constructs a [NonEmptyArray] from a set of variadic arguments
+func From[A any](first A, data ...A) NonEmptyArray[A] {
+	count := len(data)
+	if count == 0 {
+		return Of(first)
+	}
+	// allocate the requested buffer
+	buffer := make(NonEmptyArray[A], count+1)
+	buffer[0] = first
+	copy(buffer[1:], data)
+	return buffer
+}
+
+func IsEmpty[A any](_ NonEmptyArray[A]) bool {
+	return false
+}
+
+func IsNonEmpty[A any](_ NonEmptyArray[A]) bool {
+	return true
+}
+
+func MonadMap[A, B any](as NonEmptyArray[A], f func(a A) B) NonEmptyArray[B] {
+	return G.MonadMap[NonEmptyArray[A], NonEmptyArray[B]](as, f)
+}
+
+func Map[A, B any](f func(a A) B) func(NonEmptyArray[A]) NonEmptyArray[B] {
+	return F.Bind2nd(MonadMap[A, B], f)
+}
+
+func Reduce[A, B any](f func(B, A) B, initial B) func(NonEmptyArray[A]) B {
+	return func(as NonEmptyArray[A]) B {
+		return array.Reduce(as, f, initial)
+	}
+}
+
+func ReduceRight[A, B any](f func(A, B) B, initial B) func(NonEmptyArray[A]) B {
+	return func(as NonEmptyArray[A]) B {
+		return array.ReduceRight(as, f, initial)
+	}
+}
+
+func Tail[A any](as NonEmptyArray[A]) []A {
+	return as[1:]
+}
+
+func Head[A any](as NonEmptyArray[A]) A {
+	return as[0]
+}
+
+func First[A any](as NonEmptyArray[A]) A {
+	return as[0]
+}
+
+func Last[A any](as NonEmptyArray[A]) A {
+	return as[len(as)-1]
+}
+
+func Size[A any](as NonEmptyArray[A]) int {
+	return G.Size(as)
+}
+
+func Flatten[A any](mma NonEmptyArray[NonEmptyArray[A]]) NonEmptyArray[A] {
+	return G.Flatten(mma)
+}
+
+func MonadChain[A, B any](fa NonEmptyArray[A], f func(a A) NonEmptyArray[B]) NonEmptyArray[B] {
+	return G.MonadChain[NonEmptyArray[A], NonEmptyArray[B]](fa, f)
+}
+
+func Chain[A, B any](f func(A) NonEmptyArray[B]) func(NonEmptyArray[A]) NonEmptyArray[B] {
+	return G.Chain[NonEmptyArray[A], NonEmptyArray[B]](f)
+}
+
+func MonadAp[B, A any](fab NonEmptyArray[func(A) B], fa NonEmptyArray[A]) NonEmptyArray[B] {
+	return G.MonadAp[NonEmptyArray[B]](fab, fa)
+}
+
+func Ap[B, A any](fa NonEmptyArray[A]) func(NonEmptyArray[func(A) B]) NonEmptyArray[B] {
+	return G.Ap[NonEmptyArray[B], NonEmptyArray[func(A) B]](fa)
+}
+
+// FoldMap maps and folds a [NonEmptyArray]. Map the [NonEmptyArray] passing each value to the iterating function. Then fold the results using the provided [Semigroup].
+func FoldMap[A, B any](s S.Semigroup[B]) func(func(A) B) func(NonEmptyArray[A]) B {
+	return func(f func(A) B) func(NonEmptyArray[A]) B {
+		return func(as NonEmptyArray[A]) B {
+			return array.Reduce(Tail(as), func(cur B, a A) B {
+				return s.Concat(cur, f(a))
+			}, f(Head(as)))
+		}
+	}
+}
+
+// Fold folds the [NonEmptyArray] using the provided [Semigroup].
+func Fold[A any](s S.Semigroup[A]) func(NonEmptyArray[A]) A {
+	return func(as NonEmptyArray[A]) A {
+		return array.Reduce(Tail(as), s.Concat, Head(as))
+	}
+}
+
+// Prepend prepends a single value to an array
+func Prepend[A any](head A) EM.Endomorphism[NonEmptyArray[A]] {
+	return array.Prepend[EM.Endomorphism[NonEmptyArray[A]]](head)
+}

v2/array/sequence.go

@@ -0,0 +1,95 @@
+// 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 array
+
+import (
+	F "github.com/IBM/fp-go/v2/function"
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+// Sequence takes an array where elements are HKT<A> (higher kinded type) and,
+// using an applicative of that HKT, returns an HKT of []A.
+//
+// For example, it can turn:
+//   - []Either[error, string] into Either[error, []string]
+//   - []Option[int] into Option[[]int]
+//
+// Sequence requires an Applicative of the HKT you are targeting. To turn an
+// []Either[E, A] into an Either[E, []A], it needs an Applicative for Either.
+// To turn an []Option[A] into an Option[[]A], it needs an Applicative for Option.
+//
+// Note: We need to pass the members of the applicative explicitly because Go does not
+// support higher kinded types or template methods on structs or interfaces.
+//
+// Type parameters:
+//   - HKTA = HKT<A> (e.g., Option[A], Either[E, A])
+//   - HKTRA = HKT<[]A> (e.g., Option[[]A], Either[E, []A])
+//   - HKTFRA = HKT<func(A)[]A> (e.g., Option[func(A)[]A])
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/option"
+//
+//	opts := []option.Option[int]{
+//	    option.Some(1),
+//	    option.Some(2),
+//	    option.Some(3),
+//	}
+//
+//	seq := array.Sequence(
+//	    option.Of[[]int],
+//	    option.MonadMap[[]int, func(int) []int],
+//	    option.MonadAp[[]int, int],
+//	)
+//	result := seq(opts) // Some([1, 2, 3])
+func Sequence[A, HKTA, HKTRA, HKTFRA any](
+	_of func([]A) HKTRA,
+	_map func(HKTRA, func([]A) func(A) []A) HKTFRA,
+	_ap func(HKTFRA, HKTA) HKTRA,
+) func([]HKTA) HKTRA {
+	ca := F.Curry2(Append[A])
+	empty := _of(Empty[A]())
+	return Reduce(func(fas HKTRA, fa HKTA) HKTRA {
+		return _ap(_map(fas, ca), fa)
+	}, empty)
+}
+
+// ArrayOption returns a function to convert a sequence of options into an option of a sequence.
+// If all options are Some, returns Some containing an array of all values.
+// If any option is None, returns None.
+//
+// Example:
+//
+//	opts := []option.Option[int]{
+//	    option.Some(1),
+//	    option.Some(2),
+//	    option.Some(3),
+//	}
+//	result := array.ArrayOption[int]()(opts) // Some([1, 2, 3])
+//
+//	opts2 := []option.Option[int]{
+//	    option.Some(1),
+//	    option.None[int](),
+//	    option.Some(3),
+//	}
+//	result2 := array.ArrayOption[int]()(opts2) // None
+func ArrayOption[A any]() func([]O.Option[A]) O.Option[[]A] {
+	return Sequence(
+		O.Of[[]A],
+		O.MonadMap[[]A, func(A) []A],
+		O.MonadAp[[]A, A],
+	)
+}

v2/array/sequence_test.go

@@ -0,0 +1,31 @@
+// 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 array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	O "github.com/IBM/fp-go/v2/option"
+)
+
+func TestSequenceOption(t *testing.T) {
+	seq := ArrayOption[int]()
+
+	assert.Equal(t, O.Of([]int{1, 3}), seq([]O.Option[int]{O.Of(1), O.Of(3)}))
+	assert.Equal(t, O.None[[]int](), seq([]O.Option[int]{O.Of(1), O.None[int]()}))
+}

v2/array/slice_test.go

@@ -0,0 +1,407 @@
+// 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 array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestSliceBasicCases tests normal slicing operations
+func TestSliceBasicCases(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4, 5}
+
+	t.Run("normal slice from middle", func(t *testing.T) {
+		assert.Equal(t, []int{1, 2, 3}, Slice[int](1, 4)(data))
+	})
+
+	t.Run("slice from start", func(t *testing.T) {
+		assert.Equal(t, []int{0, 1, 2}, Slice[int](0, 3)(data))
+	})
+
+	t.Run("slice to end", func(t *testing.T) {
+		assert.Equal(t, []int{3, 4, 5}, Slice[int](3, 6)(data))
+	})
+
+	t.Run("slice single element", func(t *testing.T) {
+		assert.Equal(t, []int{2}, Slice[int](2, 3)(data))
+	})
+
+	t.Run("slice entire array", func(t *testing.T) {
+		assert.Equal(t, []int{0, 1, 2, 3, 4, 5}, Slice[int](0, 6)(data))
+	})
+}
+
+// TestSliceNegativeIndices tests negative index handling (counting from end)
+func TestSliceNegativeIndices(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4, 5}
+
+	t.Run("negative start index", func(t *testing.T) {
+		// -2 means length + (-2) = 6 - 2 = 4
+		assert.Equal(t, []int{4, 5}, Slice[int](-2, 6)(data))
+	})
+
+	t.Run("negative end index", func(t *testing.T) {
+		// -2 means length + (-2) = 6 - 2 = 4
+		assert.Equal(t, []int{0, 1, 2, 3}, Slice[int](0, -2)(data))
+	})
+
+	t.Run("both negative indices", func(t *testing.T) {
+		// -4 = 2, -2 = 4
+		assert.Equal(t, []int{2, 3}, Slice[int](-4, -2)(data))
+	})
+
+	t.Run("negative index beyond array start", func(t *testing.T) {
+		// -10 would be -4, clamped to 0
+		assert.Equal(t, []int{0, 1, 2}, Slice[int](-10, 3)(data))
+	})
+
+	t.Run("negative end index beyond array start", func(t *testing.T) {
+		// -10 would be -4, clamped to 0
+		assert.Equal(t, []int{}, Slice[int](0, -10)(data))
+	})
+}
+
+// TestSliceEmptyArray tests slicing on empty arrays (totality proof)
+func TestSliceEmptyArray(t *testing.T) {
+	empty := []int{}
+
+	t.Run("slice empty array with zero indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](0, 0)(empty))
+	})
+
+	t.Run("slice empty array with positive indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](0, 5)(empty))
+	})
+
+	t.Run("slice empty array with negative indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](-1, -1)(empty))
+	})
+
+	t.Run("slice empty array with mixed indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](-5, 5)(empty))
+	})
+}
+
+// TestSliceOutOfBounds tests out-of-bounds scenarios (totality proof)
+func TestSliceOutOfBounds(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4}
+
+	t.Run("start index beyond array length", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](10, 15)(data))
+	})
+
+	t.Run("end index beyond array length", func(t *testing.T) {
+		assert.Equal(t, []int{2, 3, 4}, Slice[int](2, 100)(data))
+	})
+
+	t.Run("both indices beyond array length", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](10, 20)(data))
+	})
+
+	t.Run("start equals array length", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](5, 10)(data))
+	})
+
+	t.Run("end equals array length", func(t *testing.T) {
+		assert.Equal(t, []int{3, 4}, Slice[int](3, 5)(data))
+	})
+}
+
+// TestSliceInvalidRanges tests invalid range scenarios (totality proof)
+func TestSliceInvalidRanges(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4}
+
+	t.Run("start equals end", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](2, 2)(data))
+	})
+
+	t.Run("start greater than end", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](4, 2)(data))
+	})
+
+	t.Run("start greater than end with negative indices", func(t *testing.T) {
+		// -1 = 4, -3 = 2
+		assert.Equal(t, []int{}, Slice[int](-1, -3)(data))
+	})
+
+	t.Run("zero range at start", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](0, 0)(data))
+	})
+
+	t.Run("zero range at end", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](5, 5)(data))
+	})
+}
+
+// TestSliceEdgeCases tests additional edge cases (totality proof)
+func TestSliceEdgeCases(t *testing.T) {
+	t.Run("single element array - slice all", func(t *testing.T) {
+		data := []int{42}
+		assert.Equal(t, []int{42}, Slice[int](0, 1)(data))
+	})
+
+	t.Run("single element array - slice none", func(t *testing.T) {
+		data := []int{42}
+		assert.Equal(t, []int{}, Slice[int](1, 1)(data))
+	})
+
+	t.Run("single element array - negative indices", func(t *testing.T) {
+		data := []int{42}
+		assert.Equal(t, []int{42}, Slice[int](-1, 1)(data))
+	})
+
+	t.Run("large array slice", func(t *testing.T) {
+		data := MakeBy(1000, func(i int) int { return i })
+		result := Slice[int](100, 200)(data)
+		assert.Equal(t, 100, len(result))
+		assert.Equal(t, 100, result[0])
+		assert.Equal(t, 199, result[99])
+	})
+}
+
+// TestSliceWithDifferentTypes tests that Slice works with different types (totality proof)
+func TestSliceWithDifferentTypes(t *testing.T) {
+	t.Run("string slice", func(t *testing.T) {
+		data := []string{"a", "b", "c", "d", "e"}
+		assert.Equal(t, []string{"b", "c", "d"}, Slice[string](1, 4)(data))
+	})
+
+	t.Run("float slice", func(t *testing.T) {
+		data := []float64{1.1, 2.2, 3.3, 4.4, 5.5}
+		assert.Equal(t, []float64{2.2, 3.3}, Slice[float64](1, 3)(data))
+	})
+
+	t.Run("bool slice", func(t *testing.T) {
+		data := []bool{true, false, true, false}
+		assert.Equal(t, []bool{false, true}, Slice[bool](1, 3)(data))
+	})
+
+	t.Run("struct slice", func(t *testing.T) {
+		type Point struct{ X, Y int }
+		data := []Point{{1, 2}, {3, 4}, {5, 6}}
+		assert.Equal(t, []Point{{3, 4}}, Slice[Point](1, 2)(data))
+	})
+
+	t.Run("pointer slice", func(t *testing.T) {
+		a, b, c := 1, 2, 3
+		data := []*int{&a, &b, &c}
+		result := Slice[*int](1, 3)(data)
+		assert.Equal(t, 2, len(result))
+		assert.Equal(t, 2, *result[0])
+		assert.Equal(t, 3, *result[1])
+	})
+}
+
+// TestSliceNilArray tests behavior with nil arrays (totality proof)
+func TestSliceNilArray(t *testing.T) {
+	var nilArray []int
+
+	t.Run("slice nil array with zero indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](0, 0)(nilArray))
+	})
+
+	t.Run("slice nil array with positive indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](0, 5)(nilArray))
+	})
+
+	t.Run("slice nil array with negative indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](-1, 1)(nilArray))
+	})
+
+	t.Run("slice nil array with out of bounds indices", func(t *testing.T) {
+		assert.Equal(t, []int{}, Slice[int](10, 20)(nilArray))
+	})
+}
+
+// TestSliceComposition tests that Slice can be composed with other functions
+func TestSliceComposition(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	t.Run("compose multiple slices", func(t *testing.T) {
+		// First slice [2:8], then slice [1:4] of result
+		slice1 := Slice[int](2, 8)
+		slice2 := Slice[int](1, 4)
+		result := slice2(slice1(data))
+		// [2,3,4,5,6,7] -> [3,4,5]
+		assert.Equal(t, []int{3, 4, 5}, result)
+	})
+
+	t.Run("slice then map", func(t *testing.T) {
+		sliced := Slice[int](2, 5)(data)
+		mapped := Map(func(x int) int { return x * 2 })(sliced)
+		assert.Equal(t, []int{4, 6, 8}, mapped)
+	})
+
+	t.Run("slice then filter", func(t *testing.T) {
+		sliced := Slice[int](0, 6)(data)
+		filtered := Filter(func(x int) bool { return x%2 == 0 })(sliced)
+		assert.Equal(t, []int{0, 2, 4}, filtered)
+	})
+}
+
+// TestSliceImmutability tests that Slice doesn't modify the original array
+func TestSliceImmutability(t *testing.T) {
+	original := []int{0, 1, 2, 3, 4}
+	originalCopy := []int{0, 1, 2, 3, 4}
+
+	t.Run("slicing doesn't modify original", func(t *testing.T) {
+		result := Slice[int](1, 4)(original)
+		assert.Equal(t, []int{1, 2, 3}, result)
+		assert.Equal(t, originalCopy, original)
+	})
+
+	t.Run("slice shares underlying array with original", func(t *testing.T) {
+		// Note: Go's slice operation creates a view of the underlying array,
+		// not a deep copy. This is expected behavior and matches Go's built-in slice semantics.
+		result := Slice[int](1, 4)(original)
+		result[0] = 999
+		// The original array is affected because slices share the underlying array
+		assert.Equal(t, 999, original[1], "Slices share underlying array (expected Go behavior)")
+	})
+}
+
+// TestSliceTotality is a comprehensive test proving Slice is a total function
+// A total function is defined for all possible inputs and never panics
+func TestSliceTotality(t *testing.T) {
+	testCases := []struct {
+		name  string
+		data  []int
+		low   int
+		high  int
+		panic bool // Should always be false for a total function
+	}{
+		// Normal cases
+		{"normal range", []int{1, 2, 3, 4, 5}, 1, 3, false},
+		{"full range", []int{1, 2, 3}, 0, 3, false},
+		{"empty result", []int{1, 2, 3}, 1, 1, false},
+
+		// Edge cases with empty/nil arrays
+		{"empty array", []int{}, 0, 0, false},
+		{"empty array with indices", []int{}, 1, 5, false},
+		{"nil array", nil, 0, 5, false},
+
+		// Negative indices
+		{"negative low", []int{1, 2, 3, 4, 5}, -2, 5, false},
+		{"negative high", []int{1, 2, 3, 4, 5}, 0, -1, false},
+		{"both negative", []int{1, 2, 3, 4, 5}, -3, -1, false},
+		{"negative beyond bounds", []int{1, 2, 3}, -100, -50, false},
+
+		// Out of bounds
+		{"low beyond length", []int{1, 2, 3}, 10, 20, false},
+		{"high beyond length", []int{1, 2, 3}, 1, 100, false},
+		{"both beyond length", []int{1, 2, 3}, 10, 20, false},
+
+		// Invalid ranges
+		{"low equals high", []int{1, 2, 3}, 2, 2, false},
+		{"low greater than high", []int{1, 2, 3}, 3, 1, false},
+		{"negative invalid range", []int{1, 2, 3, 4, 5}, -1, -3, false},
+
+		// Extreme values
+		{"very large indices", []int{1, 2, 3}, 1000000, 2000000, false},
+		{"very negative indices", []int{1, 2, 3}, -1000000, -500000, false},
+		{"mixed extreme", []int{1, 2, 3}, -1000000, 1000000, false},
+
+		// Zero values
+		{"zero indices", []int{1, 2, 3}, 0, 0, false},
+		{"zero low", []int{1, 2, 3}, 0, 3, false},
+		{"zero high", []int{1, 2, 3}, 0, 0, false},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// This test proves totality by ensuring no panic occurs
+			defer func() {
+				if r := recover(); r != nil {
+					if !tc.panic {
+						t.Errorf("Slice panicked unexpectedly: %v", r)
+					}
+				} else {
+					if tc.panic {
+						t.Errorf("Slice should have panicked but didn't")
+					}
+				}
+			}()
+
+			// Execute the function - if it's total, it will never panic
+			result := Slice[int](tc.low, tc.high)(tc.data)
+
+			// Additional verification: result should always be a valid slice
+			assert.NotNil(t, result, "Result should never be nil")
+			assert.True(t, len(result) >= 0, "Result length should be non-negative")
+		})
+	}
+}
+
+// TestSlicePropertyBased tests mathematical properties of Slice
+func TestSlicePropertyBased(t *testing.T) {
+	data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+	t.Run("identity: Slice(0, len) returns copy of array", func(t *testing.T) {
+		result := Slice[int](0, len(data))(data)
+		assert.Equal(t, data, result)
+	})
+
+	t.Run("empty: Slice(i, i) always returns empty", func(t *testing.T) {
+		for i := 0; i <= len(data); i++ {
+			result := Slice[int](i, i)(data)
+			assert.Equal(t, []int{}, result)
+		}
+	})
+
+	t.Run("length property: len(Slice(i, j)) = max(0, min(j, len) - max(i, 0))", func(t *testing.T) {
+		testCases := []struct{ low, high, expected int }{
+			{0, 5, 5},
+			{2, 7, 5},
+			{5, 5, 0},
+			{3, 2, 0},   // invalid range
+			{-2, 10, 2}, // -2 becomes 8, so slice [8:10] has length 2
+			{0, 100, 10},
+		}
+
+		for _, tc := range testCases {
+			result := Slice[int](tc.low, tc.high)(data)
+			assert.Equal(t, tc.expected, len(result),
+				"Slice(%d, %d) should have length %d", tc.low, tc.high, tc.expected)
+		}
+	})
+
+	t.Run("concatenation: Slice(0,i) + Slice(i,len) = original", func(t *testing.T) {
+		for i := 0; i <= len(data); i++ {
+			left := Slice[int](0, i)(data)
+			right := Slice[int](i, len(data))(data)
+			concatenated := append(left, right...)
+			assert.Equal(t, data, concatenated)
+		}
+	})
+
+	t.Run("subset property: all elements in slice are in original", func(t *testing.T) {
+		result := Slice[int](2, 7)(data)
+		for _, elem := range result {
+			found := false
+			for _, orig := range data {
+				if elem == orig {
+					found = true
+					break
+				}
+			}
+			assert.True(t, found, "Element %d should be in original array", elem)
+		}
+	})
+}
+
+// Made with Bob

v2/array/sort.go

@@ -0,0 +1,98 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	O "github.com/IBM/fp-go/v2/ord"
+)
+
+// Sort implements a stable sort on the array given the provided ordering.
+// The sort is stable, meaning that elements that compare equal retain their original order.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/ord"
+//
+//	numbers := []int{3, 1, 4, 1, 5, 9, 2, 6}
+//	sorted := array.Sort(ord.FromStrictCompare[int]())(numbers)
+//	// Result: [1, 1, 2, 3, 4, 5, 6, 9]
+//
+//go:inline
+func Sort[T any](ord O.Ord[T]) func(ma []T) []T {
+	return G.Sort[[]T](ord)
+}
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key.
+// This is useful when you want to sort complex types by a specific field.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/ord"
+//
+//	type Person struct {
+//	    Name string
+//	    Age  int
+//	}
+//
+//	people := []Person{
+//	    {"Alice", 30},
+//	    {"Bob", 25},
+//	    {"Charlie", 35},
+//	}
+//
+//	sortByAge := array.SortByKey(
+//	    ord.FromStrictCompare[int](),
+//	    func(p Person) int { return p.Age },
+//	)
+//	sorted := sortByAge(people)
+//	// Result: [{"Bob", 25}, {"Alice", 30}, {"Charlie", 35}]
+//
+//go:inline
+func SortByKey[K, T any](ord O.Ord[K], f func(T) K) func(ma []T) []T {
+	return G.SortByKey[[]T](ord, f)
+}
+
+// SortBy implements a stable sort on the array using multiple ordering criteria.
+// The orderings are applied in sequence: if two elements are equal according to the first
+// ordering, the second ordering is used, and so on.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/ord"
+//
+//	type Person struct {
+//	    LastName  string
+//	    FirstName string
+//	}
+//
+//	people := []Person{
+//	    {"Smith", "John"},
+//	    {"Smith", "Alice"},
+//	    {"Jones", "Bob"},
+//	}
+//
+//	sortByName := array.SortBy([]ord.Ord[Person]{
+//	    ord.Contramap(func(p Person) string { return p.LastName })(ord.FromStrictCompare[string]()),
+//	    ord.Contramap(func(p Person) string { return p.FirstName })(ord.FromStrictCompare[string]()),
+//	})
+//	sorted := sortByName(people)
+//	// Result: [{"Jones", "Bob"}, {"Smith", "Alice"}, {"Smith", "John"}]
+//
+//go:inline
+func SortBy[T any](ord []O.Ord[T]) func(ma []T) []T {
+	return G.SortBy[[]T, []O.Ord[T]](ord)
+}

v2/array/sort_test.go

@@ -0,0 +1,36 @@
+// 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 array
+
+import (
+	"testing"
+
+	O "github.com/IBM/fp-go/v2/ord"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSort(t *testing.T) {
+
+	ordInt := O.FromStrictCompare[int]()
+
+	input := []int{2, 1, 3}
+
+	res := Sort(ordInt)(input)
+
+	assert.Equal(t, []int{1, 2, 3}, res)
+	assert.Equal(t, []int{2, 1, 3}, input)
+
+}

v2/array/testing/laws.go

@@ -0,0 +1,74 @@
+// 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 testing
+
+import (
+	"testing"
+
+	RA "github.com/IBM/fp-go/v2/array"
+	EQ "github.com/IBM/fp-go/v2/eq"
+	L "github.com/IBM/fp-go/v2/internal/monad/testing"
+)
+
+// AssertLaws asserts the apply monad laws for the array monad
+func AssertLaws[A, B, C any](t *testing.T,
+	eqa EQ.Eq[A],
+	eqb EQ.Eq[B],
+	eqc EQ.Eq[C],
+
+	ab func(A) B,
+	bc func(B) C,
+) func(a A) bool {
+
+	return L.AssertLaws(t,
+		RA.Eq(eqa),
+		RA.Eq(eqb),
+		RA.Eq(eqc),
+
+		RA.Of[A],
+		RA.Of[B],
+		RA.Of[C],
+
+		RA.Of[func(A) A],
+		RA.Of[func(A) B],
+		RA.Of[func(B) C],
+		RA.Of[func(func(A) B) B],
+
+		RA.MonadMap[A, A],
+		RA.MonadMap[A, B],
+		RA.MonadMap[A, C],
+		RA.MonadMap[B, C],
+
+		RA.MonadMap[func(B) C, func(func(A) B) func(A) C],
+
+		RA.MonadChain[A, A],
+		RA.MonadChain[A, B],
+		RA.MonadChain[A, C],
+		RA.MonadChain[B, C],
+
+		RA.MonadAp[A, A],
+		RA.MonadAp[B, A],
+		RA.MonadAp[C, B],
+		RA.MonadAp[C, A],
+
+		RA.MonadAp[B, func(A) B],
+		RA.MonadAp[func(A) C, func(A) B],
+
+		ab,
+		bc,
+	)
+
+}

v2/array/testing/laws_test.go

@@ -0,0 +1,47 @@
+// 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 testing
+
+import (
+	"fmt"
+	"testing"
+
+	EQ "github.com/IBM/fp-go/v2/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMonadLaws(t *testing.T) {
+	// some comparison
+	eqa := EQ.FromStrictEquals[bool]()
+	eqb := EQ.FromStrictEquals[int]()
+	eqc := EQ.FromStrictEquals[string]()
+
+	ab := func(a bool) int {
+		if a {
+			return 1
+		}
+		return 0
+	}
+
+	bc := func(b int) string {
+		return fmt.Sprintf("value %d", b)
+	}
+
+	laws := AssertLaws(t, eqa, eqb, eqc, ab, bc)
+
+	assert.True(t, laws(true))
+	assert.True(t, laws(false))
+}

v2/array/traverse.go

@@ -0,0 +1,82 @@
+// 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 array
+
+import (
+	"github.com/IBM/fp-go/v2/internal/array"
+)
+
+// Traverse maps each element of an array to an effect (HKT), then collects the results
+// into an effect of an array. This is like a combination of Map and Sequence.
+//
+// Unlike Sequence which works with []HKT<A> -> HKT<[]A>, Traverse works with
+// []A -> (A -> HKT<B>) -> HKT<[]B>, allowing you to transform elements while sequencing effects.
+//
+// Type parameters:
+//   - HKTB = HKT<B> (e.g., Option[B], Either[E, B])
+//   - HKTAB = HKT<func(B)[]B> (intermediate type for applicative)
+//   - HKTRB = HKT<[]B> (e.g., Option[[]B], Either[E, []B])
+//
+// Example:
+//
+//	import (
+//	    "github.com/IBM/fp-go/v2/option"
+//	    "strconv"
+//	)
+//
+//	// Parse strings to ints, returning None if any parse fails
+//	parseAll := array.Traverse(
+//	    option.Of[[]int],
+//	    option.Map[[]int, func(int) []int],
+//	    option.Ap[[]int, int],
+//	    func(s string) option.Option[int] {
+//	        if n, err := strconv.Atoi(s); err == nil {
+//	            return option.Some(n)
+//	        }
+//	        return option.None[int]()
+//	    },
+//	)
+//
+//	result := parseAll([]string{"1", "2", "3"}) // Some([1, 2, 3])
+//	result2 := parseAll([]string{"1", "x", "3"}) // None
+//
+//go:inline
+func Traverse[A, B, HKTB, HKTAB, HKTRB any](
+	fof func([]B) HKTRB,
+	fmap func(func([]B) func(B) []B) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	f func(A) HKTB) func([]A) HKTRB {
+	return array.Traverse[[]A](fof, fmap, fap, f)
+}
+
+// MonadTraverse is the monadic version of Traverse that takes the array as a parameter.
+// It maps each element of an array to an effect (HKT), then collects the results
+// into an effect of an array.
+//
+// This is useful when you want to apply the traverse operation directly without currying.
+//
+//go:inline
+func MonadTraverse[A, B, HKTB, HKTAB, HKTRB any](
+	fof func([]B) HKTRB,
+	fmap func(func([]B) func(B) []B) func(HKTRB) HKTAB,
+	fap func(HKTB) func(HKTAB) HKTRB,
+
+	ta []A,
+	f func(A) HKTB) HKTRB {
+
+	return array.MonadTraverse(fof, fmap, fap, ta, f)
+}

v2/array/traverse_test.go

@@ -0,0 +1,43 @@
+// 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 array
+
+import (
+	"testing"
+
+	O "github.com/IBM/fp-go/v2/option"
+	"github.com/stretchr/testify/assert"
+)
+
+type ArrayType = []int
+
+func TestTraverse(t *testing.T) {
+
+	traverse := Traverse(
+		O.Of[ArrayType],
+		O.Map[ArrayType, func(int) ArrayType],
+		O.Ap[ArrayType, int],
+
+		func(n int) O.Option[int] {
+			if n%2 == 0 {
+				return O.None[int]()
+			}
+			return O.Of(n)
+		})
+
+	assert.Equal(t, O.None[[]int](), traverse(ArrayType{1, 2}))
+	assert.Equal(t, O.Of(ArrayType{1, 3}), traverse(ArrayType{1, 3}))
+}

v2/array/uniq.go

@@ -0,0 +1,51 @@
+package array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+)
+
+// StrictUniq converts an array of arbitrary items into an array of unique items
+// where uniqueness is determined by the built-in equality constraint (comparable).
+// The first occurrence of each unique value is kept, subsequent duplicates are removed.
+//
+// Example:
+//
+//	numbers := []int{1, 2, 2, 3, 3, 3, 4}
+//	unique := array.StrictUniq(numbers) // [1, 2, 3, 4]
+//
+//	strings := []string{"a", "b", "a", "c", "b"}
+//	unique2 := array.StrictUniq(strings) // ["a", "b", "c"]
+//
+//go:inline
+func StrictUniq[A comparable](as []A) []A {
+	return G.StrictUniq[[]A](as)
+}
+
+// Uniq converts an array of arbitrary items into an array of unique items
+// where uniqueness is determined based on a key extractor function.
+// The first occurrence of each unique key is kept, subsequent duplicates are removed.
+//
+// This is useful for removing duplicates from arrays of complex types based on a specific field.
+//
+// Example:
+//
+//	type Person struct {
+//	    Name string
+//	    Age  int
+//	}
+//
+//	people := []Person{
+//	    {"Alice", 30},
+//	    {"Bob", 25},
+//	    {"Alice", 35}, // duplicate name
+//	    {"Charlie", 30},
+//	}
+//
+//	uniqueByName := array.Uniq(func(p Person) string { return p.Name })
+//	result := uniqueByName(people)
+//	// Result: [{"Alice", 30}, {"Bob", 25}, {"Charlie", 30}]
+//
+//go:inline
+func Uniq[A any, K comparable](f func(A) K) func(as []A) []A {
+	return G.Uniq[[]A](f)
+}

v2/array/uniq_test.go

@@ -0,0 +1,14 @@
+package array
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUniq(t *testing.T) {
+	data := From(1, 2, 3, 2, 4, 1)
+
+	uniq := StrictUniq(data)
+	assert.Equal(t, From(1, 2, 3, 4), uniq)
+}

v2/array/zip.go

@@ -0,0 +1,83 @@
+// 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 array
+
+import (
+	G "github.com/IBM/fp-go/v2/array/generic"
+	T "github.com/IBM/fp-go/v2/tuple"
+)
+
+// ZipWith applies a function to pairs of elements at the same index in two arrays,
+// collecting the results in a new array. If one input array is shorter, excess elements
+// of the longer array are discarded.
+//
+// Example:
+//
+//	names := []string{"Alice", "Bob", "Charlie"}
+//	ages := []int{30, 25, 35}
+//
+//	result := array.ZipWith(names, ages, func(name string, age int) string {
+//	    return fmt.Sprintf("%s is %d years old", name, age)
+//	})
+//	// Result: ["Alice is 30 years old", "Bob is 25 years old", "Charlie is 35 years old"]
+//
+//go:inline
+func ZipWith[FCT ~func(A, B) C, A, B, C any](fa []A, fb []B, f FCT) []C {
+	return G.ZipWith[[]A, []B, []C, FCT](fa, fb, f)
+}
+
+// Zip takes two arrays and returns an array of corresponding pairs (tuples).
+// If one input array is shorter, excess elements of the longer array are discarded.
+//
+// Example:
+//
+//	names := []string{"Alice", "Bob", "Charlie"}
+//	ages := []int{30, 25, 35}
+//
+//	pairs := array.Zip(ages)(names)
+//	// Result: [(Alice, 30), (Bob, 25), (Charlie, 35)]
+//
+//	// With different lengths
+//	pairs2 := array.Zip([]int{1, 2})([]string{"a", "b", "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)
+}
+
+// Unzip is the reverse of Zip. It takes an array of pairs (tuples) and returns
+// two corresponding arrays, one containing all first elements and one containing all second elements.
+//
+// Example:
+//
+//	import "github.com/IBM/fp-go/v2/tuple"
+//
+//	pairs := []tuple.Tuple2[string, int]{
+//	    tuple.MakeTuple2("Alice", 30),
+//	    tuple.MakeTuple2("Bob", 25),
+//	    tuple.MakeTuple2("Charlie", 35),
+//	}
+//
+//	result := array.Unzip(pairs)
+//	// Result: (["Alice", "Bob", "Charlie"], [30, 25, 35])
+//	names := result.Head  // ["Alice", "Bob", "Charlie"]
+//	ages := result.Tail   // [30, 25, 35]
+//
+//go:inline
+func Unzip[A, B any](cs []T.Tuple2[A, B]) T.Tuple2[[]A, []B] {
+	return G.Unzip[[]A, []B, []T.Tuple2[A, B]](cs)
+}

v2/array/zip_test.go

@@ -0,0 +1,56 @@
+// 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 array
+
+import (
+	"fmt"
+	"testing"
+
+	T "github.com/IBM/fp-go/v2/tuple"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestZipWith(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c", "d")
+
+	res := ZipWith(left, right, func(l int, r string) string {
+		return fmt.Sprintf("%s%d", r, l)
+	})
+
+	assert.Equal(t, From("a1", "b2", "c3"), res)
+}
+
+func TestZip(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c", "d")
+
+	res := Zip[string](left)(right)
+
+	assert.Equal(t, From(T.MakeTuple2("a", 1), T.MakeTuple2("b", 2), T.MakeTuple2("c", 3)), res)
+}
+
+func TestUnzip(t *testing.T) {
+	left := From(1, 2, 3)
+	right := From("a", "b", "c")
+
+	zipped := Zip[string](left)(right)
+
+	unzipped := Unzip(zipped)
+
+	assert.Equal(t, right, unzipped.F1)
+	assert.Equal(t, left, unzipped.F2)
+}

v2/assert/assert_test.go

@@ -0,0 +1,109 @@
+// 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 assert
+
+import (
+	"fmt"
+	"testing"
+
+	E "github.com/IBM/fp-go/v2/either"
+	EQ "github.com/IBM/fp-go/v2/eq"
+	"github.com/stretchr/testify/assert"
+)
+
+var (
+	errTest = fmt.Errorf("test failure")
+
+	// Eq is the equal predicate checking if objects are equal
+	Eq = EQ.FromEquals(assert.ObjectsAreEqual)
+)
+
+func wrap1[T any](wrapped func(t assert.TestingT, expected, actual any, msgAndArgs ...any) bool, t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return func(actual T) E.Either[error, T] {
+		ok := wrapped(t, expected, actual)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[T](errTest)
+	}
+}
+
+// NotEqual tests if the expected and the actual values are not equal
+func NotEqual[T any](t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return wrap1(assert.NotEqual, t, expected)
+}
+
+// Equal tests if the expected and the actual values are equal
+func Equal[T any](t *testing.T, expected T) func(actual T) E.Either[error, T] {
+	return wrap1(assert.Equal, t, expected)
+}
+
+// Length tests if an array has the expected length
+func Length[T any](t *testing.T, expected int) func(actual []T) E.Either[error, []T] {
+	return func(actual []T) E.Either[error, []T] {
+		ok := assert.Len(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[[]T](errTest)
+	}
+}
+
+// NoError validates that there is no error
+func NoError[T any](t *testing.T) func(actual E.Either[error, T]) E.Either[error, T] {
+	return func(actual E.Either[error, T]) E.Either[error, T] {
+		return E.MonadFold(actual, func(e error) E.Either[error, T] {
+			assert.NoError(t, e)
+			return E.Left[T](e)
+		}, func(value T) E.Either[error, T] {
+			assert.NoError(t, nil)
+			return E.Right[error](value)
+		})
+	}
+}
+
+// ArrayContains tests if a value is contained in an array
+func ArrayContains[T any](t *testing.T, expected T) func(actual []T) E.Either[error, []T] {
+	return func(actual []T) E.Either[error, []T] {
+		ok := assert.Contains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[[]T](errTest)
+	}
+}
+
+// ContainsKey tests if a key is contained in a map
+func ContainsKey[T any, K comparable](t *testing.T, expected K) func(actual map[K]T) E.Either[error, map[K]T] {
+	return func(actual map[K]T) E.Either[error, map[K]T] {
+		ok := assert.Contains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[map[K]T](errTest)
+	}
+}
+
+// NotContainsKey tests if a key is not contained in a map
+func NotContainsKey[T any, K comparable](t *testing.T, expected K) func(actual map[K]T) E.Either[error, map[K]T] {
+	return func(actual map[K]T) E.Either[error, map[K]T] {
+		ok := assert.NotContains(t, actual, expected)
+		if ok {
+			return E.Of[error](actual)
+		}
+		return E.Left[map[K]T](errTest)
+	}
+}

v2/boolean/boolean.go

@@ -0,0 +1,59 @@
+// 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 boolean
+
+import (
+	"github.com/IBM/fp-go/v2/eq"
+	"github.com/IBM/fp-go/v2/monoid"
+	"github.com/IBM/fp-go/v2/ord"
+)
+
+var (
+	// MonoidAny is the boolean [monoid.Monoid] under disjunction
+	MonoidAny = monoid.MakeMonoid(
+		func(l, r bool) bool {
+			return l || r
+		},
+		false,
+	)
+
+	// MonoidAll is the boolean [monoid.Monoid] under conjuction
+	MonoidAll = monoid.MakeMonoid(
+		func(l, r bool) bool {
+			return l && r
+		},
+		true,
+	)
+
+	// Eq is the equals predicate for boolean
+	Eq = eq.FromStrictEquals[bool]()
+
+	// Ord is the strict ordering for boolean
+	Ord = ord.MakeOrd(func(l, r bool) int {
+		if l {
+			if r {
+				return 0
+			}
+			return +1
+		}
+		if r {
+			return -1
+		}
+		return 0
+	}, func(l, r bool) bool {
+		return l == r
+	})
+)