From 4d008e636aeddd34256e748d828fc5fd21443f98 Mon Sep 17 00:00:00 2001
From: "Dr. Carsten Leue" <carsten.leue@de.ibm.com>
Date: Tue, 4 Mar 2025 21:59:09 +0100
Subject: [PATCH] fix: next step in migration

Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
---
 v2/array/traverse.go                          |   4 +-
 v2/context/readerioeither/cancel.go           |  12 +-
 v2/context/readerioeither/file/file.go        |   4 +-
 v2/context/readerioeither/generic/resource.go |  40 -
 v2/context/readerioeither/generic/sync.go     |  44 -
 v2/context/readerioeither/resource.go         |  11 +-
 v2/context/readerioeither/sync.go             |  11 +-
 v2/context/readerioeither/type.go             |   2 +-
 v2/io/generic/bind.go                         | 101 ---
 v2/io/io.go                                   |   2 +-
 v2/ioeither/ap.go                             |  36 +-
 v2/ioeither/bind.go                           |  47 +-
 v2/ioeither/bracket.go                        |   9 +-
 v2/ioeither/eq.go                             |   6 +-
 v2/ioeither/examples_do_test.go               |   6 +-
 v2/ioeither/examples_extract_test.go          |   4 +-
 v2/ioeither/exec/exec.go                      |   4 +-
 v2/ioeither/file/tempfile.go                  |   4 +-
 v2/ioeither/generic/ap.go                     |  63 --
 v2/ioeither/generic/bind.go                   |  90 --
 v2/ioeither/generic/gen.go                    | 840 +++++++++---------
 v2/ioeither/generic/traverse.go               | 293 ------
 v2/ioeither/generic/types.go                  |  22 +
 v2/ioeither/http/builder/builder.go           |   8 +-
 v2/ioeither/http/builder/builder_test.go      |   6 +-
 v2/ioeither/http/builder/types.go             |  22 +
 v2/ioeither/ioeither.go                       | 105 +--
 v2/ioeither/retry.go                          |   3 +-
 v2/ioeither/sync.go                           |   5 +-
 v2/ioeither/traverse.go                       | 112 ++-
 v2/lazy/bind.go                               |  14 +-
 v2/readerio/reader.go                         |   2 +-
 v2/readerioeither/array_test.go               |   8 +-
 v2/readerioeither/bracket.go                  |   4 +-
 v2/readerioeither/eq.go                       |   4 +-
 v2/readerioeither/generic/bind.go             |  14 +-
 v2/readerioeither/generic/bracket.go          |  16 +-
 v2/readerioeither/generic/eq.go               |   8 +-
 v2/readerioeither/generic/gen.go              |  24 +-
 v2/readerioeither/generic/monad.go            |  14 +-
 v2/readerioeither/generic/reader.go           | 214 ++---
 v2/readerioeither/generic/resource.go         |  48 -
 v2/readerioeither/generic/sequence.go         |  48 +-
 v2/readerioeither/generic/sync.go             |   4 +-
 v2/readerioeither/generic/traverse.go         |  42 +-
 v2/readerioeither/reader.go                   | 122 ++-
 v2/readerioeither/reader_test.go              |   6 +-
 v2/readerioeither/resource.go                 |  20 +-
 v2/readerioeither/sequence_test.go            |   4 +-
 49 files changed, 1039 insertions(+), 1493 deletions(-)
 delete mode 100644 v2/context/readerioeither/generic/resource.go
 delete mode 100644 v2/context/readerioeither/generic/sync.go
 delete mode 100644 v2/io/generic/bind.go
 delete mode 100644 v2/ioeither/generic/ap.go
 delete mode 100644 v2/ioeither/generic/bind.go
 delete mode 100644 v2/ioeither/generic/traverse.go
 create mode 100644 v2/ioeither/generic/types.go
 create mode 100644 v2/ioeither/http/builder/types.go
 delete mode 100644 v2/readerioeither/generic/resource.go

diff --git a/v2/array/traverse.go b/v2/array/traverse.go
index 5f3dfaa..48eeaae 100644
--- a/v2/array/traverse.go
+++ b/v2/array/traverse.go
@@ -15,7 +15,9 @@
 
 package array
 
-import "github.com/IBM/fp-go/v2/internal/array"
+import (
+	"github.com/IBM/fp-go/v2/internal/array"
+)
 
 func Traverse[A, B, HKTB, HKTAB, HKTRB any](
 	fof func([]B) HKTRB,
diff --git a/v2/context/readerioeither/cancel.go b/v2/context/readerioeither/cancel.go
index e1af8b4..9100985 100644
--- a/v2/context/readerioeither/cancel.go
+++ b/v2/context/readerioeither/cancel.go
@@ -16,10 +16,18 @@
 package readerioeither
 
 import (
-	G "github.com/IBM/fp-go/v2/context/readerioeither/generic"
+	"context"
+
+	CIOE "github.com/IBM/fp-go/v2/context/ioeither/generic"
+	"github.com/IBM/fp-go/v2/ioeither"
 )
 
 // WithContext wraps an existing [ReaderIOEither] and performs a context check for cancellation before delegating
 func WithContext[A any](ma ReaderIOEither[A]) ReaderIOEither[A] {
-	return G.WithContext(ma)
+	return func(ctx context.Context) ioeither.IOEither[error, A] {
+		if err := context.Cause(ctx); err != nil {
+			return ioeither.Left[A](err)
+		}
+		return CIOE.WithContext(ctx, ma(ctx))
+	}
 }
diff --git a/v2/context/readerioeither/file/file.go b/v2/context/readerioeither/file/file.go
index 6713ca2..e7623c7 100644
--- a/v2/context/readerioeither/file/file.go
+++ b/v2/context/readerioeither/file/file.go
@@ -56,9 +56,9 @@ func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
 func ReadFile(path string) RIOE.ReaderIOEither[[]byte] {
 	return RIOE.WithResource[[]byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
 		return func(ctx context.Context) IOE.IOEither[error, []byte] {
-			return IOE.MakeIO(func() ET.Either[error, []byte] {
+			return func() ET.Either[error, []byte] {
 				return file.ReadAll(ctx, r)
-			})
+			}
 		}
 	})
 }
diff --git a/v2/context/readerioeither/generic/resource.go b/v2/context/readerioeither/generic/resource.go
deleted file mode 100644
index de34b67..0000000
--- a/v2/context/readerioeither/generic/resource.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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 generic
-
-import (
-	"context"
-
-	E "github.com/IBM/fp-go/v2/either"
-	F "github.com/IBM/fp-go/v2/function"
-	RIE "github.com/IBM/fp-go/v2/readerioeither/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GRA ~func(context.Context) GIOA,
-	GRR ~func(context.Context) GIOR,
-	GRANY ~func(context.Context) GIOANY,
-	GIOR ~func() E.Either[error, R],
-	GIOA ~func() E.Either[error, A],
-	GIOANY ~func() E.Either[error, ANY],
-	R, A, ANY any](onCreate GRR, onRelease func(R) GRANY) func(func(R) GRA) GRA {
-	// wraps the callback functions with a context check
-	return F.Flow2(
-		F.Bind2nd(F.Flow2[func(R) GRA, func(GRA) GRA, R, GRA, GRA], WithContext[GRA]),
-		RIE.WithResource[GRA](WithContext(onCreate), onRelease),
-	)
-}
diff --git a/v2/context/readerioeither/generic/sync.go b/v2/context/readerioeither/generic/sync.go
deleted file mode 100644
index 5c75703..0000000
--- a/v2/context/readerioeither/generic/sync.go
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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 generic
-
-import (
-	"context"
-
-	E "github.com/IBM/fp-go/v2/either"
-	F "github.com/IBM/fp-go/v2/function"
-	IO "github.com/IBM/fp-go/v2/io/generic"
-)
-
-// WithLock executes the provided IO operation in the scope of a lock
-func WithLock[
-	GRA ~func(context.Context) GIOA,
-	GIOA ~func() E.Either[error, A],
-	GRCANCEL ~func(context.Context) GIOCANCEL,
-	GIOCANCEL ~func() E.Either[error, context.CancelFunc],
-	A any](lock GRCANCEL) func(fa GRA) GRA {
-
-	type GRANY func(ctx context.Context) func() E.Either[error, any]
-	type IOANY func() any
-
-	return F.Flow2(
-		F.Constant1[context.CancelFunc, GRA],
-		WithResource[GRA, GRCANCEL, GRANY](lock, F.Flow2(
-			IO.FromImpure[IOANY, context.CancelFunc],
-			FromIO[GRANY, IOANY],
-		)),
-	)
-}
diff --git a/v2/context/readerioeither/resource.go b/v2/context/readerioeither/resource.go
index 4dacf38..5ba3a9f 100644
--- a/v2/context/readerioeither/resource.go
+++ b/v2/context/readerioeither/resource.go
@@ -16,11 +16,16 @@
 package readerioeither
 
 import (
-	G "github.com/IBM/fp-go/v2/context/readerioeither/generic"
+	"context"
+
+	"github.com/IBM/fp-go/v2/function"
+	RIE "github.com/IBM/fp-go/v2/readerioeither"
 )
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
 func WithResource[A, R, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) func(func(R) ReaderIOEither[A]) ReaderIOEither[A] {
-	// wraps the callback functions with a context check
-	return G.WithResource[ReaderIOEither[A]](onCreate, onRelease)
+	return function.Flow2(
+		function.Bind2nd(function.Flow2[func(R) ReaderIOEither[A], func(ReaderIOEither[A]) ReaderIOEither[A], R, ReaderIOEither[A], ReaderIOEither[A]], WithContext[A]),
+		RIE.WithResource[A, context.Context, error, R](WithContext(onCreate), onRelease),
+	)
 }
diff --git a/v2/context/readerioeither/sync.go b/v2/context/readerioeither/sync.go
index 73d0229..9c0ea38 100644
--- a/v2/context/readerioeither/sync.go
+++ b/v2/context/readerioeither/sync.go
@@ -18,10 +18,17 @@ package readerioeither
 import (
 	"context"
 
-	G "github.com/IBM/fp-go/v2/context/readerioeither/generic"
+	"github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/io"
 )
 
 // WithLock executes the provided IO operation in the scope of a lock
 func WithLock[A any](lock ReaderIOEither[context.CancelFunc]) func(fa ReaderIOEither[A]) ReaderIOEither[A] {
-	return G.WithLock[ReaderIOEither[A]](lock)
+	return function.Flow2(
+		function.Constant1[context.CancelFunc, ReaderIOEither[A]],
+		WithResource[A](lock, function.Flow2(
+			io.FromImpure[context.CancelFunc],
+			FromIO[any],
+		)),
+	)
 }
diff --git a/v2/context/readerioeither/type.go b/v2/context/readerioeither/type.go
index e743fd7..a312202 100644
--- a/v2/context/readerioeither/type.go
+++ b/v2/context/readerioeither/type.go
@@ -23,4 +23,4 @@ import (
 
 // ReaderIOEither is a specialization of the [RE.ReaderIOEither] monad for the typical golang scenario in which the
 // left value is an [error] and the context is a [context.Context]
-type ReaderIOEither[A any] RE.ReaderIOEither[context.Context, error, A]
+type ReaderIOEither[A any] = RE.ReaderIOEither[context.Context, error, A]
diff --git a/v2/io/generic/bind.go b/v2/io/generic/bind.go
deleted file mode 100644
index 833e090..0000000
--- a/v2/io/generic/bind.go
+++ /dev/null
@@ -1,101 +0,0 @@
-// 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 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
-//
-// Deprecated:
-func Do[GS ~func() 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]
-//
-// Deprecated:
-func Bind[GS1 ~func() S1, GS2 ~func() S2, GT ~func() 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]
-//
-// Deprecated:
-func Let[GS1 ~func() S1, GS2 ~func() 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]
-//
-// Deprecated:
-func LetTo[GS1 ~func() S1, GS2 ~func() 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]
-//
-// Deprecated:
-func BindTo[GS1 ~func() S1, GT ~func() 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
-//
-// Deprecated:
-func ApS[GS1 ~func() S1, GS2 ~func() S2, GT ~func() T, S1, S2, T any](
-	setter func(T) func(S1) S2,
-	fa GT,
-) func(GS1) GS2 {
-	return A.ApS(
-		Ap[GS2, func() func(T) S2, GT, S2, T],
-		Map[GS1, func() func(T) S2, S1, func(T) S2],
-		setter,
-		fa,
-	)
-}
diff --git a/v2/io/io.go b/v2/io/io.go
index 2f8e8fb..d4f010d 100644
--- a/v2/io/io.go
+++ b/v2/io/io.go
@@ -58,7 +58,7 @@ func FromIO[A any](a IO[A]) IO[A] {
 }
 
 // FromImpure converts a side effect without a return value into a side effect that returns any
-func FromImpure(f func()) IO[any] {
+func FromImpure[ANY ~func()](f ANY) IO[any] {
 	return func() any {
 		f()
 		return undefined
diff --git a/v2/ioeither/ap.go b/v2/ioeither/ap.go
index 1165dee..9185b9a 100644
--- a/v2/ioeither/ap.go
+++ b/v2/ioeither/ap.go
@@ -16,25 +16,47 @@
 package ioeither
 
 import (
-	G "github.com/IBM/fp-go/v2/ioeither/generic"
+	"github.com/IBM/fp-go/v2/internal/apply"
 )
 
 // MonadApFirst combines two effectful actions, keeping only the result of the first.
 func MonadApFirst[A, E, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, A] {
-	return G.MonadApFirst[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) A]](first, second)
+	return apply.MonadApFirst(
+		MonadAp[A, E, B],
+		MonadMap[E, A, func(B) A],
+
+		first,
+		second,
+	)
 }
 
 // ApFirst combines two effectful actions, keeping only the result of the first.
-func ApFirst[A, E, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, A] {
-	return G.ApFirst[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) A]](second)
+func ApFirst[A, E, B any](second IOEither[E, B]) Mapper[E, A, A] {
+	return apply.ApFirst(
+		MonadAp[A, E, B],
+		MonadMap[E, A, func(B) A],
+
+		second,
+	)
 }
 
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
 func MonadApSecond[A, E, B any](first IOEither[E, A], second IOEither[E, B]) IOEither[E, B] {
-	return G.MonadApSecond[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) B]](first, second)
+	return apply.MonadApSecond(
+		MonadAp[B, E, B],
+		MonadMap[E, A, func(B) B],
+
+		first,
+		second,
+	)
 }
 
 // ApSecond combines two effectful actions, keeping only the result of the second.
-func ApSecond[A, E, B any](second IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
-	return G.ApSecond[IOEither[E, A], IOEither[E, B], IOEither[E, func(B) B]](second)
+func ApSecond[A, E, B any](second IOEither[E, B]) Mapper[E, A, B] {
+	return apply.ApSecond(
+		MonadAp[B, E, B],
+		MonadMap[E, A, func(B) B],
+
+		second,
+	)
 }
diff --git a/v2/ioeither/bind.go b/v2/ioeither/bind.go
index 7fa5196..668ad63 100644
--- a/v2/ioeither/bind.go
+++ b/v2/ioeither/bind.go
@@ -16,51 +16,74 @@
 package ioeither
 
 import (
-	G "github.com/IBM/fp-go/v2/ioeither/generic"
+	"github.com/IBM/fp-go/v2/internal/apply"
+	"github.com/IBM/fp-go/v2/internal/chain"
+	"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[E, S any](
 	empty S,
 ) IOEither[E, S] {
-	return G.Do[IOEither[E, S], E, S](empty)
+	return Of[E](empty)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
 func Bind[E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) IOEither[E, T],
-) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.Bind[IOEither[E, S1], IOEither[E, S2], IOEither[E, T], E, S1, S2, T](setter, f)
+) Mapper[E, S1, S2] {
+	return chain.Bind(
+		Chain[E, S1, S2],
+		Map[E, T, S2],
+		setter,
+		f,
+	)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
 func Let[E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) T,
-) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.Let[IOEither[E, S1], IOEither[E, S2], E, S1, S2, T](setter, f)
+) Mapper[E, S1, S2] {
+	return functor.Let(
+		Map[E, S1, S2],
+		setter,
+		f,
+	)
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
 func LetTo[E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	b T,
-) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.LetTo[IOEither[E, S1], IOEither[E, S2], E, S1, S2, T](setter, b)
+) Mapper[E, S1, S2] {
+	return functor.LetTo(
+		Map[E, S1, S2],
+		setter,
+		b,
+	)
 }
 
 // BindTo initializes a new state [S1] from a value [T]
 func BindTo[E, S1, T any](
 	setter func(T) S1,
-) func(IOEither[E, T]) IOEither[E, S1] {
-	return G.BindTo[IOEither[E, S1], IOEither[E, T], E, S1, T](setter)
+) Mapper[E, T, S1] {
+	return chain.BindTo(
+		Map[E, 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[E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	fa IOEither[E, T],
-) func(IOEither[E, S1]) IOEither[E, S2] {
-	return G.ApS[IOEither[E, S1], IOEither[E, S2], IOEither[E, T], E, S1, S2, T](setter, fa)
+) Mapper[E, S1, S2] {
+	return apply.ApS(
+		Ap[S2, E, T],
+		Map[E, S1, func(T) S2],
+		setter,
+		fa,
+	)
 }
diff --git a/v2/ioeither/bracket.go b/v2/ioeither/bracket.go
index 29a4432..02827f1 100644
--- a/v2/ioeither/bracket.go
+++ b/v2/ioeither/bracket.go
@@ -16,7 +16,6 @@
 package ioeither
 
 import (
-	"github.com/IBM/fp-go/v2/either"
 	BR "github.com/IBM/fp-go/v2/internal/bracket"
 	"github.com/IBM/fp-go/v2/io"
 )
@@ -26,12 +25,12 @@ import (
 func Bracket[E, A, B, ANY any](
 	acquire IOEither[E, A],
 	use func(A) IOEither[E, B],
-	release func(A, either.Either[E, B]) IOEither[E, ANY],
+	release func(A, Either[E, B]) IOEither[E, ANY],
 ) IOEither[E, B] {
-	return BR.Bracket[IOEither[E, A], IOEither[E, B], IOEither[E, ANY], either.Either[E, B], A, B](
-		io.Of[either.Either[E, B]],
+	return BR.Bracket[IOEither[E, A], IOEither[E, B], IOEither[E, ANY], Either[E, B], A, B](
+		io.Of[Either[E, B]],
 		MonadChain[E, A, B],
-		io.MonadChain[either.Either[E, B], either.Either[E, B]],
+		io.MonadChain[Either[E, B], Either[E, B]],
 		MonadChain[E, ANY, B],
 
 		acquire,
diff --git a/v2/ioeither/eq.go b/v2/ioeither/eq.go
index 8e53167..523a669 100644
--- a/v2/ioeither/eq.go
+++ b/v2/ioeither/eq.go
@@ -18,12 +18,12 @@ package ioeither
 import (
 	"github.com/IBM/fp-go/v2/either"
 	EQ "github.com/IBM/fp-go/v2/eq"
-	IO "github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/io"
 )
 
 // Eq implements the equals predicate for values contained in the IOEither monad
-func Eq[E, A any](eq EQ.Eq[either.Either[E, A]]) EQ.Eq[IOEither[E, A]] {
-	return IO.Eq(eq)
+func Eq[E, A any](eq EQ.Eq[Either[E, A]]) EQ.Eq[IOEither[E, A]] {
+	return io.Eq(eq)
 }
 
 // FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
diff --git a/v2/ioeither/examples_do_test.go b/v2/ioeither/examples_do_test.go
index 9ed636c..be3ef9a 100644
--- a/v2/ioeither/examples_do_test.go
+++ b/v2/ioeither/examples_do_test.go
@@ -20,7 +20,7 @@ import (
 	"log"
 
 	F "github.com/IBM/fp-go/v2/function"
-	IO "github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/io"
 	T "github.com/IBM/fp-go/v2/tuple"
 )
 
@@ -29,8 +29,8 @@ func ExampleIOEither_do() {
 	bar := Of[error](1)
 
 	// quux consumes the state of three bindings and returns an [IO] instead of an [IOEither]
-	quux := func(t T.Tuple3[string, int, string]) IO.IO[any] {
-		return IO.FromImpure(func() {
+	quux := func(t T.Tuple3[string, int, string]) IO[any] {
+		return io.FromImpure(func() {
 			log.Printf("t1: %s, t2: %d, t3: %s", t.F1, t.F2, t.F3)
 		})
 	}
diff --git a/v2/ioeither/examples_extract_test.go b/v2/ioeither/examples_extract_test.go
index 7ad85bf..74e703c 100644
--- a/v2/ioeither/examples_extract_test.go
+++ b/v2/ioeither/examples_extract_test.go
@@ -20,7 +20,7 @@ import (
 
 	E "github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
-	IO "github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/io"
 )
 
 func ExampleIOEither_extraction() {
@@ -30,7 +30,7 @@ func ExampleIOEither_extraction() {
 	value := E.GetOrElse(F.Constant1[error](0))(eitherValue) // 42
 
 	// Or more directly
-	infaillibleIO := GetOrElse(F.Constant1[error](IO.Of(0)))(someIOEither) // => IO.Right(42)
+	infaillibleIO := GetOrElse(F.Constant1[error](io.Of(0)))(someIOEither) // => io.Right(42)
 	valueFromIO := infaillibleIO()                                         // => 42
 
 	fmt.Println(eitherValue)
diff --git a/v2/ioeither/exec/exec.go b/v2/ioeither/exec/exec.go
index efb4ed1..fa8b616 100644
--- a/v2/ioeither/exec/exec.go
+++ b/v2/ioeither/exec/exec.go
@@ -19,14 +19,14 @@ import (
 	"context"
 
 	"github.com/IBM/fp-go/v2/exec"
-	F "github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/function"
 	INTE "github.com/IBM/fp-go/v2/internal/exec"
 	"github.com/IBM/fp-go/v2/ioeither"
 )
 
 var (
 	// Command executes a command
-	Command = F.Curry3(command)
+	Command = function.Curry3(command)
 )
 
 func command(name string, args []string, in []byte) ioeither.IOEither[error, exec.CommandOutput] {
diff --git a/v2/ioeither/file/tempfile.go b/v2/ioeither/file/tempfile.go
index e8e2a21..4273fd4 100644
--- a/v2/ioeither/file/tempfile.go
+++ b/v2/ioeither/file/tempfile.go
@@ -19,7 +19,7 @@ import (
 	"os"
 
 	F "github.com/IBM/fp-go/v2/function"
-	IO "github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/io"
 	IOF "github.com/IBM/fp-go/v2/io/file"
 	"github.com/IBM/fp-go/v2/ioeither"
 )
@@ -32,7 +32,7 @@ var (
 	// destroy handler
 	onReleaseTempFile = F.Flow4(
 		IOF.Close[*os.File],
-		IO.Map((*os.File).Name),
+		io.Map((*os.File).Name),
 		ioeither.FromIO[error, string],
 		ioeither.Chain(Remove),
 	)
diff --git a/v2/ioeither/generic/ap.go b/v2/ioeither/generic/ap.go
deleted file mode 100644
index d372b2c..0000000
--- a/v2/ioeither/generic/ap.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// 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 generic
-
-import (
-	"github.com/IBM/fp-go/v2/either"
-	G "github.com/IBM/fp-go/v2/internal/apply"
-)
-
-// MonadApFirst combines two effectful actions, keeping only the result of the first.
-func MonadApFirst[GA ~func() either.Either[E, A], GB ~func() either.Either[E, B], GBA ~func() either.Either[E, func(B) A], E, A, B any](first GA, second GB) GA {
-	return G.MonadApFirst(
-		MonadAp[GA, GBA, GB],
-		MonadMap[GA, GBA, E, A, func(B) A],
-
-		first,
-		second,
-	)
-}
-
-// ApFirst combines two effectful actions, keeping only the result of the first.
-func ApFirst[GA ~func() either.Either[E, A], GB ~func() either.Either[E, B], GBA ~func() either.Either[E, func(B) A], E, A, B any](second GB) func(GA) GA {
-	return G.ApFirst(
-		MonadAp[GA, GBA, GB],
-		MonadMap[GA, GBA, E, A, func(B) A],
-
-		second,
-	)
-}
-
-// MonadApSecond combines two effectful actions, keeping only the result of the second.
-func MonadApSecond[GA ~func() either.Either[E, A], GB ~func() either.Either[E, B], GBB ~func() either.Either[E, func(B) B], E, A, B any](first GA, second GB) GB {
-	return G.MonadApSecond(
-		MonadAp[GB, GBB, GB],
-		MonadMap[GA, GBB, E, A, func(B) B],
-
-		first,
-		second,
-	)
-}
-
-// ApSecond combines two effectful actions, keeping only the result of the second.
-func ApSecond[GA ~func() either.Either[E, A], GB ~func() either.Either[E, B], GBB ~func() either.Either[E, func(B) B], E, A, B any](second GB) func(GA) GB {
-	return G.ApSecond(
-		MonadAp[GB, GBB, GB],
-		MonadMap[GA, GBB, E, A, func(B) B],
-
-		second,
-	)
-}
diff --git a/v2/ioeither/generic/bind.go b/v2/ioeither/generic/bind.go
deleted file mode 100644
index d2b5a74..0000000
--- a/v2/ioeither/generic/bind.go
+++ /dev/null
@@ -1,90 +0,0 @@
-// 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 generic
-
-import (
-	"github.com/IBM/fp-go/v2/either"
-	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 ~func() either.Either[E, S], E, S any](
-	empty S,
-) GS {
-	return Of[GS, E, S](empty)
-}
-
-// Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], GT ~func() either.Either[E, T], E, S1, S2, T any](
-	setter func(T) func(S1) S2,
-	f func(S1) GT,
-) func(GS1) GS2 {
-	return C.Bind(
-		Chain[GS1, GS2, E, S1, S2],
-		Map[GT, GS2, E, T, S2],
-		setter,
-		f,
-	)
-}
-
-// Let attaches the result of a computation to a context [S1] to produce a context [S2]
-func Let[GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], E, S1, S2, T any](
-	key func(T) func(S1) S2,
-	f func(S1) T,
-) func(GS1) GS2 {
-	return F.Let(
-		Map[GS1, GS2, E, S1, S2],
-		key,
-		f,
-	)
-}
-
-// LetTo attaches the a value to a context [S1] to produce a context [S2]
-func LetTo[GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], E, S1, S2, B any](
-	key func(B) func(S1) S2,
-	b B,
-) func(GS1) GS2 {
-	return F.LetTo(
-		Map[GS1, GS2, E, S1, S2],
-		key,
-		b,
-	)
-}
-
-// BindTo initializes a new state [S1] from a value [T]
-func BindTo[GS1 ~func() either.Either[E, S1], GT ~func() either.Either[E, T], E, S1, S2, T any](
-	setter func(T) S1,
-) func(GT) GS1 {
-	return C.BindTo(
-		Map[GT, GS1, E, 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 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], GT ~func() either.Either[E, T], E, S1, S2, T any](
-	setter func(T) func(S1) S2,
-	fa GT,
-) func(GS1) GS2 {
-	return A.ApS(
-		Ap[GS2, func() either.Either[E, func(T) S2], GT, E, T, S2],
-		Map[GS1, func() either.Either[E, func(T) S2], E, S1, func(T) S2],
-		setter,
-		fa,
-	)
-}
diff --git a/v2/ioeither/generic/gen.go b/v2/ioeither/generic/gen.go
index 29b7737..c52aa70 100644
--- a/v2/ioeither/generic/gen.go
+++ b/v2/ioeither/generic/gen.go
@@ -10,43 +10,43 @@ import (
 )
 
 // Eitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
-func Eitherize0[GIOA ~func() either.Either[error, R], F ~func() (R, error), R any](f F) func() GIOA {
+func Eitherize0[GIOA ~func() Either[error, R], F ~func() (R, error), R any](f F) func() GIOA {
 	e := either.Eitherize0(f)
 	return func() GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e()
 		}
 	}
 }
 
 // Uneitherize0 converts a function with 0 parameters returning a tuple into a function with 0 parameters returning a [GIOA]
-func Uneitherize0[GIOA ~func() either.Either[error, R], GTA ~func() GIOA, R any](f GTA) func() (R, error) {
+func Uneitherize0[GIOA ~func() Either[error, R], GTA ~func() GIOA, R any](f GTA) func() (R, error) {
 	return func() (R, error) {
 		return either.Unwrap(f()())
 	}
 }
 
 // Eitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
-func Eitherize1[GIOA ~func() either.Either[error, R], F ~func(T1) (R, error), T1, R any](f F) func(T1) GIOA {
+func Eitherize1[GIOA ~func() Either[error, R], F ~func(T1) (R, error), T1, R any](f F) func(T1) GIOA {
 	e := either.Eitherize1(f)
 	return func(t1 T1) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1)
 		}
 	}
 }
 
 // Uneitherize1 converts a function with 1 parameters returning a tuple into a function with 1 parameters returning a [GIOA]
-func Uneitherize1[GIOA ~func() either.Either[error, R], GTA ~func(T1) GIOA, T1, R any](f GTA) func(T1) (R, error) {
+func Uneitherize1[GIOA ~func() Either[error, R], GTA ~func(T1) GIOA, T1, R any](f GTA) func(T1) (R, error) {
 	return func(t1 T1) (R, error) {
 		return either.Unwrap(f(t1)())
 	}
 }
 
-// SequenceT1 converts 1 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple1[T1]]]
+// SequenceT1 converts 1 [func() Either[E, T]] into a [func() Either[E, T.Tuple1[T1]]]
 func SequenceT1[
-	G_TUPLE1 ~func() either.Either[E, T.Tuple1[T1]],
-	G_T1 ~func() either.Either[E, T1],
+	G_TUPLE1 ~func() Either[E, T.Tuple1[T1]],
+	G_T1 ~func() Either[E, T1],
 	E, T1 any](
 	t1 G_T1,
 ) G_TUPLE1 {
@@ -56,21 +56,21 @@ func SequenceT1[
 	)
 }
 
-// SequenceTuple1 converts a [T.Tuple1[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple1[T1]]]
+// SequenceTuple1 converts a [T.Tuple1[func() Either[E, T]]] into a [func() Either[E, T.Tuple1[T1]]]
 func SequenceTuple1[
-	G_TUPLE1 ~func() either.Either[E, T.Tuple1[T1]],
-	G_T1 ~func() either.Either[E, T1],
+	G_TUPLE1 ~func() Either[E, T.Tuple1[T1]],
+	G_T1 ~func() Either[E, T1],
 	E, T1 any](t T.Tuple1[G_T1]) G_TUPLE1 {
 	return A.SequenceTuple1(
 		Map[G_T1, G_TUPLE1, E, T1, T.Tuple1[T1]],
 		t)
 }
 
-// TraverseTuple1 converts a [T.Tuple1[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple1[T1]]]
+// TraverseTuple1 converts a [T.Tuple1[func() Either[E, T]]] into a [func() Either[E, T.Tuple1[T1]]]
 func TraverseTuple1[
-	G_TUPLE1 ~func() either.Either[E, T.Tuple1[T1]],
+	G_TUPLE1 ~func() Either[E, T.Tuple1[T1]],
 	F1 ~func(A1) G_T1,
-	G_T1 ~func() either.Either[E, T1],
+	G_T1 ~func() Either[E, T1],
 	E, A1, T1 any](f1 F1) func(T.Tuple1[A1]) G_TUPLE1 {
 	return func(t T.Tuple1[A1]) G_TUPLE1 {
 		return A.TraverseTuple1(
@@ -81,63 +81,63 @@ func TraverseTuple1[
 }
 
 // Eitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
-func Eitherize2[GIOA ~func() either.Either[error, R], F ~func(T1, T2) (R, error), T1, T2, R any](f F) func(T1, T2) GIOA {
+func Eitherize2[GIOA ~func() Either[error, R], F ~func(T1, T2) (R, error), T1, T2, R any](f F) func(T1, T2) GIOA {
 	e := either.Eitherize2(f)
 	return func(t1 T1, t2 T2) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2)
 		}
 	}
 }
 
 // Uneitherize2 converts a function with 2 parameters returning a tuple into a function with 2 parameters returning a [GIOA]
-func Uneitherize2[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2) GIOA, T1, T2, R any](f GTA) func(T1, T2) (R, error) {
+func Uneitherize2[GIOA ~func() Either[error, R], GTA ~func(T1, T2) GIOA, T1, T2, R any](f GTA) func(T1, T2) (R, error) {
 	return func(t1 T1, t2 T2) (R, error) {
 		return either.Unwrap(f(t1, t2)())
 	}
 }
 
-// SequenceT2 converts 2 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple2[T1, T2]]]
+// SequenceT2 converts 2 [func() Either[E, T]] into a [func() Either[E, T.Tuple2[T1, T2]]]
 func SequenceT2[
-	G_TUPLE2 ~func() either.Either[E, T.Tuple2[T1, T2]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
+	G_TUPLE2 ~func() Either[E, T.Tuple2[T1, T2]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
 	E, T1, T2 any](
 	t1 G_T1,
 	t2 G_T2,
 ) G_TUPLE2 {
 	return A.SequenceT2(
-		Map[G_T1, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
-		Ap[G_TUPLE2, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
+		Map[G_T1, func() Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
+		Ap[G_TUPLE2, func() Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
 		t1,
 		t2,
 	)
 }
 
-// SequenceTuple2 converts a [T.Tuple2[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple2[T1, T2]]]
+// SequenceTuple2 converts a [T.Tuple2[func() Either[E, T]]] into a [func() Either[E, T.Tuple2[T1, T2]]]
 func SequenceTuple2[
-	G_TUPLE2 ~func() either.Either[E, T.Tuple2[T1, T2]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
+	G_TUPLE2 ~func() Either[E, T.Tuple2[T1, T2]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
 	E, T1, T2 any](t T.Tuple2[G_T1, G_T2]) G_TUPLE2 {
 	return A.SequenceTuple2(
-		Map[G_T1, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
-		Ap[G_TUPLE2, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
+		Map[G_T1, func() Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
+		Ap[G_TUPLE2, func() Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
 		t)
 }
 
-// TraverseTuple2 converts a [T.Tuple2[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple2[T1, T2]]]
+// TraverseTuple2 converts a [T.Tuple2[func() Either[E, T]]] into a [func() Either[E, T.Tuple2[T1, T2]]]
 func TraverseTuple2[
-	G_TUPLE2 ~func() either.Either[E, T.Tuple2[T1, T2]],
+	G_TUPLE2 ~func() Either[E, T.Tuple2[T1, T2]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
 	E, A1, A2, T1, T2 any](f1 F1, f2 F2) func(T.Tuple2[A1, A2]) G_TUPLE2 {
 	return func(t T.Tuple2[A1, A2]) G_TUPLE2 {
 		return A.TraverseTuple2(
-			Map[G_T1, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
-			Ap[G_TUPLE2, func() either.Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
+			Map[G_T1, func() Either[E, func(T2) T.Tuple2[T1, T2]], E, T1, func(T2) T.Tuple2[T1, T2]],
+			Ap[G_TUPLE2, func() Either[E, func(T2) T.Tuple2[T1, T2]], G_T2],
 			f1,
 			f2,
 			t)
@@ -145,72 +145,72 @@ func TraverseTuple2[
 }
 
 // Eitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
-func Eitherize3[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3) (R, error), T1, T2, T3, R any](f F) func(T1, T2, T3) GIOA {
+func Eitherize3[GIOA ~func() Either[error, R], F ~func(T1, T2, T3) (R, error), T1, T2, T3, R any](f F) func(T1, T2, T3) GIOA {
 	e := either.Eitherize3(f)
 	return func(t1 T1, t2 T2, t3 T3) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3)
 		}
 	}
 }
 
 // Uneitherize3 converts a function with 3 parameters returning a tuple into a function with 3 parameters returning a [GIOA]
-func Uneitherize3[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3) GIOA, T1, T2, T3, R any](f GTA) func(T1, T2, T3) (R, error) {
+func Uneitherize3[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3) GIOA, T1, T2, T3, R any](f GTA) func(T1, T2, T3) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3) (R, error) {
 		return either.Unwrap(f(t1, t2, t3)())
 	}
 }
 
-// SequenceT3 converts 3 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple3[T1, T2, T3]]]
+// SequenceT3 converts 3 [func() Either[E, T]] into a [func() Either[E, T.Tuple3[T1, T2, T3]]]
 func SequenceT3[
-	G_TUPLE3 ~func() either.Either[E, T.Tuple3[T1, T2, T3]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
+	G_TUPLE3 ~func() Either[E, T.Tuple3[T1, T2, T3]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
 	E, T1, T2, T3 any](
 	t1 G_T1,
 	t2 G_T2,
 	t3 G_T3,
 ) G_TUPLE3 {
 	return A.SequenceT3(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-		Ap[func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
-		Ap[G_TUPLE3, func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+		Map[G_T1, func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+		Ap[func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+		Ap[G_TUPLE3, func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
 		t1,
 		t2,
 		t3,
 	)
 }
 
-// SequenceTuple3 converts a [T.Tuple3[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple3[T1, T2, T3]]]
+// SequenceTuple3 converts a [T.Tuple3[func() Either[E, T]]] into a [func() Either[E, T.Tuple3[T1, T2, T3]]]
 func SequenceTuple3[
-	G_TUPLE3 ~func() either.Either[E, T.Tuple3[T1, T2, T3]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
+	G_TUPLE3 ~func() Either[E, T.Tuple3[T1, T2, T3]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
 	E, T1, T2, T3 any](t T.Tuple3[G_T1, G_T2, G_T3]) G_TUPLE3 {
 	return A.SequenceTuple3(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-		Ap[func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
-		Ap[G_TUPLE3, func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+		Map[G_T1, func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+		Ap[func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+		Ap[G_TUPLE3, func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
 		t)
 }
 
-// TraverseTuple3 converts a [T.Tuple3[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple3[T1, T2, T3]]]
+// TraverseTuple3 converts a [T.Tuple3[func() Either[E, T]]] into a [func() Either[E, T.Tuple3[T1, T2, T3]]]
 func TraverseTuple3[
-	G_TUPLE3 ~func() either.Either[E, T.Tuple3[T1, T2, T3]],
+	G_TUPLE3 ~func() Either[E, T.Tuple3[T1, T2, T3]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
 	E, A1, A2, A3, T1, T2, T3 any](f1 F1, f2 F2, f3 F3) func(T.Tuple3[A1, A2, A3]) G_TUPLE3 {
 	return func(t T.Tuple3[A1, A2, A3]) G_TUPLE3 {
 		return A.TraverseTuple3(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
-			Ap[func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() either.Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
-			Ap[G_TUPLE3, func() either.Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
+			Map[G_T1, func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], E, T1, func(T2) func(T3) T.Tuple3[T1, T2, T3]],
+			Ap[func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], func() Either[E, func(T2) func(T3) T.Tuple3[T1, T2, T3]], G_T2],
+			Ap[G_TUPLE3, func() Either[E, func(T3) T.Tuple3[T1, T2, T3]], G_T3],
 			f1,
 			f2,
 			f3,
@@ -219,29 +219,29 @@ func TraverseTuple3[
 }
 
 // Eitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
-func Eitherize4[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4) (R, error), T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) GIOA {
+func Eitherize4[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4) (R, error), T1, T2, T3, T4, R any](f F) func(T1, T2, T3, T4) GIOA {
 	e := either.Eitherize4(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4)
 		}
 	}
 }
 
 // Uneitherize4 converts a function with 4 parameters returning a tuple into a function with 4 parameters returning a [GIOA]
-func Uneitherize4[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4) GIOA, T1, T2, T3, T4, R any](f GTA) func(T1, T2, T3, T4) (R, error) {
+func Uneitherize4[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4) GIOA, T1, T2, T3, T4, R any](f GTA) func(T1, T2, T3, T4) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4)())
 	}
 }
 
-// SequenceT4 converts 4 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple4[T1, T2, T3, T4]]]
+// SequenceT4 converts 4 [func() Either[E, T]] into a [func() Either[E, T.Tuple4[T1, T2, T3, T4]]]
 func SequenceT4[
-	G_TUPLE4 ~func() either.Either[E, T.Tuple4[T1, T2, T3, T4]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
+	G_TUPLE4 ~func() Either[E, T.Tuple4[T1, T2, T3, T4]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
 	E, T1, T2, T3, T4 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -249,10 +249,10 @@ func SequenceT4[
 	t4 G_T4,
 ) G_TUPLE4 {
 	return A.SequenceT4(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-		Ap[func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
-		Ap[func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
-		Ap[G_TUPLE4, func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+		Ap[func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+		Ap[func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+		Ap[G_TUPLE4, func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
 		t1,
 		t2,
 		t3,
@@ -260,40 +260,40 @@ func SequenceT4[
 	)
 }
 
-// SequenceTuple4 converts a [T.Tuple4[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple4[T1, T2, T3, T4]]]
+// SequenceTuple4 converts a [T.Tuple4[func() Either[E, T]]] into a [func() Either[E, T.Tuple4[T1, T2, T3, T4]]]
 func SequenceTuple4[
-	G_TUPLE4 ~func() either.Either[E, T.Tuple4[T1, T2, T3, T4]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
+	G_TUPLE4 ~func() Either[E, T.Tuple4[T1, T2, T3, T4]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
 	E, T1, T2, T3, T4 any](t T.Tuple4[G_T1, G_T2, G_T3, G_T4]) G_TUPLE4 {
 	return A.SequenceTuple4(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-		Ap[func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
-		Ap[func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
-		Ap[G_TUPLE4, func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+		Ap[func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+		Ap[func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+		Ap[G_TUPLE4, func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
 		t)
 }
 
-// TraverseTuple4 converts a [T.Tuple4[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple4[T1, T2, T3, T4]]]
+// TraverseTuple4 converts a [T.Tuple4[func() Either[E, T]]] into a [func() Either[E, T.Tuple4[T1, T2, T3, T4]]]
 func TraverseTuple4[
-	G_TUPLE4 ~func() either.Either[E, T.Tuple4[T1, T2, T3, T4]],
+	G_TUPLE4 ~func() Either[E, T.Tuple4[T1, T2, T3, T4]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
 	F4 ~func(A4) G_T4,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
 	E, A1, A2, A3, A4, T1, T2, T3, T4 any](f1 F1, f2 F2, f3 F3, f4 F4) func(T.Tuple4[A1, A2, A3, A4]) G_TUPLE4 {
 	return func(t T.Tuple4[A1, A2, A3, A4]) G_TUPLE4 {
 		return A.TraverseTuple4(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
-			Ap[func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
-			Ap[func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() either.Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
-			Ap[G_TUPLE4, func() either.Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], E, T1, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]],
+			Ap[func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T2) func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T2],
+			Ap[func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], func() Either[E, func(T3) func(T4) T.Tuple4[T1, T2, T3, T4]], G_T3],
+			Ap[G_TUPLE4, func() Either[E, func(T4) T.Tuple4[T1, T2, T3, T4]], G_T4],
 			f1,
 			f2,
 			f3,
@@ -303,30 +303,30 @@ func TraverseTuple4[
 }
 
 // Eitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
-func Eitherize5[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5) (R, error), T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) GIOA {
+func Eitherize5[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5) (R, error), T1, T2, T3, T4, T5, R any](f F) func(T1, T2, T3, T4, T5) GIOA {
 	e := either.Eitherize5(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5)
 		}
 	}
 }
 
 // Uneitherize5 converts a function with 5 parameters returning a tuple into a function with 5 parameters returning a [GIOA]
-func Uneitherize5[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5) GIOA, T1, T2, T3, T4, T5, R any](f GTA) func(T1, T2, T3, T4, T5) (R, error) {
+func Uneitherize5[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5) GIOA, T1, T2, T3, T4, T5, R any](f GTA) func(T1, T2, T3, T4, T5) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5)())
 	}
 }
 
-// SequenceT5 converts 5 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
+// SequenceT5 converts 5 [func() Either[E, T]] into a [func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceT5[
-	G_TUPLE5 ~func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
+	G_TUPLE5 ~func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
 	E, T1, T2, T3, T4, T5 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -335,11 +335,11 @@ func SequenceT5[
 	t5 G_T5,
 ) G_TUPLE5 {
 	return A.SequenceT5(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
-		Ap[func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
-		Ap[G_TUPLE5, func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+		Ap[func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+		Ap[G_TUPLE5, func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
 		t1,
 		t2,
 		t3,
@@ -348,45 +348,45 @@ func SequenceT5[
 	)
 }
 
-// SequenceTuple5 converts a [T.Tuple5[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
+// SequenceTuple5 converts a [T.Tuple5[func() Either[E, T]]] into a [func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func SequenceTuple5[
-	G_TUPLE5 ~func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
+	G_TUPLE5 ~func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
 	E, T1, T2, T3, T4, T5 any](t T.Tuple5[G_T1, G_T2, G_T3, G_T4, G_T5]) G_TUPLE5 {
 	return A.SequenceTuple5(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
-		Ap[func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
-		Ap[G_TUPLE5, func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+		Ap[func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+		Ap[G_TUPLE5, func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
 		t)
 }
 
-// TraverseTuple5 converts a [T.Tuple5[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
+// TraverseTuple5 converts a [T.Tuple5[func() Either[E, T]]] into a [func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]]]
 func TraverseTuple5[
-	G_TUPLE5 ~func() either.Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
+	G_TUPLE5 ~func() Either[E, T.Tuple5[T1, T2, T3, T4, T5]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
 	F4 ~func(A4) G_T4,
 	F5 ~func(A5) G_T5,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
 	E, A1, A2, A3, A4, A5, T1, T2, T3, T4, T5 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5) func(T.Tuple5[A1, A2, A3, A4, A5]) G_TUPLE5 {
 	return func(t T.Tuple5[A1, A2, A3, A4, A5]) G_TUPLE5 {
 		return A.TraverseTuple5(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
-			Ap[func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() either.Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
-			Ap[G_TUPLE5, func() either.Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], E, T1, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T2) func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T3) func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T3],
+			Ap[func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], func() Either[E, func(T4) func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T4],
+			Ap[G_TUPLE5, func() Either[E, func(T5) T.Tuple5[T1, T2, T3, T4, T5]], G_T5],
 			f1,
 			f2,
 			f3,
@@ -397,31 +397,31 @@ func TraverseTuple5[
 }
 
 // Eitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
-func Eitherize6[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6) (R, error), T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) GIOA {
+func Eitherize6[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5, T6) (R, error), T1, T2, T3, T4, T5, T6, R any](f F) func(T1, T2, T3, T4, T5, T6) GIOA {
 	e := either.Eitherize6(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5, t6)
 		}
 	}
 }
 
 // Uneitherize6 converts a function with 6 parameters returning a tuple into a function with 6 parameters returning a [GIOA]
-func Uneitherize6[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6) GIOA, T1, T2, T3, T4, T5, T6, R any](f GTA) func(T1, T2, T3, T4, T5, T6) (R, error) {
+func Uneitherize6[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6) GIOA, T1, T2, T3, T4, T5, T6, R any](f GTA) func(T1, T2, T3, T4, T5, T6) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5, t6)())
 	}
 }
 
-// SequenceT6 converts 6 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+// SequenceT6 converts 6 [func() Either[E, T]] into a [func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceT6[
-	G_TUPLE6 ~func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
+	G_TUPLE6 ~func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
 	E, T1, T2, T3, T4, T5, T6 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -431,12 +431,12 @@ func SequenceT6[
 	t6 G_T6,
 ) G_TUPLE6 {
 	return A.SequenceT6(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
-		Ap[func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
-		Ap[G_TUPLE6, func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+		Ap[func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+		Ap[G_TUPLE6, func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
 		t1,
 		t2,
 		t3,
@@ -446,50 +446,50 @@ func SequenceT6[
 	)
 }
 
-// SequenceTuple6 converts a [T.Tuple6[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+// SequenceTuple6 converts a [T.Tuple6[func() Either[E, T]]] into a [func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func SequenceTuple6[
-	G_TUPLE6 ~func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
+	G_TUPLE6 ~func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
 	E, T1, T2, T3, T4, T5, T6 any](t T.Tuple6[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6]) G_TUPLE6 {
 	return A.SequenceTuple6(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
-		Ap[func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
-		Ap[G_TUPLE6, func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+		Ap[func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+		Ap[G_TUPLE6, func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
 		t)
 }
 
-// TraverseTuple6 converts a [T.Tuple6[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
+// TraverseTuple6 converts a [T.Tuple6[func() Either[E, T]]] into a [func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]]]
 func TraverseTuple6[
-	G_TUPLE6 ~func() either.Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
+	G_TUPLE6 ~func() Either[E, T.Tuple6[T1, T2, T3, T4, T5, T6]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
 	F4 ~func(A4) G_T4,
 	F5 ~func(A5) G_T5,
 	F6 ~func(A6) G_T6,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
 	E, A1, A2, A3, A4, A5, A6, T1, T2, T3, T4, T5, T6 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6) func(T.Tuple6[A1, A2, A3, A4, A5, A6]) G_TUPLE6 {
 	return func(t T.Tuple6[A1, A2, A3, A4, A5, A6]) G_TUPLE6 {
 		return A.TraverseTuple6(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
-			Ap[func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
-			Ap[func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() either.Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
-			Ap[G_TUPLE6, func() either.Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T3) func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T3],
+			Ap[func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T4) func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T4],
+			Ap[func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], func() Either[E, func(T5) func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T5],
+			Ap[G_TUPLE6, func() Either[E, func(T6) T.Tuple6[T1, T2, T3, T4, T5, T6]], G_T6],
 			f1,
 			f2,
 			f3,
@@ -501,32 +501,32 @@ func TraverseTuple6[
 }
 
 // Eitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
-func Eitherize7[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7) (R, error), T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) GIOA {
+func Eitherize7[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7) (R, error), T1, T2, T3, T4, T5, T6, T7, R any](f F) func(T1, T2, T3, T4, T5, T6, T7) GIOA {
 	e := either.Eitherize7(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5, t6, t7)
 		}
 	}
 }
 
 // Uneitherize7 converts a function with 7 parameters returning a tuple into a function with 7 parameters returning a [GIOA]
-func Uneitherize7[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7) GIOA, T1, T2, T3, T4, T5, T6, T7, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7) (R, error) {
+func Uneitherize7[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7) GIOA, T1, T2, T3, T4, T5, T6, T7, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5, t6, t7)())
 	}
 }
 
-// SequenceT7 converts 7 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+// SequenceT7 converts 7 [func() Either[E, T]] into a [func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceT7[
-	G_TUPLE7 ~func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
+	G_TUPLE7 ~func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
 	E, T1, T2, T3, T4, T5, T6, T7 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -537,13 +537,13 @@ func SequenceT7[
 	t7 G_T7,
 ) G_TUPLE7 {
 	return A.SequenceT7(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
-		Ap[func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
-		Ap[G_TUPLE7, func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+		Ap[func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+		Ap[G_TUPLE7, func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
 		t1,
 		t2,
 		t3,
@@ -554,31 +554,31 @@ func SequenceT7[
 	)
 }
 
-// SequenceTuple7 converts a [T.Tuple7[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+// SequenceTuple7 converts a [T.Tuple7[func() Either[E, T]]] into a [func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func SequenceTuple7[
-	G_TUPLE7 ~func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
+	G_TUPLE7 ~func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
 	E, T1, T2, T3, T4, T5, T6, T7 any](t T.Tuple7[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7]) G_TUPLE7 {
 	return A.SequenceTuple7(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
-		Ap[func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
-		Ap[G_TUPLE7, func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+		Ap[func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+		Ap[G_TUPLE7, func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
 		t)
 }
 
-// TraverseTuple7 converts a [T.Tuple7[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
+// TraverseTuple7 converts a [T.Tuple7[func() Either[E, T]]] into a [func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]]]
 func TraverseTuple7[
-	G_TUPLE7 ~func() either.Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+	G_TUPLE7 ~func() Either[E, T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
@@ -586,23 +586,23 @@ func TraverseTuple7[
 	F5 ~func(A5) G_T5,
 	F6 ~func(A6) G_T6,
 	F7 ~func(A7) G_T7,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
 	E, A1, A2, A3, A4, A5, A6, A7, T1, T2, T3, T4, T5, T6, T7 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7) func(T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) G_TUPLE7 {
 	return func(t T.Tuple7[A1, A2, A3, A4, A5, A6, A7]) G_TUPLE7 {
 		return A.TraverseTuple7(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
-			Ap[func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
-			Ap[func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
-			Ap[func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() either.Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
-			Ap[G_TUPLE7, func() either.Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T3],
+			Ap[func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T4) func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T4],
+			Ap[func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T5) func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T5],
+			Ap[func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], func() Either[E, func(T6) func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T6],
+			Ap[G_TUPLE7, func() Either[E, func(T7) T.Tuple7[T1, T2, T3, T4, T5, T6, T7]], G_T7],
 			f1,
 			f2,
 			f3,
@@ -615,33 +615,33 @@ func TraverseTuple7[
 }
 
 // Eitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
-func Eitherize8[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA {
+func Eitherize8[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA {
 	e := either.Eitherize8(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5, t6, t7, t8)
 		}
 	}
 }
 
 // Uneitherize8 converts a function with 8 parameters returning a tuple into a function with 8 parameters returning a [GIOA]
-func Uneitherize8[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
+func Uneitherize8[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8)())
 	}
 }
 
-// SequenceT8 converts 8 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+// SequenceT8 converts 8 [func() Either[E, T]] into a [func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceT8[
-	G_TUPLE8 ~func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
+	G_TUPLE8 ~func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
 	E, T1, T2, T3, T4, T5, T6, T7, T8 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -653,14 +653,14 @@ func SequenceT8[
 	t8 G_T8,
 ) G_TUPLE8 {
 	return A.SequenceT8(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
-		Ap[func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
-		Ap[G_TUPLE8, func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+		Ap[func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+		Ap[G_TUPLE8, func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
 		t1,
 		t2,
 		t3,
@@ -672,33 +672,33 @@ func SequenceT8[
 	)
 }
 
-// SequenceTuple8 converts a [T.Tuple8[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+// SequenceTuple8 converts a [T.Tuple8[func() Either[E, T]]] into a [func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func SequenceTuple8[
-	G_TUPLE8 ~func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
+	G_TUPLE8 ~func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
 	E, T1, T2, T3, T4, T5, T6, T7, T8 any](t T.Tuple8[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8]) G_TUPLE8 {
 	return A.SequenceTuple8(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
-		Ap[func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
-		Ap[G_TUPLE8, func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+		Ap[func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+		Ap[G_TUPLE8, func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
 		t)
 }
 
-// TraverseTuple8 converts a [T.Tuple8[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
+// TraverseTuple8 converts a [T.Tuple8[func() Either[E, T]]] into a [func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]]
 func TraverseTuple8[
-	G_TUPLE8 ~func() either.Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+	G_TUPLE8 ~func() Either[E, T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
@@ -707,25 +707,25 @@ func TraverseTuple8[
 	F6 ~func(A6) G_T6,
 	F7 ~func(A7) G_T7,
 	F8 ~func(A8) G_T8,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
 	E, A1, A2, A3, A4, A5, A6, A7, A8, T1, T2, T3, T4, T5, T6, T7, T8 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8) func(T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) G_TUPLE8 {
 	return func(t T.Tuple8[A1, A2, A3, A4, A5, A6, A7, A8]) G_TUPLE8 {
 		return A.TraverseTuple8(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
-			Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
-			Ap[func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
-			Ap[func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
-			Ap[func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() either.Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
-			Ap[G_TUPLE8, func() either.Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T3],
+			Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T4],
+			Ap[func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T5) func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T5],
+			Ap[func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T6) func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T6],
+			Ap[func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], func() Either[E, func(T7) func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T7],
+			Ap[G_TUPLE8, func() Either[E, func(T8) T.Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]], G_T8],
 			f1,
 			f2,
 			f3,
@@ -739,34 +739,34 @@ func TraverseTuple8[
 }
 
 // Eitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
-func Eitherize9[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA {
+func Eitherize9[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA {
 	e := either.Eitherize9(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5, t6, t7, t8, t9)
 		}
 	}
 }
 
 // Uneitherize9 converts a function with 9 parameters returning a tuple into a function with 9 parameters returning a [GIOA]
-func Uneitherize9[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
+func Uneitherize9[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9)())
 	}
 }
 
-// SequenceT9 converts 9 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+// SequenceT9 converts 9 [func() Either[E, T]] into a [func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceT9[
-	G_TUPLE9 ~func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
+	G_TUPLE9 ~func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
 	E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -779,15 +779,15 @@ func SequenceT9[
 	t9 G_T9,
 ) G_TUPLE9 {
 	return A.SequenceT9(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
-		Ap[func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
-		Ap[func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
-		Ap[G_TUPLE9, func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+		Ap[func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+		Ap[func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+		Ap[G_TUPLE9, func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
 		t1,
 		t2,
 		t3,
@@ -800,35 +800,35 @@ func SequenceT9[
 	)
 }
 
-// SequenceTuple9 converts a [T.Tuple9[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+// SequenceTuple9 converts a [T.Tuple9[func() Either[E, T]]] into a [func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func SequenceTuple9[
-	G_TUPLE9 ~func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
+	G_TUPLE9 ~func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
 	E, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t T.Tuple9[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9]) G_TUPLE9 {
 	return A.SequenceTuple9(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
-		Ap[func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
-		Ap[func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
-		Ap[G_TUPLE9, func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+		Ap[func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+		Ap[func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+		Ap[G_TUPLE9, func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
 		t)
 }
 
-// TraverseTuple9 converts a [T.Tuple9[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
+// TraverseTuple9 converts a [T.Tuple9[func() Either[E, T]]] into a [func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]]
 func TraverseTuple9[
-	G_TUPLE9 ~func() either.Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+	G_TUPLE9 ~func() Either[E, T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
@@ -838,27 +838,27 @@ func TraverseTuple9[
 	F7 ~func(A7) G_T7,
 	F8 ~func(A8) G_T8,
 	F9 ~func(A9) G_T9,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
 	E, A1, A2, A3, A4, A5, A6, A7, A8, A9, T1, T2, T3, T4, T5, T6, T7, T8, T9 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9) func(T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) G_TUPLE9 {
 	return func(t T.Tuple9[A1, A2, A3, A4, A5, A6, A7, A8, A9]) G_TUPLE9 {
 		return A.TraverseTuple9(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
-			Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
-			Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
-			Ap[func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
-			Ap[func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
-			Ap[func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() either.Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
-			Ap[G_TUPLE9, func() either.Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T3],
+			Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T4],
+			Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T5],
+			Ap[func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T6) func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T6],
+			Ap[func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T7) func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T7],
+			Ap[func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], func() Either[E, func(T8) func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T8],
+			Ap[G_TUPLE9, func() Either[E, func(T9) T.Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]], G_T9],
 			f1,
 			f2,
 			f3,
@@ -873,35 +873,35 @@ func TraverseTuple9[
 }
 
 // Eitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]
-func Eitherize10[GIOA ~func() either.Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA {
+func Eitherize10[GIOA ~func() Either[error, R], F ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error), T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f F) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA {
 	e := either.Eitherize10(f)
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) GIOA {
-		return func() either.Either[error, R] {
+		return func() Either[error, R] {
 			return e(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)
 		}
 	}
 }
 
 // Uneitherize10 converts a function with 10 parameters returning a tuple into a function with 10 parameters returning a [GIOA]
-func Uneitherize10[GIOA ~func() either.Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) {
+func Uneitherize10[GIOA ~func() Either[error, R], GTA ~func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) GIOA, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R any](f GTA) func(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) (R, error) {
 	return func(t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) (R, error) {
 		return either.Unwrap(f(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)())
 	}
 }
 
-// SequenceT10 converts 10 [func() either.Either[E, T]] into a [func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+// SequenceT10 converts 10 [func() Either[E, T]] into a [func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceT10[
-	G_TUPLE10 ~func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
-	G_T10 ~func() either.Either[E, T10],
+	G_TUPLE10 ~func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
+	G_T10 ~func() Either[E, T10],
 	E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](
 	t1 G_T1,
 	t2 G_T2,
@@ -915,16 +915,16 @@ func SequenceT10[
 	t10 G_T10,
 ) G_TUPLE10 {
 	return A.SequenceT10(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
-		Ap[func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
-		Ap[func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
-		Ap[func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
-		Ap[G_TUPLE10, func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+		Ap[func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+		Ap[func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+		Ap[func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+		Ap[G_TUPLE10, func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
 		t1,
 		t2,
 		t3,
@@ -938,37 +938,37 @@ func SequenceT10[
 	)
 }
 
-// SequenceTuple10 converts a [T.Tuple10[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+// SequenceTuple10 converts a [T.Tuple10[func() Either[E, T]]] into a [func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func SequenceTuple10[
-	G_TUPLE10 ~func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
-	G_T10 ~func() either.Either[E, T10],
+	G_TUPLE10 ~func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
+	G_T10 ~func() Either[E, T10],
 	E, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t T.Tuple10[G_T1, G_T2, G_T3, G_T4, G_T5, G_T6, G_T7, G_T8, G_T9, G_T10]) G_TUPLE10 {
 	return A.SequenceTuple10(
-		Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-		Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
-		Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
-		Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
-		Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
-		Ap[func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
-		Ap[func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
-		Ap[func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
-		Ap[func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
-		Ap[G_TUPLE10, func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+		Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+		Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
+		Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
+		Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
+		Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+		Ap[func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+		Ap[func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+		Ap[func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+		Ap[func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+		Ap[G_TUPLE10, func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
 		t)
 }
 
-// TraverseTuple10 converts a [T.Tuple10[func() either.Either[E, T]]] into a [func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
+// TraverseTuple10 converts a [T.Tuple10[func() Either[E, T]]] into a [func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]]
 func TraverseTuple10[
-	G_TUPLE10 ~func() either.Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+	G_TUPLE10 ~func() Either[E, T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
 	F1 ~func(A1) G_T1,
 	F2 ~func(A2) G_T2,
 	F3 ~func(A3) G_T3,
@@ -979,29 +979,29 @@ func TraverseTuple10[
 	F8 ~func(A8) G_T8,
 	F9 ~func(A9) G_T9,
 	F10 ~func(A10) G_T10,
-	G_T1 ~func() either.Either[E, T1],
-	G_T2 ~func() either.Either[E, T2],
-	G_T3 ~func() either.Either[E, T3],
-	G_T4 ~func() either.Either[E, T4],
-	G_T5 ~func() either.Either[E, T5],
-	G_T6 ~func() either.Either[E, T6],
-	G_T7 ~func() either.Either[E, T7],
-	G_T8 ~func() either.Either[E, T8],
-	G_T9 ~func() either.Either[E, T9],
-	G_T10 ~func() either.Either[E, T10],
+	G_T1 ~func() Either[E, T1],
+	G_T2 ~func() Either[E, T2],
+	G_T3 ~func() Either[E, T3],
+	G_T4 ~func() Either[E, T4],
+	G_T5 ~func() Either[E, T5],
+	G_T6 ~func() Either[E, T6],
+	G_T7 ~func() Either[E, T7],
+	G_T8 ~func() Either[E, T8],
+	G_T9 ~func() Either[E, T9],
+	G_T10 ~func() Either[E, T10],
 	E, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](f1 F1, f2 F2, f3 F3, f4 F4, f5 F5, f6 F6, f7 F7, f8 F8, f9 F9, f10 F10) func(T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) G_TUPLE10 {
 	return func(t T.Tuple10[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]) G_TUPLE10 {
 		return A.TraverseTuple10(
-			Map[G_T1, func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
-			Ap[func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
-			Ap[func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
-			Ap[func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
-			Ap[func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
-			Ap[func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
-			Ap[func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
-			Ap[func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
-			Ap[func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() either.Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
-			Ap[G_TUPLE10, func() either.Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
+			Map[G_T1, func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], E, T1, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]],
+			Ap[func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T2) func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T2],
+			Ap[func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T3) func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T3],
+			Ap[func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T4) func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T4],
+			Ap[func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T5) func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T5],
+			Ap[func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T6) func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T6],
+			Ap[func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T7) func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T7],
+			Ap[func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T8) func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T8],
+			Ap[func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], func() Either[E, func(T9) func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T9],
+			Ap[G_TUPLE10, func() Either[E, func(T10) T.Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]], G_T10],
 			f1,
 			f2,
 			f3,
diff --git a/v2/ioeither/generic/traverse.go b/v2/ioeither/generic/traverse.go
deleted file mode 100644
index 09f55c4..0000000
--- a/v2/ioeither/generic/traverse.go
+++ /dev/null
@@ -1,293 +0,0 @@
-// 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 generic
-
-import (
-	"github.com/IBM/fp-go/v2/either"
-	F "github.com/IBM/fp-go/v2/function"
-	RA "github.com/IBM/fp-go/v2/internal/array"
-	RR "github.com/IBM/fp-go/v2/internal/record"
-)
-
-// MonadTraverseArray transforms an array
-func MonadTraverseArray[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RA.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArray transforms an array
-func TraverseArray[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RA.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndex transforms an array
-func MonadTraverseArrayWithIndex[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
-	return RA.MonadTraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndex transforms an array
-func TraverseArrayWithIndex[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
-	return RA.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArray converts a homogeneous sequence of either into an either of sequence
-func SequenceArray[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
-	return MonadTraverseArray[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseRecord transforms an array
-func MonadTraverseRecord[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RR.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecord transforms an array
-func TraverseRecord[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RR.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndex transforms an array
-func TraverseRecordWithIndex[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
-	return RR.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		Ap[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecord converts a homogeneous sequence of either into an either of sequence
-func SequenceRecord[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
-	return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseArraySeq transforms an array
-func MonadTraverseArraySeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RA.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RA.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexSeq transforms an array
-func MonadTraverseArrayWithIndexSeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
-	return RA.MonadTraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
-	return RA.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
-	return MonadTraverseArraySeq[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseRecordSeq transforms an array
-func MonadTraverseRecordSeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RR.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordSeq transforms an array
-func TraverseRecordSeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RR.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexSeq transforms an array
-func TraverseRecordWithIndexSeq[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
-	return RR.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
-	return MonadTraverseRecordSeq[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseArrayPar transforms an array
-func MonadTraverseArrayPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RA.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RA.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexPar transforms an array
-func MonadTraverseArrayWithIndexPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](tas AAS, f func(int, A) GB) GBS {
-	return RA.MonadTraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS {
-	return RA.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS {
-	return MonadTraverseArrayPar[GA, GAS](tas, F.Identity[GA])
-}
-
-// MonadTraverseRecordPar transforms an array
-func MonadTraverseRecordPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](tas AAS, f func(A) GB) GBS {
-	return RR.MonadTraverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordPar transforms an array
-func TraverseRecordPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(A) GB) func(AAS) GBS {
-	return RR.Traverse[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexPar transforms an array
-func TraverseRecordWithIndexPar[GB ~func() either.Either[E, B], GBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, E, A, B any](f func(K, A) GB) func(AAS) GBS {
-	return RR.TraverseWithIndex[AAS](
-		Of[GBS, E, BBS],
-		Map[GBS, func() either.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() either.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[GA ~func() either.Either[E, A], GAS ~func() either.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, E, A any](tas GAAS) GAS {
-	return MonadTraverseRecordPar[GA, GAS](tas, F.Identity[GA])
-}
diff --git a/v2/ioeither/generic/types.go b/v2/ioeither/generic/types.go
new file mode 100644
index 0000000..8a229ab
--- /dev/null
+++ b/v2/ioeither/generic/types.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package generic
+
+import "github.com/IBM/fp-go/v2/either"
+
+type (
+	Either[E, A any] = either.Either[E, A]
+)
diff --git a/v2/ioeither/http/builder/builder.go b/v2/ioeither/http/builder/builder.go
index 86078e3..6e5260f 100644
--- a/v2/ioeither/http/builder/builder.go
+++ b/v2/ioeither/http/builder/builder.go
@@ -32,7 +32,7 @@ import (
 
 func Requester(builder *R.Builder) IOEH.Requester {
 
-	withBody := F.Curry3(func(data []byte, url string, method string) ioeither.IOEither[error, *http.Request] {
+	withBody := F.Curry3(func(data []byte, url string, method string) IOEither[*http.Request] {
 		return ioeither.TryCatchError(func() (*http.Request, error) {
 			req, err := http.NewRequest(method, url, bytes.NewReader(data))
 			if err == nil {
@@ -43,7 +43,7 @@ func Requester(builder *R.Builder) IOEH.Requester {
 		})
 	})
 
-	withoutBody := F.Curry2(func(url string, method string) ioeither.IOEither[error, *http.Request] {
+	withoutBody := F.Curry2(func(url string, method string) IOEither[*http.Request] {
 		return ioeither.TryCatchError(func() (*http.Request, error) {
 			req, err := http.NewRequest(method, url, nil)
 			if err == nil {
@@ -56,8 +56,8 @@ func Requester(builder *R.Builder) IOEH.Requester {
 	return F.Pipe5(
 		builder.GetBody(),
 		O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
-		E.Ap[func(string) ioeither.IOEither[error, *http.Request]](builder.GetTargetURL()),
-		E.Flap[error, ioeither.IOEither[error, *http.Request]](builder.GetMethod()),
+		E.Ap[func(string) IOEither[*http.Request]](builder.GetTargetURL()),
+		E.Flap[error, IOEither[*http.Request]](builder.GetMethod()),
 		E.GetOrElse(ioeither.Left[*http.Request, error]),
 		ioeither.Map[error](func(req *http.Request) *http.Request {
 			req.Header = H.Monoid.Concat(req.Header, builder.GetHeaders())
diff --git a/v2/ioeither/http/builder/builder_test.go b/v2/ioeither/http/builder/builder_test.go
index 51e0640..3bc8235 100644
--- a/v2/ioeither/http/builder/builder_test.go
+++ b/v2/ioeither/http/builder/builder_test.go
@@ -23,7 +23,7 @@ import (
 	E "github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
 	R "github.com/IBM/fp-go/v2/http/builder"
-	IO "github.com/IBM/fp-go/v2/io"
+	"github.com/IBM/fp-go/v2/io"
 	"github.com/IBM/fp-go/v2/ioeither"
 	"github.com/stretchr/testify/assert"
 )
@@ -45,8 +45,8 @@ func TestBuilderWithQuery(t *testing.T) {
 		ioeither.Map[error](func(r *http.Request) *url.URL {
 			return r.URL
 		}),
-		ioeither.ChainFirstIOK[error](func(u *url.URL) IO.IO[any] {
-			return IO.FromImpure(func() {
+		ioeither.ChainFirstIOK[error](func(u *url.URL) io.IO[any] {
+			return io.FromImpure(func() {
 				q := u.Query()
 				assert.Equal(t, "10", q.Get("limit"))
 				assert.Equal(t, "b", q.Get("a"))
diff --git a/v2/ioeither/http/builder/types.go b/v2/ioeither/http/builder/types.go
new file mode 100644
index 0000000..695d00a
--- /dev/null
+++ b/v2/ioeither/http/builder/types.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2025 IBM Corp.
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package builder
+
+import "github.com/IBM/fp-go/v2/ioeither"
+
+type (
+	IOEither[A any] = ioeither.IOEither[error, A]
+)
diff --git a/v2/ioeither/ioeither.go b/v2/ioeither/ioeither.go
index 585dd2d..295a8ba 100644
--- a/v2/ioeither/ioeither.go
+++ b/v2/ioeither/ioeither.go
@@ -34,19 +34,22 @@ import (
 )
 
 type (
+	IO[A any]        = io.IO[A]
+	Either[E, A any] = either.Either[E, A]
+
 	// IOEither represents a synchronous computation that may fail
 	// refer to [https://andywhite.xyz/posts/2021-01-27-rte-foundations/#ioeitherlte-agt] for more details
-	IOEither[E, A any] = io.IO[either.Either[E, A]]
+	IOEither[E, A any] = IO[Either[E, A]]
 
 	Mapper[E, A, B any] = R.Reader[IOEither[E, A], IOEither[E, B]]
 )
 
 func Left[A, E any](l E) IOEither[E, A] {
-	return eithert.Left(io.MonadOf[either.Either[E, A]], l)
+	return eithert.Left(io.MonadOf[Either[E, A]], l)
 }
 
 func Right[E, A any](r A) IOEither[E, A] {
-	return eithert.Right(io.MonadOf[either.Either[E, A]], r)
+	return eithert.Right(io.MonadOf[Either[E, A]], r)
 }
 
 func Of[E, A any](r A) IOEither[E, A] {
@@ -57,15 +60,15 @@ func MonadOf[E, A any](r A) IOEither[E, A] {
 	return Of[E](r)
 }
 
-func LeftIO[A, E any](ml io.IO[E]) IOEither[E, A] {
-	return eithert.LeftF(io.MonadMap[E, either.Either[E, A]], ml)
+func LeftIO[A, E any](ml IO[E]) IOEither[E, A] {
+	return eithert.LeftF(io.MonadMap[E, Either[E, A]], ml)
 }
 
-func RightIO[E, A any](mr io.IO[A]) IOEither[E, A] {
-	return eithert.RightF(io.MonadMap[A, either.Either[E, A]], mr)
+func RightIO[E, A any](mr IO[A]) IOEither[E, A] {
+	return eithert.RightF(io.MonadMap[A, Either[E, A]], mr)
 }
 
-func FromEither[E, A any](e either.Either[E, A]) IOEither[E, A] {
+func FromEither[E, A any](e Either[E, A]) IOEither[E, A] {
 	return io.Of(e)
 }
 
@@ -88,7 +91,7 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(I
 	)
 }
 
-func MonadChainIOK[E, A, B any](ma IOEither[E, A], f func(A) io.IO[B]) IOEither[E, B] {
+func MonadChainIOK[E, A, B any](ma IOEither[E, A], f func(A) IO[B]) IOEither[E, B] {
 	return fromio.MonadChainIOK(
 		MonadChain[E, A, B],
 		FromIO[E, B],
@@ -97,7 +100,7 @@ func MonadChainIOK[E, A, B any](ma IOEither[E, A], f func(A) io.IO[B]) IOEither[
 	)
 }
 
-func ChainIOK[E, A, B any](f func(A) io.IO[B]) func(IOEither[E, A]) IOEither[E, B] {
+func ChainIOK[E, A, B any](f func(A) IO[B]) func(IOEither[E, A]) IOEither[E, B] {
 	return fromio.ChainIOK(
 		Chain[E, A, B],
 		FromIO[E, B],
@@ -110,7 +113,7 @@ func ChainLazyK[E, A, B any](f func(A) lazy.Lazy[B]) func(IOEither[E, A]) IOEith
 }
 
 // FromIO creates an [IOEither] from an [IO] instance, invoking [IO] for each invocation of [IOEither]
-func FromIO[E, A any](mr io.IO[A]) IOEither[E, A] {
+func FromIO[E, A any](mr IO[A]) IOEither[E, A] {
 	return RightIO[E](mr)
 }
 
@@ -120,11 +123,11 @@ func FromLazy[E, A any](mr lazy.Lazy[A]) IOEither[E, A] {
 }
 
 func MonadMap[E, A, B any](fa IOEither[E, A], f func(A) B) IOEither[E, B] {
-	return eithert.MonadMap(io.MonadMap[either.Either[E, A], either.Either[E, B]], fa, f)
+	return eithert.MonadMap(io.MonadMap[Either[E, A], Either[E, B]], fa, f)
 }
 
 func Map[E, A, B any](f func(A) B) Mapper[E, A, B] {
-	return eithert.Map(io.Map[either.Either[E, A], either.Either[E, B]], f)
+	return eithert.Map(io.Map[Either[E, A], Either[E, B]], f)
 }
 
 func MonadMapTo[E, A, B any](fa IOEither[E, A], b B) IOEither[E, B] {
@@ -136,14 +139,14 @@ func MapTo[E, A, B any](b B) Mapper[E, A, B] {
 }
 
 func MonadChain[E, A, B any](fa IOEither[E, A], f func(A) IOEither[E, B]) IOEither[E, B] {
-	return eithert.MonadChain(io.MonadChain[either.Either[E, A], either.Either[E, B]], io.MonadOf[either.Either[E, B]], fa, f)
+	return eithert.MonadChain(io.MonadChain[Either[E, A], Either[E, B]], io.MonadOf[Either[E, B]], fa, f)
 }
 
 func Chain[E, A, B any](f func(A) IOEither[E, B]) Mapper[E, A, B] {
-	return eithert.Chain(io.Chain[either.Either[E, A], either.Either[E, B]], io.Of[either.Either[E, B]], f)
+	return eithert.Chain(io.Chain[Either[E, A], Either[E, B]], io.Of[Either[E, B]], f)
 }
 
-func MonadChainEitherK[E, A, B any](ma IOEither[E, A], f func(A) either.Either[E, B]) IOEither[E, B] {
+func MonadChainEitherK[E, A, B any](ma IOEither[E, A], f func(A) Either[E, B]) IOEither[E, B] {
 	return fromeither.MonadChainEitherK(
 		MonadChain[E, A, B],
 		FromEither[E, B],
@@ -152,7 +155,7 @@ func MonadChainEitherK[E, A, B any](ma IOEither[E, A], f func(A) either.Either[E
 	)
 }
 
-func ChainEitherK[E, A, B any](f func(A) either.Either[E, B]) func(IOEither[E, A]) IOEither[E, B] {
+func ChainEitherK[E, A, B any](f func(A) Either[E, B]) func(IOEither[E, A]) IOEither[E, B] {
 	return fromeither.ChainEitherK(
 		Chain[E, A, B],
 		FromEither[E, B],
@@ -162,46 +165,46 @@ func ChainEitherK[E, A, B any](f func(A) either.Either[E, B]) func(IOEither[E, A
 
 func MonadAp[B, E, A any](mab IOEither[E, func(A) B], ma IOEither[E, A]) IOEither[E, B] {
 	return eithert.MonadAp(
-		io.MonadAp[either.Either[E, A], either.Either[E, B]],
-		io.MonadMap[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.MonadAp[Either[E, A], Either[E, B]],
+		io.MonadMap[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		mab, ma)
 }
 
 // Ap is an alias of [ApPar]
 func Ap[B, E, A any](ma IOEither[E, A]) Mapper[E, func(A) B, B] {
 	return eithert.Ap(
-		io.Ap[either.Either[E, B], either.Either[E, A]],
-		io.Map[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.Ap[Either[E, B], Either[E, A]],
+		io.Map[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		ma)
 }
 
 func MonadApPar[B, E, A any](mab IOEither[E, func(A) B], ma IOEither[E, A]) IOEither[E, B] {
 	return eithert.MonadAp(
-		io.MonadApPar[either.Either[E, A], either.Either[E, B]],
-		io.MonadMap[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.MonadApPar[Either[E, A], Either[E, B]],
+		io.MonadMap[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		mab, ma)
 }
 
 // ApPar applies function and value in parallel
 func ApPar[B, E, A any](ma IOEither[E, A]) Mapper[E, func(A) B, B] {
 	return eithert.Ap(
-		io.ApPar[either.Either[E, B], either.Either[E, A]],
-		io.Map[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.ApPar[Either[E, B], Either[E, A]],
+		io.Map[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		ma)
 }
 
 func MonadApSeq[B, E, A any](mab IOEither[E, func(A) B], ma IOEither[E, A]) IOEither[E, B] {
 	return eithert.MonadAp(
-		io.MonadApSeq[either.Either[E, A], either.Either[E, B]],
-		io.MonadMap[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.MonadApSeq[Either[E, A], Either[E, B]],
+		io.MonadMap[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		mab, ma)
 }
 
 // ApSeq applies function and value sequentially
 func ApSeq[B, E, A any](ma IOEither[E, A]) func(IOEither[E, func(A) B]) IOEither[E, B] {
 	return eithert.Ap(
-		io.ApSeq[either.Either[E, B], either.Either[E, A]],
-		io.Map[either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
+		io.ApSeq[Either[E, B], Either[E, A]],
+		io.Map[Either[E, func(A) B], func(Either[E, A]) Either[E, B]],
 		ma)
 }
 
@@ -210,14 +213,14 @@ func Flatten[E, A any](mma IOEither[E, IOEither[E, A]]) IOEither[E, A] {
 }
 
 func TryCatch[E, A any](f func() (A, error), onThrow func(error) E) IOEither[E, A] {
-	return func() either.Either[E, A] {
+	return func() Either[E, A] {
 		a, err := f()
 		return either.TryCatch(a, err, onThrow)
 	}
 }
 
 func TryCatchError[A any](f func() (A, error)) IOEither[error, A] {
-	return func() either.Either[error, A] {
+	return func() Either[error, A] {
 		return either.TryCatchError(f())
 	}
 }
@@ -228,7 +231,7 @@ func Memoize[E, A any](ma IOEither[E, A]) IOEither[E, A] {
 
 func MonadMapLeft[E1, E2, A any](fa IOEither[E1, A], f func(E1) E2) IOEither[E2, A] {
 	return eithert.MonadMapLeft(
-		io.MonadMap[either.Either[E1, A], either.Either[E2, A]],
+		io.MonadMap[Either[E1, A], Either[E2, A]],
 		fa,
 		f,
 	)
@@ -236,28 +239,28 @@ func MonadMapLeft[E1, E2, A any](fa IOEither[E1, A], f func(E1) E2) IOEither[E2,
 
 func MapLeft[A, E1, E2 any](f func(E1) E2) func(IOEither[E1, A]) IOEither[E2, A] {
 	return eithert.MapLeft(
-		io.Map[either.Either[E1, A], either.Either[E2, A]],
+		io.Map[Either[E1, A], Either[E2, A]],
 		f,
 	)
 }
 
 func MonadBiMap[E1, E2, A, B any](fa IOEither[E1, A], f func(E1) E2, g func(A) B) IOEither[E2, B] {
-	return eithert.MonadBiMap(io.MonadMap[either.Either[E1, A], either.Either[E2, B]], fa, f, g)
+	return eithert.MonadBiMap(io.MonadMap[Either[E1, A], Either[E2, B]], fa, f, g)
 }
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
 func BiMap[E1, E2, A, B any](f func(E1) E2, g func(A) B) func(IOEither[E1, A]) IOEither[E2, B] {
-	return eithert.BiMap(io.Map[either.Either[E1, A], either.Either[E2, B]], f, g)
+	return eithert.BiMap(io.Map[Either[E1, A], Either[E2, B]], f, g)
 }
 
 // Fold converts an IOEither into an IO
-func Fold[E, A, B any](onLeft func(E) io.IO[B], onRight func(A) io.IO[B]) func(IOEither[E, A]) io.IO[B] {
-	return eithert.MatchE(io.MonadChain[either.Either[E, A], B], onLeft, onRight)
+func Fold[E, A, B any](onLeft func(E) IO[B], onRight func(A) IO[B]) func(IOEither[E, A]) IO[B] {
+	return eithert.MatchE(io.MonadChain[Either[E, A], B], onLeft, onRight)
 }
 
 // GetOrElse extracts the value or maps the error
-func GetOrElse[E, A any](onLeft func(E) io.IO[A]) func(IOEither[E, A]) io.IO[A] {
-	return eithert.GetOrElse(io.MonadChain[either.Either[E, A], A], io.MonadOf[A], onLeft)
+func GetOrElse[E, A any](onLeft func(E) IO[A]) func(IOEither[E, A]) IO[A] {
+	return eithert.GetOrElse(io.MonadChain[Either[E, A], A], io.MonadOf[A], onLeft)
 }
 
 // MonadChainTo composes to the second monad ignoring the return value of the first
@@ -289,7 +292,7 @@ func ChainFirst[E, A, B any](f func(A) IOEither[E, B]) Mapper[E, A, A] {
 	)
 }
 
-func MonadChainFirstEitherK[A, E, B any](ma IOEither[E, A], f func(A) either.Either[E, B]) IOEither[E, A] {
+func MonadChainFirstEitherK[A, E, B any](ma IOEither[E, A], f func(A) Either[E, B]) IOEither[E, A] {
 	return fromeither.MonadChainFirstEitherK(
 		MonadChain[E, A, A],
 		MonadMap[E, B, A],
@@ -299,7 +302,7 @@ func MonadChainFirstEitherK[A, E, B any](ma IOEither[E, A], f func(A) either.Eit
 	)
 }
 
-func ChainFirstEitherK[A, E, B any](f func(A) either.Either[E, B]) Mapper[E, A, A] {
+func ChainFirstEitherK[A, E, B any](f func(A) Either[E, B]) Mapper[E, A, A] {
 	return fromeither.ChainFirstEitherK(
 		Chain[E, A, A],
 		Map[E, B, A],
@@ -309,7 +312,7 @@ func ChainFirstEitherK[A, E, B any](f func(A) either.Either[E, B]) Mapper[E, A,
 }
 
 // MonadChainFirstIOK runs [IO] the monad returned by the function but returns the result of the original monad
-func MonadChainFirstIOK[E, A, B any](ma IOEither[E, A], f func(A) io.IO[B]) IOEither[E, A] {
+func MonadChainFirstIOK[E, A, B any](ma IOEither[E, A], f func(A) IO[B]) IOEither[E, A] {
 	return fromio.MonadChainFirstIOK(
 		MonadChain[E, A, A],
 		MonadMap[E, B, A],
@@ -320,7 +323,7 @@ func MonadChainFirstIOK[E, A, B any](ma IOEither[E, A], f func(A) io.IO[B]) IOEi
 }
 
 // ChainFirstIOK runs the [IO] monad returned by the function but returns the result of the original monad
-func ChainFirstIOK[E, A, B any](f func(A) io.IO[B]) func(IOEither[E, A]) IOEither[E, A] {
+func ChainFirstIOK[E, A, B any](f func(A) IO[B]) func(IOEither[E, A]) IOEither[E, A] {
 	return fromio.ChainFirstIOK(
 		Chain[E, A, A],
 		Map[E, B, A],
@@ -329,16 +332,16 @@ func ChainFirstIOK[E, A, B any](f func(A) io.IO[B]) func(IOEither[E, A]) IOEithe
 	)
 }
 
-func MonadFold[E, A, B any](ma IOEither[E, A], onLeft func(E) io.IO[B], onRight func(A) io.IO[B]) io.IO[B] {
-	return eithert.FoldE(io.MonadChain[either.Either[E, A], B], ma, onLeft, onRight)
+func MonadFold[E, A, B any](ma IOEither[E, A], onLeft func(E) IO[B], onRight func(A) IO[B]) IO[B] {
+	return eithert.FoldE(io.MonadChain[Either[E, A], B], ma, onLeft, onRight)
 }
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
 func WithResource[A, E, R, ANY any](onCreate IOEither[E, R], onRelease func(R) IOEither[E, ANY]) func(func(R) IOEither[E, A]) IOEither[E, A] {
 	return file.WithResource(
 		MonadChain[E, R, A],
-		MonadFold[E, A, either.Either[E, A]],
-		MonadFold[E, ANY, either.Either[E, A]],
+		MonadFold[E, A, Either[E, A]],
+		MonadFold[E, ANY, Either[E, A]],
 		MonadMap[E, ANY, A],
 		Left[A, E],
 	)(function.Constant(onCreate), onRelease)
@@ -366,8 +369,8 @@ func Defer[E, A any](gen lazy.Lazy[IOEither[E, A]]) IOEither[E, A] {
 // MonadAlt identifies an associative operation on a type constructor
 func MonadAlt[E, A any](first IOEither[E, A], second lazy.Lazy[IOEither[E, A]]) IOEither[E, A] {
 	return eithert.MonadAlt(
-		io.Of[either.Either[E, A]],
-		io.MonadChain[either.Either[E, A], either.Either[E, A]],
+		io.Of[Either[E, A]],
+		io.MonadChain[Either[E, A], Either[E, A]],
 
 		first,
 		second,
@@ -397,10 +400,10 @@ func ToIOOption[E, A any](ioe IOEither[E, A]) IOO.IOOption[A] {
 
 // Delay creates an operation that passes in the value after some delay
 func Delay[E, A any](delay time.Duration) Mapper[E, A, A] {
-	return io.Delay[either.Either[E, A]](delay)
+	return io.Delay[Either[E, A]](delay)
 }
 
 // After creates an operation that passes after the given [time.Time]
 func After[E, A any](timestamp time.Time) Mapper[E, A, A] {
-	return io.After[either.Either[E, A]](timestamp)
+	return io.After[Either[E, A]](timestamp)
 }
diff --git a/v2/ioeither/retry.go b/v2/ioeither/retry.go
index 40d1ba7..c1600ac 100644
--- a/v2/ioeither/retry.go
+++ b/v2/ioeither/retry.go
@@ -16,7 +16,6 @@
 package ioeither
 
 import (
-	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/io"
 	R "github.com/IBM/fp-go/v2/retry"
 )
@@ -29,7 +28,7 @@ import (
 func Retrying[E, A any](
 	policy R.RetryPolicy,
 	action func(R.RetryStatus) IOEither[E, A],
-	check func(either.Either[E, A]) bool,
+	check func(Either[E, A]) bool,
 ) IOEither[E, A] {
 	return io.Retrying(policy, action, check)
 }
diff --git a/v2/ioeither/sync.go b/v2/ioeither/sync.go
index ba533bf..2a32a94 100644
--- a/v2/ioeither/sync.go
+++ b/v2/ioeither/sync.go
@@ -18,11 +18,10 @@ package ioeither
 import (
 	"context"
 
-	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/io"
 )
 
 // WithLock executes the provided IO operation in the scope of a lock
-func WithLock[E, A any](lock io.IO[context.CancelFunc]) func(fa IOEither[E, A]) IOEither[E, A] {
-	return io.WithLock[either.Either[E, A]](lock)
+func WithLock[E, A any](lock IO[context.CancelFunc]) func(fa IOEither[E, A]) IOEither[E, A] {
+	return io.WithLock[Either[E, A]](lock)
 }
diff --git a/v2/ioeither/traverse.go b/v2/ioeither/traverse.go
index 556697d..f79a048 100644
--- a/v2/ioeither/traverse.go
+++ b/v2/ioeither/traverse.go
@@ -16,95 +16,169 @@
 package ioeither
 
 import (
-	G "github.com/IBM/fp-go/v2/ioeither/generic"
+	"github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/array"
+	"github.com/IBM/fp-go/v2/internal/record"
 )
 
 // TraverseArray transforms an array
 func TraverseArray[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArray[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.Traverse[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		Ap[[]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseArrayWithIndex transforms an array
 func TraverseArrayWithIndex[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayWithIndex[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.TraverseWithIndex[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		Ap[[]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
 func SequenceArray[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
-	return G.SequenceArray[IOEither[E, A], IOEither[E, []A]](ma)
+	return TraverseArray(function.Identity[IOEither[E, A]])(ma)
 }
 
 // TraverseRecord transforms a record
 func TraverseRecord[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecord[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.Traverse[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		Ap[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseRecordWithIndex transforms a record
 func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordWithIndex[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.TraverseWithIndex[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		Ap[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
 func SequenceRecord[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
-	return G.SequenceRecord[IOEither[E, A], IOEither[E, map[K]A]](ma)
+	return TraverseRecord[K](function.Identity[IOEither[E, A]])(ma)
 }
 
 // TraverseArraySeq transforms an array
 func TraverseArraySeq[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArraySeq[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.Traverse[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		ApSeq[[]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseArrayWithIndexSeq transforms an array
 func TraverseArrayWithIndexSeq[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayWithIndexSeq[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.TraverseWithIndex[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		ApSeq[[]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
 func SequenceArraySeq[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
-	return G.SequenceArraySeq[IOEither[E, A], IOEither[E, []A]](ma)
+	return TraverseArraySeq(function.Identity[IOEither[E, A]])(ma)
 }
 
 // TraverseRecordSeq transforms a record
 func TraverseRecordSeq[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordSeq[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.Traverse[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		ApSeq[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseRecordWithIndexSeq transforms a record
 func TraverseRecordWithIndexSeq[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordWithIndexSeq[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.TraverseWithIndex[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		ApSeq[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
 func SequenceRecordSeq[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
-	return G.SequenceRecordSeq[IOEither[E, A], IOEither[E, map[K]A]](ma)
+	return TraverseRecordSeq[K](function.Identity[IOEither[E, A]])(ma)
 }
 
 // TraverseArrayPar transforms an array
 func TraverseArrayPar[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayPar[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.Traverse[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		ApPar[[]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseArrayWithIndexPar transforms an array
 func TraverseArrayWithIndexPar[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] {
-	return G.TraverseArrayWithIndexPar[IOEither[E, B], IOEither[E, []B], []A](f)
+	return array.TraverseWithIndex[[]A](
+		Of[E, []B],
+		Map[E, []B, func(B) []B],
+		ApPar[[]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceArrayPar converts a homogeneous Paruence of either into an either of Paruence
 func SequenceArrayPar[E, A any](ma []IOEither[E, A]) IOEither[E, []A] {
-	return G.SequenceArrayPar[IOEither[E, A], IOEither[E, []A]](ma)
+	return TraverseArrayPar(function.Identity[IOEither[E, A]])(ma)
 }
 
 // TraverseRecordPar transforms a record
 func TraverseRecordPar[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordPar[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.Traverse[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		ApPar[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // TraverseRecordWithIndexPar transforms a record
 func TraverseRecordWithIndexPar[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] {
-	return G.TraverseRecordWithIndexPar[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f)
+	return record.TraverseWithIndex[map[K]A](
+		Of[E, map[K]B],
+		Map[E, map[K]B, func(B) map[K]B],
+		ApSeq[map[K]B, E, B],
+
+		f,
+	)
 }
 
 // SequenceRecordPar converts a homogeneous Paruence of either into an either of Paruence
 func SequenceRecordPar[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] {
-	return G.SequenceRecordPar[IOEither[E, A], IOEither[E, map[K]A]](ma)
+	return TraverseRecordPar[K](function.Identity[IOEither[E, A]])(ma)
 }
diff --git a/v2/lazy/bind.go b/v2/lazy/bind.go
index 7d2e40a..6319229 100644
--- a/v2/lazy/bind.go
+++ b/v2/lazy/bind.go
@@ -16,14 +16,14 @@
 package lazy
 
 import (
-	G "github.com/IBM/fp-go/v2/io/generic"
+	"github.com/IBM/fp-go/v2/io"
 )
 
 // Bind creates an empty context of type [S] to be used with the [Bind] operation
 func Do[S any](
 	empty S,
 ) Lazy[S] {
-	return G.Do[Lazy[S], S](empty)
+	return io.Do(empty)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -31,7 +31,7 @@ func Bind[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) Lazy[T],
 ) func(Lazy[S1]) Lazy[S2] {
-	return G.Bind[Lazy[S1], Lazy[S2], Lazy[T], S1, S2, T](setter, f)
+	return io.Bind(setter, f)
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -39,7 +39,7 @@ func Let[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) T,
 ) func(Lazy[S1]) Lazy[S2] {
-	return G.Let[Lazy[S1], Lazy[S2], S1, S2, T](setter, f)
+	return io.Let(setter, f)
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
@@ -47,14 +47,14 @@ func LetTo[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	b T,
 ) func(Lazy[S1]) Lazy[S2] {
-	return G.LetTo[Lazy[S1], Lazy[S2], S1, S2, T](setter, b)
+	return io.LetTo(setter, b)
 }
 
 // BindTo initializes a new state [S1] from a value [T]
 func BindTo[S1, T any](
 	setter func(T) S1,
 ) func(Lazy[T]) Lazy[S1] {
-	return G.BindTo[Lazy[S1], Lazy[T], S1, T](setter)
+	return io.BindTo(setter)
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
@@ -62,5 +62,5 @@ func ApS[S1, S2, T any](
 	setter func(T) func(S1) S2,
 	fa Lazy[T],
 ) func(Lazy[S1]) Lazy[S2] {
-	return G.ApS[Lazy[S1], Lazy[S2], Lazy[T], S1, S2, T](setter, fa)
+	return io.ApS(setter, fa)
 }
diff --git a/v2/readerio/reader.go b/v2/readerio/reader.go
index c8376fb..e271145 100644
--- a/v2/readerio/reader.go
+++ b/v2/readerio/reader.go
@@ -21,7 +21,7 @@ import (
 	G "github.com/IBM/fp-go/v2/readerio/generic"
 )
 
-type ReaderIO[E, A any] R.Reader[E, IO.IO[A]]
+type ReaderIO[E, A any] = R.Reader[E, IO.IO[A]]
 
 // FromIO converts an [IO.IO] to a [ReaderIO]
 func FromIO[E, A any](t IO.IO[A]) ReaderIO[E, A] {
diff --git a/v2/readerioeither/array_test.go b/v2/readerioeither/array_test.go
index f3cfb80..4e5d4ec 100644
--- a/v2/readerioeither/array_test.go
+++ b/v2/readerioeither/array_test.go
@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	A "github.com/IBM/fp-go/v2/array"
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
 	TST "github.com/IBM/fp-go/v2/internal/testing"
 	"github.com/stretchr/testify/assert"
@@ -35,9 +35,9 @@ func TestTraverseArray(t *testing.T) {
 		return Left[context.Context, string, string]("e")
 	})
 	ctx := context.Background()
-	assert.Equal(t, ET.Right[string](A.Empty[string]()), F.Pipe1(A.Empty[string](), f)(ctx)())
-	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)())
+	assert.Equal(t, either.Right[string](A.Empty[string]()), F.Pipe1(A.Empty[string](), f)(ctx)())
+	assert.Equal(t, either.Right[string]([]string{"aa", "bb"}), F.Pipe1([]string{"a", "b"}, f)(ctx)())
+	assert.Equal(t, either.Left[[]string]("e"), F.Pipe1([]string{"a", ""}, f)(ctx)())
 }
 
 func TestSequenceArray(t *testing.T) {
diff --git a/v2/readerioeither/bracket.go b/v2/readerioeither/bracket.go
index cbfe672..1b3b468 100644
--- a/v2/readerioeither/bracket.go
+++ b/v2/readerioeither/bracket.go
@@ -16,7 +16,7 @@
 package readerioeither
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	G "github.com/IBM/fp-go/v2/readerioeither/generic"
 )
 
@@ -27,7 +27,7 @@ func Bracket[
 
 	acquire ReaderIOEither[R, E, A],
 	use func(A) ReaderIOEither[R, E, B],
-	release func(A, ET.Either[E, B]) ReaderIOEither[R, E, ANY],
+	release func(A, either.Either[E, B]) ReaderIOEither[R, E, ANY],
 ) ReaderIOEither[R, E, B] {
 	return G.Bracket(acquire, use, release)
 }
diff --git a/v2/readerioeither/eq.go b/v2/readerioeither/eq.go
index 2e1e2ad..adaec0e 100644
--- a/v2/readerioeither/eq.go
+++ b/v2/readerioeither/eq.go
@@ -16,13 +16,13 @@
 package readerioeither
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	EQ "github.com/IBM/fp-go/v2/eq"
 	G "github.com/IBM/fp-go/v2/readerioeither/generic"
 )
 
 // Eq implements the equals predicate for values contained in the IOEither monad
-func Eq[R, E, A any](eq EQ.Eq[ET.Either[E, A]]) func(R) EQ.Eq[ReaderIOEither[R, E, A]] {
+func Eq[R, E, A any](eq EQ.Eq[either.Either[E, A]]) func(R) EQ.Eq[ReaderIOEither[R, E, A]] {
 	return G.Eq[ReaderIOEither[R, E, A]](eq)
 }
 
diff --git a/v2/readerioeither/generic/bind.go b/v2/readerioeither/generic/bind.go
index 98d7177..bc8b269 100644
--- a/v2/readerioeither/generic/bind.go
+++ b/v2/readerioeither/generic/bind.go
@@ -16,21 +16,21 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	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[GRS ~func(R) GS, GS ~func() ET.Either[E, S], R, E, S any](
+func Do[GRS ~func(R) GS, GS ~func() either.Either[E, S], R, E, S any](
 	empty S,
 ) GRS {
 	return Of[GRS, GS, R, E, S](empty)
 }
 
 // Bind attaches the result of a computation to a context [S1] to produce a context [S2]
-func Bind[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], R, E, S1, S2, T any](
+func Bind[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], GT ~func() either.Either[E, T], R, E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	f func(S1) GRT,
 ) func(GRS1) GRS2 {
@@ -43,7 +43,7 @@ func Bind[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GS1 ~func() ET.
 }
 
 // Let attaches the result of a computation to a context [S1] to produce a context [S2]
-func Let[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], R, E, S1, S2, T any](
+func Let[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], R, E, S1, S2, T any](
 	key func(T) func(S1) S2,
 	f func(S1) T,
 ) func(GRS1) GRS2 {
@@ -55,7 +55,7 @@ func Let[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], GS2
 }
 
 // LetTo attaches the a value to a context [S1] to produce a context [S2]
-func LetTo[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], R, E, S1, S2, B any](
+func LetTo[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], R, E, S1, S2, B any](
 	key func(B) func(S1) S2,
 	b B,
 ) func(GRS1) GRS2 {
@@ -67,7 +67,7 @@ func LetTo[GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GS1 ~func() ET.Either[E, S1], G
 }
 
 // BindTo initializes a new state [S1] from a value [T]
-func BindTo[GRS1 ~func(R) GS1, GRT ~func(R) GT, GS1 ~func() ET.Either[E, S1], GT ~func() ET.Either[E, T], R, E, S1, T any](
+func BindTo[GRS1 ~func(R) GS1, GRT ~func(R) GT, GS1 ~func() either.Either[E, S1], GT ~func() either.Either[E, T], R, E, S1, T any](
 	setter func(T) S1,
 ) func(GRT) GRS1 {
 	return C.BindTo(
@@ -77,7 +77,7 @@ func BindTo[GRS1 ~func(R) GS1, GRT ~func(R) GT, GS1 ~func() ET.Either[E, S1], GT
 }
 
 // ApS attaches a value to a context [S1] to produce a context [S2] by considering the context and the value concurrently
-func ApS[GRTS1 ~func(R) GTS1, GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GTS1 ~func() ET.Either[E, func(T) S2], GS1 ~func() ET.Either[E, S1], GS2 ~func() ET.Either[E, S2], GT ~func() ET.Either[E, T], R, E, S1, S2, T any](
+func ApS[GRTS1 ~func(R) GTS1, GRS1 ~func(R) GS1, GRS2 ~func(R) GS2, GRT ~func(R) GT, GTS1 ~func() either.Either[E, func(T) S2], GS1 ~func() either.Either[E, S1], GS2 ~func() either.Either[E, S2], GT ~func() either.Either[E, T], R, E, S1, S2, T any](
 	setter func(T) func(S1) S2,
 	fa GRT,
 ) func(GRS1) GRS2 {
diff --git a/v2/readerioeither/generic/bracket.go b/v2/readerioeither/generic/bracket.go
index 0c32999..93f2841 100644
--- a/v2/readerioeither/generic/bracket.go
+++ b/v2/readerioeither/generic/bracket.go
@@ -16,7 +16,7 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	G "github.com/IBM/fp-go/v2/internal/bracket"
 	I "github.com/IBM/fp-go/v2/readerio/generic"
 )
@@ -28,20 +28,20 @@ func Bracket[
 	GB ~func(R) TB,
 	GANY ~func(R) TANY,
 
-	TA ~func() ET.Either[E, A],
-	TB ~func() ET.Either[E, B],
-	TANY ~func() ET.Either[E, ANY],
+	TA ~func() either.Either[E, A],
+	TB ~func() either.Either[E, B],
+	TANY ~func() either.Either[E, ANY],
 
 	R, E, A, B, ANY any](
 
 	acquire GA,
 	use func(A) GB,
-	release func(A, ET.Either[E, B]) GANY,
+	release func(A, either.Either[E, B]) GANY,
 ) GB {
-	return G.Bracket[GA, GB, GANY, ET.Either[E, B], A, B](
-		I.Of[GB, TB, R, ET.Either[E, B]],
+	return G.Bracket[GA, GB, GANY, either.Either[E, B], A, B](
+		I.Of[GB, TB, R, either.Either[E, B]],
 		MonadChain[GA, GB, TA, TB, R, E, A, B],
-		I.MonadChain[GB, GB, TB, TB, R, ET.Either[E, B], ET.Either[E, B]],
+		I.MonadChain[GB, GB, TB, TB, R, either.Either[E, B], either.Either[E, B]],
 		MonadChain[GANY, GB, TANY, TB, R, E, ANY, B],
 
 		acquire,
diff --git a/v2/readerioeither/generic/eq.go b/v2/readerioeither/generic/eq.go
index 28101cc..e3fb240 100644
--- a/v2/readerioeither/generic/eq.go
+++ b/v2/readerioeither/generic/eq.go
@@ -16,17 +16,17 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	EQ "github.com/IBM/fp-go/v2/eq"
 	G "github.com/IBM/fp-go/v2/readerio/generic"
 )
 
 // Eq implements the equals predicate for values contained in the IOEither monad
-func Eq[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](eq EQ.Eq[ET.Either[E, A]]) func(R) EQ.Eq[GEA] {
+func Eq[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](eq EQ.Eq[either.Either[E, A]]) func(R) EQ.Eq[GEA] {
 	return G.Eq[GEA](eq)
 }
 
 // FromStrictEquals constructs an [EQ.Eq] from the canonical comparison function
-func FromStrictEquals[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R any, E, A comparable]() func(R) EQ.Eq[GEA] {
-	return Eq[GEA](ET.FromStrictEquals[E, A]())
+func FromStrictEquals[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R any, E, A comparable]() func(R) EQ.Eq[GEA] {
+	return Eq[GEA](either.FromStrictEquals[E, A]())
 }
diff --git a/v2/readerioeither/generic/gen.go b/v2/readerioeither/generic/gen.go
index 050394b..3ac6c08 100644
--- a/v2/readerioeither/generic/gen.go
+++ b/v2/readerioeither/generic/gen.go
@@ -5,13 +5,13 @@ package generic
 
 import (
 	E "github.com/IBM/fp-go/v2/either"
-	RD "github.com/IBM/fp-go/v2/reader/generic"
+	reader "github.com/IBM/fp-go/v2/reader/generic"
 )
 
 // From0 converts a function with 1 parameters returning a tuple into a function with 0 parameters returning a [GRA]
 // The first parameter is considerd to be the context [C].
 func From0[GRA ~func(C) GIOA, F ~func(C) func() (R, error), GIOA ~func() E.Either[error, R], C, R any](f F) func() GRA {
-	return RD.From0[GRA](func(r C) GIOA {
+	return reader.From0[GRA](func(r C) GIOA {
 		return E.Eitherize0(f(r))
 	})
 }
@@ -37,7 +37,7 @@ func Uneitherize0[GRA ~func(C) GIOA, F ~func(C) (R, error), GIOA ~func() E.Eithe
 // 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 {
-	return RD.From1[GRA](func(r C, t0 T0) GIOA {
+	return reader.From1[GRA](func(r C, t0 T0) GIOA {
 		return E.Eitherize0(f(r, t0))
 	})
 }
@@ -63,7 +63,7 @@ func Uneitherize1[GRA ~func(C) GIOA, F ~func(C, T0) (R, error), GIOA ~func() E.E
 // 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 {
-	return RD.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
+	return reader.From2[GRA](func(r C, t0 T0, t1 T1) GIOA {
 		return E.Eitherize0(f(r, t0, t1))
 	})
 }
@@ -89,7 +89,7 @@ func Uneitherize2[GRA ~func(C) GIOA, F ~func(C, T0, T1) (R, error), GIOA ~func()
 // 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 {
-	return RD.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
+	return reader.From3[GRA](func(r C, t0 T0, t1 T1, t2 T2) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2))
 	})
 }
@@ -115,7 +115,7 @@ func Uneitherize3[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2) (R, error), GIOA ~fu
 // 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 {
-	return RD.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
+	return reader.From4[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3))
 	})
 }
@@ -141,7 +141,7 @@ func Uneitherize4[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3) (R, error), GIOA
 // 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 {
-	return RD.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
+	return reader.From5[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4))
 	})
 }
@@ -167,7 +167,7 @@ func Uneitherize5[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4) (R, error),
 // 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 {
-	return RD.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
+	return reader.From6[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5))
 	})
 }
@@ -193,7 +193,7 @@ func Uneitherize6[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5) (R, erro
 // 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 {
-	return RD.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
+	return reader.From7[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6))
 	})
 }
@@ -219,7 +219,7 @@ func Uneitherize7[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6) (R,
 // 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 {
-	return RD.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
+	return reader.From8[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7))
 	})
 }
@@ -245,7 +245,7 @@ func Uneitherize8[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7)
 // 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 {
-	return RD.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
+	return reader.From9[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8))
 	})
 }
@@ -271,7 +271,7 @@ func Uneitherize9[GRA ~func(C) GIOA, F ~func(C, T0, T1, T2, T3, T4, T5, T6, T7,
 // 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 {
-	return RD.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
+	return reader.From10[GRA](func(r C, t0 T0, t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) GIOA {
 		return E.Eitherize0(f(r, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9))
 	})
 }
diff --git a/v2/readerioeither/generic/monad.go b/v2/readerioeither/generic/monad.go
index 32a844e..0a2ab74 100644
--- a/v2/readerioeither/generic/monad.go
+++ b/v2/readerioeither/generic/monad.go
@@ -16,17 +16,17 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/internal/functor"
 	"github.com/IBM/fp-go/v2/internal/monad"
 	"github.com/IBM/fp-go/v2/internal/pointed"
 )
 
-type readerIOEitherPointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() ET.Either[E, A]] struct{}
+type readerIOEitherPointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() either.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 readerIOEitherMonad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GIOAB ~func() either.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{}
+type readerIOEitherFunctor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B]] struct{}
 
 func (o *readerIOEitherPointed[R, E, A, GRA, GIOA]) Of(a A) GRA {
 	return Of[GRA, GIOA, R, E, A](a)
@@ -53,16 +53,16 @@ func (o *readerIOEitherFunctor[R, E, A, B, GRA, GRB, GIOA, GIOB]) Map(f func(A)
 }
 
 // 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] {
+func Pointed[R, E, A any, GRA ~func(R) GIOA, GIOA ~func() either.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] {
+func Functor[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.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] {
+func Monad[R, E, A, B any, GRA ~func(R) GIOA, GRB ~func(R) GIOB, GRAB ~func(R) GIOAB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GIOAB ~func() either.Either[E, func(A) B]]() monad.Monad[A, B, GRA, GRB, GRAB] {
 	return &readerIOEitherMonad[R, E, A, B, GRA, GRB, GRAB, GIOA, GIOB, GIOAB]{}
 }
diff --git a/v2/readerioeither/generic/reader.go b/v2/readerioeither/generic/reader.go
index 830ba9c..03f44a4 100644
--- a/v2/readerioeither/generic/reader.go
+++ b/v2/readerioeither/generic/reader.go
@@ -16,7 +16,7 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
 	C "github.com/IBM/fp-go/v2/internal/chain"
 	"github.com/IBM/fp-go/v2/internal/eithert"
@@ -32,11 +32,11 @@ import (
 )
 
 // MakeReader constructs an instance of a reader
-func MakeReader[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](f func(R) GIOA) GEA {
+func MakeReader[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](f func(R) GIOA) GEA {
 	return f
 }
 
-func MonadAlt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](first GEA, second LAZY) GEA {
+func MonadAlt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](first GEA, second LAZY) GEA {
 	return eithert.MonadAlt(
 		G.Of[GEA],
 		G.MonadChain[GEA, GEA],
@@ -46,39 +46,39 @@ func MonadAlt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A],
 	)
 }
 
-func Alt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](second LAZY) func(GEA) GEA {
+func Alt[LAZY ~func() GEA, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](second LAZY) func(GEA) GEA {
 	return F.Bind2nd(MonadAlt[LAZY], second)
 }
 
-func MonadMap[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](fa GEA, f func(A) B) GEB {
-	return eithert.MonadMap(G.MonadMap[GEA, GEB, GIOA, GIOB, R, ET.Either[E, A], ET.Either[E, B]], fa, f)
+func MonadMap[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](fa GEA, f func(A) B) GEB {
+	return eithert.MonadMap(G.MonadMap[GEA, GEB, GIOA, GIOB, R, either.Either[E, A], either.Either[E, B]], fa, f)
 }
 
-func Map[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](f func(A) B) func(GEA) GEB {
+func Map[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](f func(A) B) func(GEA) GEB {
 	return F.Bind2nd(MonadMap[GEA, GEB, GIOA, GIOB, R, E, A, B], f)
 }
 
-func MonadMapTo[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](fa GEA, b B) GEB {
+func MonadMapTo[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](fa GEA, b B) GEB {
 	return MonadMap[GEA, GEB](fa, F.Constant1[A](b))
 }
 
-func MapTo[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](b B) func(GEA) GEB {
+func MapTo[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](b B) func(GEA) GEB {
 	return Map[GEA, GEB](F.Constant1[A](b))
 }
 
-func MonadChain[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](fa GEA, f func(A) GEB) GEB {
+func MonadChain[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](fa GEA, f func(A) GEB) GEB {
 	return eithert.MonadChain(
-		G.MonadChain[GEA, GEB, GIOA, GIOB, R, ET.Either[E, A], ET.Either[E, B]],
-		G.Of[GEB, GIOB, R, ET.Either[E, B]],
+		G.MonadChain[GEA, GEB, GIOA, GIOB, R, either.Either[E, A], either.Either[E, B]],
+		G.Of[GEB, GIOB, R, either.Either[E, B]],
 		fa,
 		f)
 }
 
-func Chain[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](f func(A) GEB) func(fa GEA) GEB {
+func Chain[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](f func(A) GEB) func(fa GEA) GEB {
 	return F.Bind2nd(MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B], f)
 }
 
-func MonadChainFirst[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](fa GEA, f func(A) GEB) GEA {
+func MonadChainFirst[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](fa GEA, f func(A) GEB) GEA {
 	return C.MonadChainFirst(
 		MonadChain[GEA, GEA, GIOA, GIOA, R, E, A, A],
 		MonadMap[GEB, GEA, GIOB, GIOA, R, E, B, A],
@@ -86,11 +86,11 @@ func MonadChainFirst[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Eithe
 		f)
 }
 
-func ChainFirst[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](f func(A) GEB) func(fa GEA) GEA {
+func ChainFirst[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](f func(A) GEB) func(fa GEA) GEA {
 	return F.Bind2nd(MonadChainFirst[GEA, GEB, GIOA, GIOB, R, E, A, B], f)
 }
 
-func MonadChainEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](ma GEA, f func(A) ET.Either[E, B]) GEB {
+func MonadChainEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](ma GEA, f func(A) either.Either[E, B]) GEB {
 	return FE.MonadChainEitherK(
 		MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B],
 		FromEither[GEB, GIOB, R, E, B],
@@ -99,39 +99,39 @@ func MonadChainEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Eit
 	)
 }
 
-func ChainEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](f func(A) ET.Either[E, B]) func(ma GEA) GEB {
+func ChainEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](f func(A) either.Either[E, B]) func(ma GEA) GEB {
 	return F.Bind2nd(MonadChainEitherK[GEA, GEB, GIOA, GIOB, R, E, A, B], f)
 }
 
-func MonadChainFirstEitherK[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A, B any](ma GEA, f func(A) ET.Either[E, B]) GEA {
+func MonadChainFirstEitherK[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A, B any](ma GEA, f func(A) either.Either[E, B]) GEA {
 	return FE.MonadChainFirstEitherK(
 		MonadChain[GEA, GEA, GIOA, GIOA, R, E, A, A],
-		MonadMap[func(R) func() ET.Either[E, B], GEA, func() ET.Either[E, B], GIOA, R, E, B, A],
-		FromEither[func(R) func() ET.Either[E, B], func() ET.Either[E, B], R, E, B],
+		MonadMap[func(R) func() either.Either[E, B], GEA, func() either.Either[E, B], GIOA, R, E, B, A],
+		FromEither[func(R) func() either.Either[E, B], func() either.Either[E, B], R, E, B],
 		ma,
 		f,
 	)
 }
 
-func ChainFirstEitherK[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A, B any](f func(A) ET.Either[E, B]) func(ma GEA) GEA {
+func ChainFirstEitherK[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A, B any](f func(A) either.Either[E, B]) func(ma GEA) GEA {
 	return F.Bind2nd(MonadChainFirstEitherK[GEA, GIOA, R, E, A, B], f)
 }
 
-func MonadChainFirstIOK[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GIO ~func() B, R, E, A, B any](ma GEA, f func(A) GIO) GEA {
+func MonadChainFirstIOK[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GIO ~func() B, R, E, A, B any](ma GEA, f func(A) GIO) GEA {
 	return FIO.MonadChainFirstIOK(
 		MonadChain[GEA, GEA, GIOA, GIOA, R, E, A, A],
-		MonadMap[func(R) func() ET.Either[E, B], GEA, func() ET.Either[E, B], GIOA, R, E, B, A],
-		FromIO[func(R) func() ET.Either[E, B], func() ET.Either[E, B], GIO, R, E, B],
+		MonadMap[func(R) func() either.Either[E, B], GEA, func() either.Either[E, B], GIOA, R, E, B, A],
+		FromIO[func(R) func() either.Either[E, B], func() either.Either[E, B], GIO, R, E, B],
 		ma,
 		f,
 	)
 }
 
-func ChainFirstIOK[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GIO ~func() B, R, E, A, B any](f func(A) GIO) func(GEA) GEA {
+func ChainFirstIOK[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GIO ~func() B, R, E, A, B any](f func(A) GIO) func(GEA) GEA {
 	return F.Bind2nd(MonadChainFirstIOK[GEA, GIOA, GIO, R, E, A, B], f)
 }
 
-func MonadChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GB ~func(R) B, R, E, A, B any](ma GEA, f func(A) GB) GEB {
+func MonadChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GB ~func(R) B, R, E, A, B any](ma GEA, f func(A) GB) GEB {
 	return FR.MonadChainReaderK(
 		MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B],
 		FromReader[GB, GEB, GIOB, R, E, B],
@@ -140,7 +140,7 @@ func MonadChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Eit
 	)
 }
 
-func ChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GB ~func(R) B, R, E, A, B any](f func(A) GB) func(GEA) GEB {
+func ChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GB ~func(R) B, R, E, A, B any](f func(A) GB) func(GEA) GEB {
 	return FR.ChainReaderK(
 		MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B],
 		FromReader[GB, GEB, GIOB, R, E, B],
@@ -148,7 +148,7 @@ func ChainReaderK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E
 	)
 }
 
-func MonadChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() ET.Either[E, A], GIOEB ~func() ET.Either[E, B], GIOB ~func() B, GB ~func(R) GIOB, R, E, A, B any](ma GEA, f func(A) GB) GEB {
+func MonadChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() either.Either[E, A], GIOEB ~func() either.Either[E, B], GIOB ~func() B, GB ~func(R) GIOB, R, E, A, B any](ma GEA, f func(A) GB) GEB {
 	return FR.MonadChainReaderK(
 		MonadChain[GEA, GEB, GIOEA, GIOEB, R, E, A, B],
 		RightReaderIO[GEB, GIOEB, GB, GIOB, R, E, B],
@@ -157,7 +157,7 @@ func MonadChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() E
 	)
 }
 
-func ChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() ET.Either[E, A], GIOEB ~func() ET.Either[E, B], GIOB ~func() B, GB ~func(R) GIOB, R, E, A, B any](f func(A) GB) func(GEA) GEB {
+func ChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() either.Either[E, A], GIOEB ~func() either.Either[E, B], GIOB ~func() B, GB ~func(R) GIOB, R, E, A, B any](f func(A) GB) func(GEA) GEB {
 	return FR.ChainReaderK(
 		MonadChain[GEA, GEB, GIOEA, GIOEB, R, E, A, B],
 		RightReaderIO[GEB, GIOEB, GB, GIOB, R, E, B],
@@ -165,7 +165,7 @@ func ChainReaderIOK[GEA ~func(R) GIOEA, GEB ~func(R) GIOEB, GIOEA ~func() ET.Eit
 	)
 }
 
-func MonadChainIOEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](ma GEA, f func(A) GIOB) GEB {
+func MonadChainIOEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](ma GEA, f func(A) GIOB) GEB {
 	return FIOE.MonadChainIOEitherK(
 		MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B],
 		FromIOEither[GEB, GIOB, R, E, B],
@@ -174,11 +174,11 @@ func MonadChainIOEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.E
 	)
 }
 
-func ChainIOEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](f func(A) GIOB) func(GEA) GEB {
+func ChainIOEitherK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](f func(A) GIOB) func(GEA) GEB {
 	return F.Bind2nd(MonadChainIOEitherK[GEA, GEB, GIOA, GIOB, R, E, A, B], f)
 }
 
-func MonadChainIOK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIO ~func() B, R, E, A, B any](ma GEA, f func(A) GIO) GEB {
+func MonadChainIOK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GIO ~func() B, R, E, A, B any](ma GEA, f func(A) GIO) GEB {
 	return FIO.MonadChainIOK(
 		MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B],
 		FromIO[GEB, GIOB, GIO, R, E, B],
@@ -187,11 +187,11 @@ func MonadChainIOK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[
 	)
 }
 
-func ChainIOK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], GIO ~func() B, R, E, A, B any](f func(A) GIO) func(GEA) GEB {
+func ChainIOK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], GIO ~func() B, R, E, A, B any](f func(A) GIO) func(GEA) GEB {
 	return F.Bind2nd(MonadChainIOK[GEA, GEB, GIOA, GIOB, GIO, R, E, A, B], f)
 }
 
-func ChainOptionK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() ET.Either[E, A], GIOB ~func() ET.Either[E, B], R, E, A, B any](onNone func() E) func(func(A) O.Option[B]) func(GEA) GEB {
+func ChainOptionK[GEA ~func(R) GIOA, GEB ~func(R) GIOB, GIOA ~func() either.Either[E, A], GIOB ~func() either.Either[E, B], R, E, A, B any](onNone func() E) func(func(A) O.Option[B]) func(GEA) GEB {
 	return FE.ChainOptionK(MonadChain[GEA, GEB, GIOA, GIOB, R, E, A, B], FromEither[GEB, GIOB, R, E, B], onNone)
 }
 
@@ -199,14 +199,14 @@ func MonadAp[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fab GEFAB, fa GEA) GEB {
 
 	return eithert.MonadAp(
-		G.MonadAp[GEA, GEB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOA, GIOB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, A], ET.Either[E, B]],
-		G.MonadMap[GEFAB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOFAB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
+		G.MonadAp[GEA, GEB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOA, GIOB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, A], either.Either[E, B]],
+		G.MonadMap[GEFAB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOFAB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
 		fab,
 		fa,
 	)
@@ -216,9 +216,9 @@ func Ap[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fa GEA) func(fab GEFAB) GEB {
 	return F.Bind2nd(MonadAp[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa)
 }
@@ -227,14 +227,14 @@ func MonadApSeq[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fab GEFAB, fa GEA) GEB {
 
 	return eithert.MonadAp(
-		G.MonadApSeq[GEA, GEB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOA, GIOB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, A], ET.Either[E, B]],
-		G.MonadMap[GEFAB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOFAB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
+		G.MonadApSeq[GEA, GEB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOA, GIOB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, A], either.Either[E, B]],
+		G.MonadMap[GEFAB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOFAB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
 		fab,
 		fa,
 	)
@@ -244,9 +244,9 @@ func ApSeq[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fa GEA) func(fab GEFAB) GEB {
 	return F.Bind2nd(MonadApSeq[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa)
 }
@@ -255,14 +255,14 @@ func MonadApPar[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fab GEFAB, fa GEA) GEB {
 
 	return eithert.MonadAp(
-		G.MonadApPar[GEA, GEB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOA, GIOB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, A], ET.Either[E, B]],
-		G.MonadMap[GEFAB, func(R) func() func(ET.Either[E, A]) ET.Either[E, B], GIOFAB, func() func(ET.Either[E, A]) ET.Either[E, B], R, ET.Either[E, func(A) B], func(ET.Either[E, A]) ET.Either[E, B]],
+		G.MonadApPar[GEA, GEB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOA, GIOB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, A], either.Either[E, B]],
+		G.MonadMap[GEFAB, func(R) func() func(either.Either[E, A]) either.Either[E, B], GIOFAB, func() func(either.Either[E, A]) either.Either[E, B], R, either.Either[E, func(A) B], func(either.Either[E, A]) either.Either[E, B]],
 		fab,
 		fa,
 	)
@@ -272,55 +272,55 @@ func ApPar[
 	GEA ~func(R) GIOA,
 	GEB ~func(R) GIOB,
 	GEFAB ~func(R) GIOFAB,
-	GIOA ~func() ET.Either[E, A],
-	GIOB ~func() ET.Either[E, B],
-	GIOFAB ~func() ET.Either[E, func(A) B],
+	GIOA ~func() either.Either[E, A],
+	GIOB ~func() either.Either[E, B],
+	GIOFAB ~func() either.Either[E, func(A) B],
 	R, E, A, B any](fa GEA) func(fab GEFAB) GEB {
 	return F.Bind2nd(MonadApPar[GEA, GEB, GEFAB, GIOA, GIOB, GIOFAB, R, E, A, B], fa)
 }
 
-func Right[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](a A) GEA {
-	return eithert.Right(G.Of[GEA, GIOA, R, ET.Either[E, A]], a)
+func Right[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](a A) GEA {
+	return eithert.Right(G.Of[GEA, GIOA, R, either.Either[E, A]], a)
 }
 
-func Left[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](e E) GEA {
-	return eithert.Left(G.Of[GEA, GIOA, R, ET.Either[E, A]], e)
+func Left[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](e E) GEA {
+	return eithert.Left(G.Of[GEA, GIOA, R, either.Either[E, A]], e)
 }
 
-func ThrowError[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](e E) GEA {
+func ThrowError[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](e E) GEA {
 	return Left[GEA](e)
 }
 
 // Of returns a Reader with a fixed value
-func Of[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](a A) GEA {
+func Of[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](a A) GEA {
 	return Right[GEA](a)
 }
 
-func Flatten[GEA ~func(R) GIOA, GGEA ~func(R) GIOEA, GIOA ~func() ET.Either[E, A], GIOEA ~func() ET.Either[E, GEA], R, E, A any](mma GGEA) GEA {
+func Flatten[GEA ~func(R) GIOA, GGEA ~func(R) GIOEA, GIOA ~func() either.Either[E, A], GIOEA ~func() either.Either[E, GEA], R, E, A any](mma GGEA) GEA {
 	return MonadChain(mma, F.Identity[GEA])
 }
 
-func FromIOEither[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](t GIOA) GEA {
+func FromIOEither[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](t GIOA) GEA {
 	return RD.Of[GEA](t)
 }
 
-func FromEither[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](t ET.Either[E, A]) GEA {
+func FromEither[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](t either.Either[E, A]) GEA {
 	return G.Of[GEA](t)
 }
 
-func RightReader[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](ma GA) GEA {
+func RightReader[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](ma GA) GEA {
 	return F.Flow2(ma, IOE.Right[GIOA, E, A])
 }
 
-func LeftReader[GE ~func(R) E, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](ma GE) GEA {
+func LeftReader[GE ~func(R) E, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](ma GE) GEA {
 	return F.Flow2(ma, IOE.Left[GIOA, E, A])
 }
 
-func FromReader[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](ma GA) GEA {
+func FromReader[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](ma GA) GEA {
 	return RightReader[GA, GEA](ma)
 }
 
-func MonadFromReaderIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](a A, f func(A) GRIO) GEA {
+func MonadFromReaderIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](a A, f func(A) GRIO) GEA {
 	return F.Pipe2(
 		a,
 		f,
@@ -328,98 +328,98 @@ func MonadFromReaderIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GRIO ~fu
 	)
 }
 
-func FromReaderIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](f func(A) GRIO) func(A) GEA {
+func FromReaderIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](f func(A) GRIO) func(A) GEA {
 	return F.Bind2nd(MonadFromReaderIO[GEA, GIOA, GRIO, GIO, R, E, A], f)
 }
 
-func RightReaderIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](ma GRIO) GEA {
+func RightReaderIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GRIO ~func(R) GIO, GIO ~func() A, R, E, A any](ma GRIO) GEA {
 	return eithert.RightF(
-		G.MonadMap[GRIO, GEA, GIO, GIOA, R, A, ET.Either[E, A]],
+		G.MonadMap[GRIO, GEA, GIO, GIOA, R, A, either.Either[E, A]],
 		ma,
 	)
 }
 
-func LeftReaderIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GRIO ~func(R) GIO, GIO ~func() E, R, E, A any](me GRIO) GEA {
+func LeftReaderIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GRIO ~func(R) GIO, GIO ~func() E, R, E, A any](me GRIO) GEA {
 	return eithert.LeftF(
-		G.MonadMap[GRIO, GEA, GIO, GIOA, R, E, ET.Either[E, A]],
+		G.MonadMap[GRIO, GEA, GIO, GIOA, R, E, either.Either[E, A]],
 		me,
 	)
 }
 
-func RightIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GR ~func() A, R, E, A any](ma GR) GEA {
+func RightIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GR ~func() A, R, E, A any](ma GR) GEA {
 	return F.Pipe2(ma, IOE.RightIO[GIOA, GR, E, A], FromIOEither[GEA, GIOA, R, E, A])
 }
 
-func LeftIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GR ~func() E, R, E, A any](ma GR) GEA {
+func LeftIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GR ~func() E, R, E, A any](ma GR) GEA {
 	return F.Pipe2(ma, IOE.LeftIO[GIOA, GR, E, A], FromIOEither[GEA, GIOA, R, E, A])
 }
 
-func FromIO[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], GR ~func() A, R, E, A any](ma GR) GEA {
+func FromIO[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], GR ~func() A, R, E, A any](ma GR) GEA {
 	return RightIO[GEA](ma)
 }
 
-func FromReaderEither[GA ~func(R) ET.Either[E, A], GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](ma GA) GEA {
+func FromReaderEither[GA ~func(R) either.Either[E, A], GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](ma GA) GEA {
 	return F.Flow2(ma, IOE.FromEither[GIOA, E, A])
 }
 
-func Ask[GER ~func(R) GIOR, GIOR ~func() ET.Either[E, R], R, E any]() GER {
+func Ask[GER ~func(R) GIOR, GIOR ~func() either.Either[E, R], R, E any]() GER {
 	return FR.Ask(FromReader[func(R) R, GER, GIOR, R, E, R])()
 }
 
-func Asks[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](r GA) GEA {
+func Asks[GA ~func(R) A, GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](r GA) GEA {
 	return FR.Asks(FromReader[GA, GEA, GIOA, R, E, A])(r)
 }
 
-func FromOption[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](onNone func() E) func(O.Option[A]) GEA {
+func FromOption[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](onNone func() E) func(O.Option[A]) GEA {
 	return FE.FromOption(FromEither[GEA, GIOA, R, E, A], onNone)
 }
 
-func FromPredicate[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](pred func(A) bool, onFalse func(A) E) func(A) GEA {
+func FromPredicate[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](pred func(A) bool, onFalse func(A) E) func(A) GEA {
 	return FE.FromPredicate(FromEither[GEA, GIOA, R, E, A], pred, onFalse)
 }
 
-func Fold[GB ~func(R) GIOB, GEA ~func(R) GIOA, GIOB ~func() B, GIOA ~func() ET.Either[E, A], R, E, A, B any](onLeft func(E) GB, onRight func(A) GB) func(GEA) GB {
-	return eithert.MatchE(G.MonadChain[GEA, GB, GIOA, GIOB, R, ET.Either[E, A], B], onLeft, onRight)
+func Fold[GB ~func(R) GIOB, GEA ~func(R) GIOA, GIOB ~func() B, GIOA ~func() either.Either[E, A], R, E, A, B any](onLeft func(E) GB, onRight func(A) GB) func(GEA) GB {
+	return eithert.MatchE(G.MonadChain[GEA, GB, GIOA, GIOB, R, either.Either[E, A], B], onLeft, onRight)
 }
 
-func GetOrElse[GA ~func(R) GIOB, GEA ~func(R) GIOA, GIOB ~func() A, GIOA ~func() ET.Either[E, A], R, E, A any](onLeft func(E) GA) func(GEA) GA {
-	return eithert.GetOrElse(G.MonadChain[GEA, GA, GIOA, GIOB, R, ET.Either[E, A], A], G.Of[GA, GIOB, R, A], onLeft)
+func GetOrElse[GA ~func(R) GIOB, GEA ~func(R) GIOA, GIOB ~func() A, GIOA ~func() either.Either[E, A], R, E, A any](onLeft func(E) GA) func(GEA) GA {
+	return eithert.GetOrElse(G.MonadChain[GEA, GA, GIOA, GIOB, R, either.Either[E, A], A], G.Of[GA, GIOB, R, A], onLeft)
 }
 
-func OrElse[GEA1 ~func(R) GIOA1, GEA2 ~func(R) GIOA2, GIOA1 ~func() ET.Either[E1, A], GIOA2 ~func() ET.Either[E2, A], R, E1, A, E2 any](onLeft func(E1) GEA2) func(GEA1) GEA2 {
-	return eithert.OrElse(G.MonadChain[GEA1, GEA2, GIOA1, GIOA2, R, ET.Either[E1, A], ET.Either[E2, A]], G.Of[GEA2, GIOA2, R, ET.Either[E2, A]], onLeft)
+func OrElse[GEA1 ~func(R) GIOA1, GEA2 ~func(R) GIOA2, GIOA1 ~func() either.Either[E1, A], GIOA2 ~func() either.Either[E2, A], R, E1, A, E2 any](onLeft func(E1) GEA2) func(GEA1) GEA2 {
+	return eithert.OrElse(G.MonadChain[GEA1, GEA2, GIOA1, GIOA2, R, either.Either[E1, A], either.Either[E2, A]], G.Of[GEA2, GIOA2, R, either.Either[E2, A]], onLeft)
 }
 
-func OrLeft[GEA1 ~func(R) GIOA1, GE2 ~func(R) GIOE2, GEA2 ~func(R) GIOA2, GIOA1 ~func() ET.Either[E1, A], GIOE2 ~func() E2, GIOA2 ~func() ET.Either[E2, A], E1, R, E2, A any](onLeft func(E1) GE2) func(GEA1) GEA2 {
+func OrLeft[GEA1 ~func(R) GIOA1, GE2 ~func(R) GIOE2, GEA2 ~func(R) GIOA2, GIOA1 ~func() either.Either[E1, A], GIOE2 ~func() E2, GIOA2 ~func() either.Either[E2, A], E1, R, E2, A any](onLeft func(E1) GE2) func(GEA1) GEA2 {
 	return eithert.OrLeft(
-		G.MonadChain[GEA1, GEA2, GIOA1, GIOA2, R, ET.Either[E1, A], ET.Either[E2, A]],
-		G.MonadMap[GE2, GEA2, GIOE2, GIOA2, R, E2, ET.Either[E2, A]],
-		G.Of[GEA2, GIOA2, R, ET.Either[E2, A]],
+		G.MonadChain[GEA1, GEA2, GIOA1, GIOA2, R, either.Either[E1, A], either.Either[E2, A]],
+		G.MonadMap[GE2, GEA2, GIOE2, GIOA2, R, E2, either.Either[E2, A]],
+		G.Of[GEA2, GIOA2, R, either.Either[E2, A]],
 		onLeft,
 	)
 }
 
-func MonadBiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() ET.Either[E1, A], GE2B ~func() ET.Either[E2, B], R, E1, E2, A, B any](fa GA, f func(E1) E2, g func(A) B) GB {
-	return eithert.MonadBiMap(G.MonadMap[GA, GB, GE1A, GE2B, R, ET.Either[E1, A], ET.Either[E2, B]], fa, f, g)
+func MonadBiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() either.Either[E1, A], GE2B ~func() either.Either[E2, B], R, E1, E2, A, B any](fa GA, f func(E1) E2, g func(A) B) GB {
+	return eithert.MonadBiMap(G.MonadMap[GA, GB, GE1A, GE2B, R, either.Either[E1, A], either.Either[E2, B]], fa, f, g)
 }
 
 // BiMap maps a pair of functions over the two type arguments of the bifunctor.
-func BiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() ET.Either[E1, A], GE2B ~func() ET.Either[E2, B], R, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
-	return eithert.BiMap(G.Map[GA, GB, GE1A, GE2B, R, ET.Either[E1, A], ET.Either[E2, B]], f, g)
+func BiMap[GA ~func(R) GE1A, GB ~func(R) GE2B, GE1A ~func() either.Either[E1, A], GE2B ~func() either.Either[E2, B], R, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(GA) GB {
+	return eithert.BiMap(G.Map[GA, GB, GE1A, GE2B, R, either.Either[E1, A], either.Either[E2, B]], f, g)
 }
 
 // Swap changes the order of type parameters
-func Swap[GREA ~func(R) GEA, GRAE ~func(R) GAE, GEA ~func() ET.Either[E, A], GAE ~func() ET.Either[A, E], R, E, A any](val GREA) GRAE {
+func Swap[GREA ~func(R) GEA, GRAE ~func(R) GAE, GEA ~func() either.Either[E, A], GAE ~func() either.Either[A, E], R, E, A any](val GREA) GRAE {
 	return RD.MonadMap[GREA, GRAE, R, GEA, GAE](val, IOE.Swap[GEA, GAE])
 }
 
 // Defer creates an IO by creating a brand new IO via a generator function, each time
-func Defer[GEA ~func(R) GA, GA ~func() ET.Either[E, A], R, E, A any](gen func() GEA) GEA {
+func Defer[GEA ~func(R) GA, GA ~func() either.Either[E, A], R, E, A any](gen func() GEA) GEA {
 	return G.Defer[GEA](gen)
 }
 
 // TryCatch wraps a reader returning a tuple as an error into ReaderIOEither
-func TryCatch[GEA ~func(R) GA, GA ~func() ET.Either[E, A], R, E, A any](f func(R) func() (A, error), onThrow func(error) E) GEA {
+func TryCatch[GEA ~func(R) GA, GA ~func() either.Either[E, A], R, E, A any](f func(R) func() (A, error), onThrow func(error) E) GEA {
 	return func(r R) GA {
 		return IOE.TryCatch[GA](f(r), onThrow)
 	}
@@ -429,24 +429,24 @@ func TryCatch[GEA ~func(R) GA, GA ~func() ET.Either[E, A], R, E, A any](f func(R
 // The context used to compute the value is the context of the first call, so do not use this
 // method if the value has a functional dependency on the content of the context
 func Memoize[
-	GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](rdr GEA) GEA {
+	GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](rdr GEA) GEA {
 	return G.Memoize[GEA](rdr)
 }
 
-func MonadFlap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], R, E, B, A any](fab GREAB, a A) GREB {
+func MonadFlap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() either.Either[E, func(A) B], GEB ~func() either.Either[E, B], R, E, B, A any](fab GREAB, a A) GREB {
 	return FC.MonadFlap(MonadMap[GREAB, GREB], fab, a)
 }
 
-func Flap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], R, E, B, A any](a A) func(GREAB) GREB {
+func Flap[GREAB ~func(R) GEAB, GREB ~func(R) GEB, GEAB ~func() either.Either[E, func(A) B], GEB ~func() either.Either[E, B], R, E, B, A any](a A) func(GREAB) GREB {
 	return FC.Flap(Map[GREAB, GREB], a)
 }
 
-func MonadMapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Either[E1, A], GEA2 ~func() ET.Either[E2, A], R, E1, E2, A any](fa GREA1, f func(E1) E2) GREA2 {
+func MonadMapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() either.Either[E1, A], GEA2 ~func() either.Either[E2, A], R, E1, E2, A any](fa GREA1, f func(E1) E2) GREA2 {
 	return eithert.MonadMapLeft(G.MonadMap[GREA1, GREA2], fa, f)
 }
 
 // MapLeft applies a mapping function to the error channel
-func MapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() ET.Either[E1, A], GEA2 ~func() ET.Either[E2, A], R, E1, E2, A any](f func(E1) E2) func(GREA1) GREA2 {
+func MapLeft[GREA1 ~func(R) GEA1, GREA2 ~func(R) GEA2, GEA1 ~func() either.Either[E1, A], GEA2 ~func() either.Either[E2, A], R, E1, E2, A any](f func(E1) E2) func(GREA1) GREA2 {
 	return F.Bind2nd(MonadMapLeft[GREA1, GREA2], f)
 }
 
@@ -456,7 +456,7 @@ func Local[
 	GEA1 ~func(R1) GIOA,
 	GEA2 ~func(R2) GIOA,
 
-	GIOA ~func() ET.Either[E, A],
+	GIOA ~func() either.Either[E, A],
 	R1, R2, E, A any,
 ](f func(R2) R1) func(GEA1) GEA2 {
 	return RD.Local[GEA1, GEA2](f)
diff --git a/v2/readerioeither/generic/resource.go b/v2/readerioeither/generic/resource.go
deleted file mode 100644
index fa0f8bd..0000000
--- a/v2/readerioeither/generic/resource.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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 generic
-
-import (
-	ET "github.com/IBM/fp-go/v2/either"
-	IOE "github.com/IBM/fp-go/v2/ioeither/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GEA ~func(L) TEA,
-	GER ~func(L) TER,
-	GEANY ~func(L) TEANY,
-
-	TEA ~func() ET.Either[E, A],
-	TER ~func() ET.Either[E, R],
-	TEANY ~func() ET.Either[E, ANY],
-
-	L, E, R, A, ANY any](onCreate GER, onRelease func(R) GEANY) func(func(R) GEA) GEA {
-
-	return func(f func(R) GEA) GEA {
-		return func(l L) TEA {
-			// dispatch to the generic implementation
-			return IOE.WithResource[TEA](
-				onCreate(l),
-				func(r R) TEANY {
-					return onRelease(r)(l)
-				},
-			)(func(r R) TEA {
-				return f(r)(l)
-			})
-		}
-	}
-}
diff --git a/v2/readerioeither/generic/sequence.go b/v2/readerioeither/generic/sequence.go
index 4b5cb50..65fae44 100644
--- a/v2/readerioeither/generic/sequence.go
+++ b/v2/readerioeither/generic/sequence.go
@@ -16,7 +16,7 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	"github.com/IBM/fp-go/v2/internal/apply"
 	T "github.com/IBM/fp-go/v2/tuple"
 )
@@ -26,8 +26,8 @@ import (
 func SequenceT1[
 	GA ~func(E) GIOA,
 	GTA ~func(E) GIOTA,
-	GIOA ~func() ET.Either[L, A],
-	GIOTA ~func() ET.Either[L, T.Tuple1[A]],
+	GIOA ~func() either.Either[L, A],
+	GIOTA ~func() either.Either[L, T.Tuple1[A]],
 	E, L, A any](a GA) GTA {
 	return apply.SequenceT1(
 		Map[GA, GTA, GIOA, GIOTA, E, L, A, T.Tuple1[A]],
@@ -40,13 +40,13 @@ func SequenceT2[
 	GA ~func(E) GIOA,
 	GB ~func(E) GIOB,
 	GTAB ~func(E) GIOTAB,
-	GIOA ~func() ET.Either[L, A],
-	GIOB ~func() ET.Either[L, B],
-	GIOTAB ~func() ET.Either[L, T.Tuple2[A, B]],
+	GIOA ~func() either.Either[L, A],
+	GIOB ~func() either.Either[L, B],
+	GIOTAB ~func() either.Either[L, T.Tuple2[A, B]],
 	E, L, A, B any](a GA, b GB) GTAB {
 	return apply.SequenceT2(
-		Map[GA, func(E) func() ET.Either[L, func(B) T.Tuple2[A, B]], GIOA, func() ET.Either[L, func(B) T.Tuple2[A, B]], E, L, A, func(B) T.Tuple2[A, B]],
-		Ap[GB, GTAB, func(E) func() ET.Either[L, func(B) T.Tuple2[A, B]], GIOB, GIOTAB, func() ET.Either[L, func(B) T.Tuple2[A, B]], E, L, B, T.Tuple2[A, B]],
+		Map[GA, func(E) func() either.Either[L, func(B) T.Tuple2[A, B]], GIOA, func() either.Either[L, func(B) T.Tuple2[A, B]], E, L, A, func(B) T.Tuple2[A, B]],
+		Ap[GB, GTAB, func(E) func() either.Either[L, func(B) T.Tuple2[A, B]], GIOB, GIOTAB, func() either.Either[L, func(B) T.Tuple2[A, B]], E, L, B, T.Tuple2[A, B]],
 
 		a, b,
 	)
@@ -57,15 +57,15 @@ func SequenceT3[
 	GB ~func(E) GIOB,
 	GC ~func(E) GIOC,
 	GTABC ~func(E) GIOTABC,
-	GIOA ~func() ET.Either[L, A],
-	GIOB ~func() ET.Either[L, B],
-	GIOC ~func() ET.Either[L, C],
-	GIOTABC ~func() ET.Either[L, T.Tuple3[A, B, C]],
+	GIOA ~func() either.Either[L, A],
+	GIOB ~func() either.Either[L, B],
+	GIOC ~func() either.Either[L, C],
+	GIOTABC ~func() either.Either[L, T.Tuple3[A, B, C]],
 	E, L, A, B, C any](a GA, b GB, c GC) GTABC {
 	return apply.SequenceT3(
-		Map[GA, func(E) func() ET.Either[L, func(B) func(C) T.Tuple3[A, B, C]], GIOA, func() ET.Either[L, func(B) func(C) T.Tuple3[A, B, C]], E, L, A, func(B) func(C) T.Tuple3[A, B, C]],
-		Ap[GB, func(E) func() ET.Either[L, func(C) T.Tuple3[A, B, C]], func(E) func() ET.Either[L, func(B) func(C) T.Tuple3[A, B, C]], GIOB, func() ET.Either[L, func(C) T.Tuple3[A, B, C]], func() ET.Either[L, func(B) func(C) T.Tuple3[A, B, C]], E, L, B, func(C) T.Tuple3[A, B, C]],
-		Ap[GC, GTABC, func(E) func() ET.Either[L, func(C) T.Tuple3[A, B, C]], GIOC, GIOTABC, func() ET.Either[L, func(C) T.Tuple3[A, B, C]], E, L, C, T.Tuple3[A, B, C]],
+		Map[GA, func(E) func() either.Either[L, func(B) func(C) T.Tuple3[A, B, C]], GIOA, func() either.Either[L, func(B) func(C) T.Tuple3[A, B, C]], E, L, A, func(B) func(C) T.Tuple3[A, B, C]],
+		Ap[GB, func(E) func() either.Either[L, func(C) T.Tuple3[A, B, C]], func(E) func() either.Either[L, func(B) func(C) T.Tuple3[A, B, C]], GIOB, func() either.Either[L, func(C) T.Tuple3[A, B, C]], func() either.Either[L, func(B) func(C) T.Tuple3[A, B, C]], E, L, B, func(C) T.Tuple3[A, B, C]],
+		Ap[GC, GTABC, func(E) func() either.Either[L, func(C) T.Tuple3[A, B, C]], GIOC, GIOTABC, func() either.Either[L, func(C) T.Tuple3[A, B, C]], E, L, C, T.Tuple3[A, B, C]],
 
 		a, b, c,
 	)
@@ -77,17 +77,17 @@ func SequenceT4[
 	GC ~func(E) GIOC,
 	GD ~func(E) GIOD,
 	GTABCD ~func(E) GIOTABCD,
-	GIOA ~func() ET.Either[L, A],
-	GIOB ~func() ET.Either[L, B],
-	GIOC ~func() ET.Either[L, C],
-	GIOD ~func() ET.Either[L, D],
-	GIOTABCD ~func() ET.Either[L, T.Tuple4[A, B, C, D]],
+	GIOA ~func() either.Either[L, A],
+	GIOB ~func() either.Either[L, B],
+	GIOC ~func() either.Either[L, C],
+	GIOD ~func() either.Either[L, D],
+	GIOTABCD ~func() either.Either[L, T.Tuple4[A, B, C, D]],
 	E, L, A, B, C, D any](a GA, b GB, c GC, d GD) GTABCD {
 	return apply.SequenceT4(
-		Map[GA, func(E) func() ET.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], GIOA, func() ET.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, L, A, func(B) func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[GB, func(E) func() ET.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], func(E) func() ET.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], GIOB, func() ET.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], func() ET.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, L, B, func(C) func(D) T.Tuple4[A, B, C, D]],
-		Ap[GC, func(E) func() ET.Either[L, func(D) T.Tuple4[A, B, C, D]], func(E) func() ET.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], GIOC, func() ET.Either[L, func(D) T.Tuple4[A, B, C, D]], func() ET.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], E, L, C, func(D) T.Tuple4[A, B, C, D]],
-		Ap[GD, GTABCD, func(E) func() ET.Either[L, func(D) T.Tuple4[A, B, C, D]], GIOD, GIOTABCD, func() ET.Either[L, func(D) T.Tuple4[A, B, C, D]], E, L, D, T.Tuple4[A, B, C, D]],
+		Map[GA, func(E) func() either.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], GIOA, func() either.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, L, A, func(B) func(C) func(D) T.Tuple4[A, B, C, D]],
+		Ap[GB, func(E) func() either.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], func(E) func() either.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], GIOB, func() either.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], func() either.Either[L, func(B) func(C) func(D) T.Tuple4[A, B, C, D]], E, L, B, func(C) func(D) T.Tuple4[A, B, C, D]],
+		Ap[GC, func(E) func() either.Either[L, func(D) T.Tuple4[A, B, C, D]], func(E) func() either.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], GIOC, func() either.Either[L, func(D) T.Tuple4[A, B, C, D]], func() either.Either[L, func(C) func(D) T.Tuple4[A, B, C, D]], E, L, C, func(D) T.Tuple4[A, B, C, D]],
+		Ap[GD, GTABCD, func(E) func() either.Either[L, func(D) T.Tuple4[A, B, C, D]], GIOD, GIOTABCD, func() either.Either[L, func(D) T.Tuple4[A, B, C, D]], E, L, D, T.Tuple4[A, B, C, D]],
 
 		a, b, c, d,
 	)
diff --git a/v2/readerioeither/generic/sync.go b/v2/readerioeither/generic/sync.go
index fa89a35..b75f134 100644
--- a/v2/readerioeither/generic/sync.go
+++ b/v2/readerioeither/generic/sync.go
@@ -18,11 +18,11 @@ package generic
 import (
 	"context"
 
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	G "github.com/IBM/fp-go/v2/readerio/generic"
 )
 
 // WithLock executes the provided IO operation in the scope of a lock
-func WithLock[GEA ~func(R) GIOA, GIOA ~func() ET.Either[E, A], R, E, A any](lock func() context.CancelFunc) func(fa GEA) GEA {
+func WithLock[GEA ~func(R) GIOA, GIOA ~func() either.Either[E, A], R, E, A any](lock func() context.CancelFunc) func(fa GEA) GEA {
 	return G.WithLock[GEA](lock)
 }
diff --git a/v2/readerioeither/generic/traverse.go b/v2/readerioeither/generic/traverse.go
index ab940da..d225a33 100644
--- a/v2/readerioeither/generic/traverse.go
+++ b/v2/readerioeither/generic/traverse.go
@@ -16,56 +16,56 @@
 package generic
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	F "github.com/IBM/fp-go/v2/function"
 	RA "github.com/IBM/fp-go/v2/internal/array"
 	RR "github.com/IBM/fp-go/v2/internal/record"
 )
 
 // MonadTraverseArray transforms an array
-func MonadTraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[L, B], GIOBS ~func() ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](ma AAS, f func(A) GB) GBS {
+func MonadTraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() either.Either[L, B], GIOBS ~func() either.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](ma AAS, f func(A) GB) GBS {
 	return RA.MonadTraverse[AAS](
 		Of[GBS, GIOBS, E, L, BBS],
-		Map[GBS, func(E) func() ET.Either[L, func(B) BBS], GIOBS, func() ET.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
-		Ap[GB, GBS, func(E) func() ET.Either[L, func(B) BBS], GIOB, GIOBS, func() ET.Either[L, func(B) BBS], E, L, B, BBS],
+		Map[GBS, func(E) func() either.Either[L, func(B) BBS], GIOBS, func() either.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) func() either.Either[L, func(B) BBS], GIOB, GIOBS, func() either.Either[L, func(B) BBS], E, L, B, BBS],
 
 		ma, f,
 	)
 }
 
 // TraverseArray transforms an array
-func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[L, B], GIOBS ~func() ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(A) GB) func(AAS) GBS {
+func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() either.Either[L, B], GIOBS ~func() either.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(A) GB) func(AAS) GBS {
 	return RA.Traverse[AAS](
 		Of[GBS, GIOBS, E, L, BBS],
-		Map[GBS, func(E) func() ET.Either[L, func(B) BBS], GIOBS, func() ET.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
-		Ap[GB, GBS, func(E) func() ET.Either[L, func(B) BBS], GIOB, GIOBS, func() ET.Either[L, func(B) BBS], E, L, B, BBS],
+		Map[GBS, func(E) func() either.Either[L, func(B) BBS], GIOBS, func() either.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) func() either.Either[L, func(B) BBS], GIOB, GIOBS, func() either.Either[L, func(B) BBS], E, L, B, BBS],
 
 		f,
 	)
 }
 
 // TraverseArrayWithIndex transforms an array
-func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[L, B], GIOBS ~func() ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(int, A) GB) func(AAS) GBS {
+func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() either.Either[L, B], GIOBS ~func() either.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(int, A) GB) func(AAS) GBS {
 	return RA.TraverseWithIndex[AAS](
 		Of[GBS, GIOBS, E, L, BBS],
-		Map[GBS, func(E) func() ET.Either[L, func(B) BBS], GIOBS, func() ET.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
-		Ap[GB, GBS, func(E) func() ET.Either[L, func(B) BBS], GIOB, GIOBS, func() ET.Either[L, func(B) BBS], E, L, B, BBS],
+		Map[GBS, func(E) func() either.Either[L, func(B) BBS], GIOBS, func() either.Either[L, func(B) BBS], E, L, BBS, func(B) BBS],
+		Ap[GB, GBS, func(E) func() either.Either[L, func(B) BBS], GIOB, GIOBS, func() either.Either[L, func(B) BBS], E, L, B, BBS],
 
 		f,
 	)
 }
 
 // SequenceArray converts a homogeneous sequence of either into an either of sequence
-func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() ET.Either[L, A], GIOAS ~func() ET.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, E, L, A any](ma GAAS) GAS {
+func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() either.Either[L, A], GIOAS ~func() either.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, E, L, A any](ma GAAS) GAS {
 	return MonadTraverseArray[GA, GAS](ma, F.Identity[GA])
 }
 
 // MonadTraverseRecord transforms an array
-func MonadTraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](tas AAS, f func(A) GB) GBS {
+func MonadTraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() either.Either[E, B], GIOBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](tas AAS, f func(A) GB) GBS {
 	return RR.MonadTraverse[AAS](
 		Of[GBS, GIOBS, C, E, BBS],
-		Map[GBS, func(C) func() ET.Either[E, func(B) BBS], GIOBS, func() ET.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
-		Ap[GB, GBS, func(C) func() ET.Either[E, func(B) BBS], GIOB, GIOBS, func() ET.Either[E, func(B) BBS], C, E, B, BBS],
+		Map[GBS, func(C) func() either.Either[E, func(B) BBS], GIOBS, func() either.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(C) func() either.Either[E, func(B) BBS], GIOB, GIOBS, func() either.Either[E, func(B) BBS], C, E, B, BBS],
 
 		tas,
 		f,
@@ -73,28 +73,28 @@ func MonadTraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.E
 }
 
 // TraverseRecord transforms a record
-func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(A) GB) func(AAS) GBS {
+func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() either.Either[E, B], GIOBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(A) GB) func(AAS) GBS {
 	return RR.Traverse[AAS](
 		Of[GBS, GIOBS, C, E, BBS],
-		Map[GBS, func(C) func() ET.Either[E, func(B) BBS], GIOBS, func() ET.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
-		Ap[GB, GBS, func(C) func() ET.Either[E, func(B) BBS], GIOB, GIOBS, func() ET.Either[E, func(B) BBS], C, E, B, BBS],
+		Map[GBS, func(C) func() either.Either[E, func(B) BBS], GIOBS, func() either.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(C) func() either.Either[E, func(B) BBS], GIOB, GIOBS, func() either.Either[E, func(B) BBS], C, E, B, BBS],
 
 		f,
 	)
 }
 
 // TraverseRecordWithIndex transforms a record
-func TraverseRecordWithIndex[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(K, A) GB) func(AAS) GBS {
+func TraverseRecordWithIndex[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() either.Either[E, B], GIOBS ~func() either.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(K, A) GB) func(AAS) GBS {
 	return RR.TraverseWithIndex[AAS](
 		Of[GBS, GIOBS, C, E, BBS],
-		Map[GBS, func(C) func() ET.Either[E, func(B) BBS], GIOBS, func() ET.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
-		Ap[GB, GBS, func(C) func() ET.Either[E, func(B) BBS], GIOB, GIOBS, func() ET.Either[E, func(B) BBS], C, E, B, BBS],
+		Map[GBS, func(C) func() either.Either[E, func(B) BBS], GIOBS, func() either.Either[E, func(B) BBS], C, E, BBS, func(B) BBS],
+		Ap[GB, GBS, func(C) func() either.Either[E, func(B) BBS], GIOB, GIOBS, func() either.Either[E, func(B) BBS], C, E, B, BBS],
 
 		f,
 	)
 }
 
 // SequenceRecord converts a homogeneous sequence of either into an either of sequence
-func SequenceRecord[GA ~func(C) GIOA, GAS ~func(C) GIOAS, GIOA ~func() ET.Either[E, A], GIOAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, C, E, A any](tas GAAS) GAS {
+func SequenceRecord[GA ~func(C) GIOA, GAS ~func(C) GIOAS, GIOA ~func() either.Either[E, A], GIOAS ~func() either.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, C, E, A any](tas GAAS) GAS {
 	return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA])
 }
diff --git a/v2/readerioeither/reader.go b/v2/readerioeither/reader.go
index a63981f..4fb7898 100644
--- a/v2/readerioeither/reader.go
+++ b/v2/readerioeither/reader.go
@@ -16,85 +16,115 @@
 package readerioeither
 
 import (
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/function"
+	"github.com/IBM/fp-go/v2/internal/chain"
+	"github.com/IBM/fp-go/v2/internal/eithert"
+	"github.com/IBM/fp-go/v2/internal/fromeither"
 	"github.com/IBM/fp-go/v2/io"
 	IOE "github.com/IBM/fp-go/v2/ioeither"
 	L "github.com/IBM/fp-go/v2/lazy"
 	O "github.com/IBM/fp-go/v2/option"
-	RD "github.com/IBM/fp-go/v2/reader"
+	"github.com/IBM/fp-go/v2/reader"
 	RE "github.com/IBM/fp-go/v2/readereither"
-	RIO "github.com/IBM/fp-go/v2/readerio"
+	"github.com/IBM/fp-go/v2/readerio"
 	G "github.com/IBM/fp-go/v2/readerioeither/generic"
 )
 
-type ReaderIOEither[R, E, A any] RD.Reader[R, IOE.IOEither[E, A]]
+type (
+	ReaderIOEither[R, E, A any] = reader.Reader[R, IOE.IOEither[E, A]]
 
-// MakeReader constructs an instance of a reader
-func MakeReader[R, E, A any](f func(R) IOE.IOEither[E, A]) ReaderIOEither[R, E, A] {
-	return G.MakeReader[ReaderIOEither[R, E, A]](f)
+	Mapper[R, E, A, B any] = reader.Reader[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]]
+)
+
+func MonadFromReaderIO[R, E, A any](a A, f func(A) readerio.ReaderIO[R, A]) ReaderIOEither[R, E, A] {
+	return function.Pipe2(
+		a,
+		f,
+		RightReaderIO[R, E, A],
+	)
 }
 
-func MonadFromReaderIO[R, E, A any](a A, f func(A) RIO.ReaderIO[R, A]) ReaderIOEither[R, E, A] {
-	return G.MonadFromReaderIO[ReaderIOEither[R, E, A]](a, f)
+func FromReaderIO[R, E, A any](f func(A) readerio.ReaderIO[R, A]) func(A) ReaderIOEither[R, E, A] {
+	return function.Bind2nd(MonadFromReaderIO[R, E, A], f)
 }
 
-func FromReaderIO[R, E, A any](f func(A) RIO.ReaderIO[R, A]) func(A) ReaderIOEither[R, E, A] {
-	return G.FromReaderIO[ReaderIOEither[R, E, A]](f)
+func RightReaderIO[R, E, A any](ma readerio.ReaderIO[R, A]) ReaderIOEither[R, E, A] {
+	return eithert.RightF(
+		readerio.MonadMap[R, A, either.Either[E, A]],
+		ma,
+	)
 }
 
-func RightReaderIO[R, E, A any](ma RIO.ReaderIO[R, A]) ReaderIOEither[R, E, A] {
-	return G.RightReaderIO[ReaderIOEither[R, E, A]](ma)
-}
-
-func LeftReaderIO[A, R, E any](me RIO.ReaderIO[R, E]) ReaderIOEither[R, E, A] {
-	return G.LeftReaderIO[ReaderIOEither[R, E, A]](me)
+func LeftReaderIO[A, R, E any](me readerio.ReaderIO[R, E]) ReaderIOEither[R, E, A] {
+	return eithert.LeftF(
+		readerio.MonadMap[R, E, either.Either[E, A]],
+		me,
+	)
 }
 
 func MonadMap[R, E, A, B any](fa ReaderIOEither[R, E, A], f func(A) B) ReaderIOEither[R, E, B] {
-	return G.MonadMap[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](fa, f)
+	return eithert.MonadMap(readerio.MonadMap[R, either.Either[E, A], either.Either[E, B]], fa, f)
 }
 
 func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
-	return G.Map[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](f)
+	return eithert.Map(readerio.Map[R, either.Either[E, A], either.Either[E, B]], f)
 }
 
 func MonadMapTo[R, E, A, B any](fa ReaderIOEither[R, E, A], b B) ReaderIOEither[R, E, B] {
-	return G.MonadMapTo[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](fa, b)
+	return MonadMap(fa, function.Constant1[A](b))
 }
 
 func MapTo[R, E, A, B any](b B) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
-	return G.MapTo[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](b)
+	return Map[R, E](function.Constant1[A](b))
 }
 
 func MonadChain[R, E, A, B any](fa ReaderIOEither[R, E, A], f func(A) ReaderIOEither[R, E, B]) ReaderIOEither[R, E, B] {
-	return G.MonadChain(fa, f)
+	return eithert.MonadChain(
+		readerio.MonadChain[R, either.Either[E, A], either.Either[E, B]],
+		readerio.Of[R, either.Either[E, B]],
+		fa,
+		f)
 }
 
 func MonadChainFirst[R, E, A, B any](fa ReaderIOEither[R, E, A], f func(A) ReaderIOEither[R, E, B]) ReaderIOEither[R, E, A] {
-	return G.MonadChainFirst(fa, f)
+	return chain.MonadChainFirst(
+		MonadChain[R, E, A, A],
+		MonadMap[R, E, B, A],
+		fa,
+		f)
 }
 
-func MonadChainEitherK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) ET.Either[E, B]) ReaderIOEither[R, E, B] {
-	return G.MonadChainEitherK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](ma, f)
+func MonadChainEitherK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) either.Either[E, B]) ReaderIOEither[R, E, B] {
+	return fromeither.MonadChainEitherK(
+		MonadChain[R, E, A, B],
+		FromEither[R, E, B],
+		ma,
+		f,
+	)
 }
 
-func ChainEitherK[R, E, A, B any](f func(A) ET.Either[E, B]) func(ma ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
-	return G.ChainEitherK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](f)
+func ChainEitherK[R, E, A, B any](f func(A) either.Either[E, B]) func(ma ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
+	return fromeither.ChainEitherK(
+		Chain[R, E, A, B],
+		FromEither[R, E, B],
+		f,
+	)
 }
 
-func MonadChainFirstEitherK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) ET.Either[E, B]) ReaderIOEither[R, E, A] {
+func MonadChainFirstEitherK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) either.Either[E, B]) ReaderIOEither[R, E, A] {
 	return G.MonadChainFirstEitherK[ReaderIOEither[R, E, A]](ma, f)
 }
 
-func ChainFirstEitherK[R, E, A, B any](f func(A) ET.Either[E, B]) func(ma ReaderIOEither[R, E, A]) ReaderIOEither[R, E, A] {
+func ChainFirstEitherK[R, E, A, B any](f func(A) either.Either[E, B]) func(ma ReaderIOEither[R, E, A]) ReaderIOEither[R, E, A] {
 	return G.ChainFirstEitherK[ReaderIOEither[R, E, A]](f)
 }
 
-func MonadChainReaderK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) RD.Reader[R, B]) ReaderIOEither[R, E, B] {
+func MonadChainReaderK[R, E, A, B any](ma ReaderIOEither[R, E, A], f func(A) reader.Reader[R, B]) ReaderIOEither[R, E, B] {
 	return G.MonadChainReaderK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](ma, f)
 }
 
-func ChainReaderK[E, R, A, B any](f func(A) RD.Reader[R, B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
+func ChainReaderK[E, R, A, B any](f func(A) reader.Reader[R, B]) func(ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B] {
 	return G.ChainReaderK[ReaderIOEither[R, E, A], ReaderIOEither[R, E, B]](f)
 }
 
@@ -163,20 +193,20 @@ func Flatten[R, E, A any](mma ReaderIOEither[R, E, ReaderIOEither[R, E, A]]) Rea
 	return G.Flatten(mma)
 }
 
-func FromEither[R, E, A any](t ET.Either[E, A]) ReaderIOEither[R, E, A] {
+func FromEither[R, E, A any](t either.Either[E, A]) ReaderIOEither[R, E, A] {
 	return G.FromEither[ReaderIOEither[R, E, A]](t)
 }
 
-func RightReader[E, R, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
-	return G.RightReader[RD.Reader[R, A], ReaderIOEither[R, E, A]](ma)
+func RightReader[E, R, A any](ma reader.Reader[R, A]) ReaderIOEither[R, E, A] {
+	return G.RightReader[reader.Reader[R, A], ReaderIOEither[R, E, A]](ma)
 }
 
-func LeftReader[A, R, E any](ma RD.Reader[R, E]) ReaderIOEither[R, E, A] {
-	return G.LeftReader[RD.Reader[R, E], ReaderIOEither[R, E, A]](ma)
+func LeftReader[A, R, E any](ma reader.Reader[R, E]) ReaderIOEither[R, E, A] {
+	return G.LeftReader[reader.Reader[R, E], ReaderIOEither[R, E, A]](ma)
 }
 
-func FromReader[E, R, A any](ma RD.Reader[R, A]) ReaderIOEither[R, E, A] {
-	return G.FromReader[RD.Reader[R, A], ReaderIOEither[R, E, A]](ma)
+func FromReader[E, R, A any](ma reader.Reader[R, A]) ReaderIOEither[R, E, A] {
+	return G.FromReader[reader.Reader[R, A], ReaderIOEither[R, E, A]](ma)
 }
 
 func RightIO[R, E, A any](ma io.IO[A]) ReaderIOEither[R, E, A] {
@@ -203,8 +233,8 @@ func Ask[R, E any]() ReaderIOEither[R, E, R] {
 	return G.Ask[ReaderIOEither[R, E, R]]()
 }
 
-func Asks[E, R, A any](r RD.Reader[R, A]) ReaderIOEither[R, E, A] {
-	return G.Asks[RD.Reader[R, A], ReaderIOEither[R, E, A]](r)
+func Asks[E, R, A any](r reader.Reader[R, A]) ReaderIOEither[R, E, A] {
+	return G.Asks[reader.Reader[R, A], ReaderIOEither[R, E, A]](r)
 }
 
 func FromOption[R, A, E any](onNone func() E) func(O.Option[A]) ReaderIOEither[R, E, A] {
@@ -215,20 +245,20 @@ func FromPredicate[R, E, A any](pred func(A) bool, onFalse func(A) E) func(A) Re
 	return G.FromPredicate[ReaderIOEither[R, E, A]](pred, onFalse)
 }
 
-func Fold[R, E, A, B any](onLeft func(E) RIO.ReaderIO[R, B], onRight func(A) RIO.ReaderIO[R, B]) func(ReaderIOEither[R, E, A]) RIO.ReaderIO[R, B] {
-	return G.Fold[RIO.ReaderIO[R, B], ReaderIOEither[R, E, A]](onLeft, onRight)
+func Fold[R, E, A, B any](onLeft func(E) readerio.ReaderIO[R, B], onRight func(A) readerio.ReaderIO[R, B]) func(ReaderIOEither[R, E, A]) readerio.ReaderIO[R, B] {
+	return G.Fold[readerio.ReaderIO[R, B], ReaderIOEither[R, E, A]](onLeft, onRight)
 }
 
-func GetOrElse[R, E, A any](onLeft func(E) RIO.ReaderIO[R, A]) func(ReaderIOEither[R, E, A]) RIO.ReaderIO[R, A] {
-	return G.GetOrElse[RIO.ReaderIO[R, A], ReaderIOEither[R, E, A]](onLeft)
+func GetOrElse[R, E, A any](onLeft func(E) readerio.ReaderIO[R, A]) func(ReaderIOEither[R, E, A]) readerio.ReaderIO[R, A] {
+	return G.GetOrElse[readerio.ReaderIO[R, A], ReaderIOEither[R, E, A]](onLeft)
 }
 
 func OrElse[R, E1, A, E2 any](onLeft func(E1) ReaderIOEither[R, E2, A]) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
 	return G.OrElse[ReaderIOEither[R, E1, A]](onLeft)
 }
 
-func OrLeft[A, E1, R, E2 any](onLeft func(E1) RIO.ReaderIO[R, E2]) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
-	return G.OrLeft[ReaderIOEither[R, E1, A], RIO.ReaderIO[R, E2], ReaderIOEither[R, E2, A]](onLeft)
+func OrLeft[A, E1, R, E2 any](onLeft func(E1) readerio.ReaderIO[R, E2]) func(ReaderIOEither[R, E1, A]) ReaderIOEither[R, E2, A] {
+	return G.OrLeft[ReaderIOEither[R, E1, A], readerio.ReaderIO[R, E2], ReaderIOEither[R, E2, A]](onLeft)
 }
 
 func MonadBiMap[R, E1, E2, A, B any](fa ReaderIOEither[R, E1, A], f func(E1) E2, g func(A) B) ReaderIOEither[R, E2, B] {
diff --git a/v2/readerioeither/reader_test.go b/v2/readerioeither/reader_test.go
index 87a8106..d127af1 100644
--- a/v2/readerioeither/reader_test.go
+++ b/v2/readerioeither/reader_test.go
@@ -24,7 +24,7 @@ import (
 	F "github.com/IBM/fp-go/v2/function"
 	"github.com/IBM/fp-go/v2/internal/utils"
 	R "github.com/IBM/fp-go/v2/reader"
-	RIO "github.com/IBM/fp-go/v2/readerio"
+	"github.com/IBM/fp-go/v2/readerio"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -39,8 +39,8 @@ func TestMap(t *testing.T) {
 }
 
 func TestOrLeft(t *testing.T) {
-	f := OrLeft[int](func(s string) RIO.ReaderIO[context.Context, string] {
-		return RIO.Of[context.Context](s + "!")
+	f := OrLeft[int](func(s string) readerio.ReaderIO[context.Context, string] {
+		return readerio.Of[context.Context](s + "!")
 	})
 
 	g1 := F.Pipe1(
diff --git a/v2/readerioeither/resource.go b/v2/readerioeither/resource.go
index 6006e96..79e1a87 100644
--- a/v2/readerioeither/resource.go
+++ b/v2/readerioeither/resource.go
@@ -15,11 +15,21 @@
 
 package readerioeither
 
-import (
-	G "github.com/IBM/fp-go/v2/readerioeither/generic"
-)
+import "github.com/IBM/fp-go/v2/ioeither"
 
 // WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[A, L, E, R any](onCreate ReaderIOEither[L, E, R], onRelease func(R) ReaderIOEither[L, E, any]) func(func(R) ReaderIOEither[L, E, A]) ReaderIOEither[L, E, A] {
-	return G.WithResource[ReaderIOEither[L, E, A]](onCreate, onRelease)
+func WithResource[A, L, E, R, ANY any](onCreate ReaderIOEither[L, E, R], onRelease func(R) ReaderIOEither[L, E, ANY]) func(func(R) ReaderIOEither[L, E, A]) ReaderIOEither[L, E, A] {
+	return func(f func(R) ReaderIOEither[L, E, A]) ReaderIOEither[L, E, A] {
+		return func(l L) ioeither.IOEither[E, A] {
+			// dispatch to the generic implementation
+			return ioeither.WithResource[A](
+				onCreate(l),
+				func(r R) ioeither.IOEither[E, ANY] {
+					return onRelease(r)(l)
+				},
+			)(func(r R) ioeither.IOEither[E, A] {
+				return f(r)(l)
+			})
+		}
+	}
 }
diff --git a/v2/readerioeither/sequence_test.go b/v2/readerioeither/sequence_test.go
index 925540c..dc462e4 100644
--- a/v2/readerioeither/sequence_test.go
+++ b/v2/readerioeither/sequence_test.go
@@ -19,7 +19,7 @@ import (
 	"context"
 	"testing"
 
-	ET "github.com/IBM/fp-go/v2/either"
+	"github.com/IBM/fp-go/v2/either"
 	T "github.com/IBM/fp-go/v2/tuple"
 	"github.com/stretchr/testify/assert"
 )
@@ -34,5 +34,5 @@ func TestSequence2(t *testing.T) {
 	res := s2(first, second)
 
 	ctx := context.Background()
-	assert.Equal(t, ET.Right[error](T.MakeTuple2("a", 1)), res(ctx)())
+	assert.Equal(t, either.Right[error](T.MakeTuple2("a", 1)), res(ctx)())
 }