fix: http interface of IOEither

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

array/generic/uniq.go

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

array/uniq.go

@@ -1,17 +0,0 @@
-package array
-
-import (
-	G "github.com/IBM/fp-go/array/generic"
-)
-
-// StrictUniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined by the built-in uniqueness constraint
-func StrictUniq[A comparable](as []A) []A {
-	return G.StrictUniq[[]A](as)
-}
-
-// Uniq converts an array of arbitrary items into an array or unique items
-// where uniqueness is determined based on a key extractor function
-func Uniq[A any, K comparable](f func(A) K) func(as []A) []A {
-	return G.Uniq[[]A](f)
-}

array/uniq_test.go

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

context/readerioeither/generic/traverse.go

@@ -166,289 +166,3 @@ func SequenceRecord[K comparable,
 
 	return MonadTraverseRecord[K, GAS, GRAS](ma, F.Identity[GRA])
 }
-
-// MonadTraverseArraySeq transforms an array
-func MonadTraverseArraySeq[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](as AS, f func(A) GRB) GRBS {
-
-	return RA.MonadTraverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		as, f,
-	)
-}
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](f func(A) GRB) func(AS) GRBS {
-
-	return RA.Traverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](f func(int, A) GRB) func(AS) GRBS {
-
-	return RA.TraverseWithIndex[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[
-	AS ~[]A,
-	GAS ~[]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseArraySeq[GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseRecordSeq transforms a record
-func MonadTraverseRecordSeq[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](ma AS, f func(A) GRB) GRBS {
-
-	return RR.MonadTraverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		ma, f,
-	)
-}
-
-// TraverseRecordSeq transforms a record
-func TraverseRecordSeq[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](f func(A) GRB) func(AS) GRBS {
-
-	return RR.Traverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexSeq transforms a record
-func TraverseRecordWithIndexSeq[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](f func(K, A) GRB) func(AS) GRBS {
-
-	return RR.TraverseWithIndex[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApSeq[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[K comparable,
-	AS ~map[K]A,
-	GAS ~map[K]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseRecordSeq[K, GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseArrayPar transforms an array
-func MonadTraverseArrayPar[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](as AS, f func(A) GRB) GRBS {
-
-	return RA.MonadTraverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		as, f,
-	)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](f func(A) GRB) func(AS) GRBS {
-
-	return RA.Traverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[
-	AS ~[]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~[]B,
-	A, B any](f func(int, A) GRB) func(AS) GRBS {
-
-	return RA.TraverseWithIndex[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[
-	AS ~[]A,
-	GAS ~[]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseArrayPar[GAS, GRAS](ma, F.Identity[GRA])
-}
-
-// MonadTraverseRecordPar transforms a record
-func MonadTraverseRecordPar[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](ma AS, f func(A) GRB) GRBS {
-
-	return RR.MonadTraverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		ma, f,
-	)
-}
-
-// TraverseRecordPar transforms a record
-func TraverseRecordPar[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](f func(A) GRB) func(AS) GRBS {
-
-	return RR.Traverse[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexPar transforms a record
-func TraverseRecordWithIndexPar[K comparable,
-	AS ~map[K]A,
-	GRBS ~func(context.Context) GIOBS,
-	GRB ~func(context.Context) GIOB,
-	GIOBS ~func() E.Either[error, BS],
-	GIOB ~func() E.Either[error, B],
-	BS ~map[K]B,
-
-	A, B any](f func(K, A) GRB) func(AS) GRBS {
-
-	return RR.TraverseWithIndex[AS](
-		Of[GRBS, GIOBS, BS],
-		Map[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GIOBS, func() E.Either[error, func(B) BS], BS, func(B) BS],
-		ApPar[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB],
-
-		f,
-	)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[K comparable,
-	AS ~map[K]A,
-	GAS ~map[K]GRA,
-	GRAS ~func(context.Context) GIOAS,
-	GRA ~func(context.Context) GIOA,
-	GIOAS ~func() E.Either[error, AS],
-	GIOA ~func() E.Either[error, A],
-	A any](ma GAS) GRAS {
-
-	return MonadTraverseRecordPar[K, GAS, GRAS](ma, F.Identity[GRA])
-}

context/readerioeither/traverse.go

@@ -48,63 +48,3 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither
 func SequenceRecord[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
 	return G.SequenceRecord[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
 }
-
-// TraverseArraySeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArraySeq[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArraySeq[[]A, ReaderIOEither[[]B]](f)
-}
-
-// TraverseArrayWithIndexSeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayWithIndexSeq[[]A, ReaderIOEither[[]B]](f)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
-	return G.SequenceArraySeq[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
-}
-
-// TraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordSeq[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// TraverseRecordWithIndexSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordWithIndexSeq[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
-	return G.SequenceRecordSeq[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
-}
-
-// TraverseArrayPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayPar[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayPar[[]A, ReaderIOEither[[]B]](f)
-}
-
-// TraverseArrayWithIndexPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
-func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] {
-	return G.TraverseArrayWithIndexPar[[]A, ReaderIOEither[[]B]](f)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
-	return G.SequenceArrayPar[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma)
-}
-
-// TraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordPar[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// TraverseRecordWithIndexPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
-func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] {
-	return G.TraverseRecordWithIndexPar[K, map[K]A, ReaderIOEither[map[K]B]](f)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
-	return G.SequenceRecordPar[K, map[K]A, map[K]ReaderIOEither[A], ReaderIOEither[map[K]A]](ma)
-}

di/erasure/provider.go

@@ -117,7 +117,7 @@ var (
 					mp,
 					R.Map[int](F.Flow3(
 						getAt(res),
-						IOE.ToIOOption[error, any],
+						IOO.FromIOEither[error, any],
 						F.ToAny[IOO.IOOption[any]],
 					)),
 					IOE.Of[error, paramValue],

either/array.go

@@ -61,14 +61,14 @@ func SequenceArray[E, A any](ma []Either[E, A]) Either[E, []A] {
 	return SequenceArrayG[[]A](ma)
 }
 
-// CompactArrayG discards the none values and keeps the right values
+// CompactArrayG discards the none values and keeps the some values
 func CompactArrayG[A1 ~[]Either[E, A], A2 ~[]A, E, A any](fa A1) A2 {
 	return RA.Reduce(fa, func(out A2, value Either[E, A]) A2 {
 		return MonadFold(value, F.Constant1[E](out), F.Bind1st(RA.Append[A2, A], out))
-	}, make(A2, 0, len(fa)))
+	}, make(A2, len(fa)))
 }
 
-// CompactArray discards the none values and keeps the right values
+// CompactArray discards the none values and keeps the some values
 func CompactArray[E, A any](fa []Either[E, A]) []A {
 	return CompactArrayG[[]Either[E, A], []A](fa)
 }

either/array_test.go

@@ -1,18 +0,0 @@
-package either
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCompactArray(t *testing.T) {
-	ar := []Either[string, string]{
-		Of[string]("ok"),
-		Left[string]("err"),
-		Of[string]("ok"),
-	}
-
-	res := CompactArray(ar)
-	assert.Equal(t, 2, len(res))
-}

either/either.go

@@ -89,7 +89,7 @@ func MonadChainFirst[E, A, B any](ma Either[E, A], f func(a A) Either[E, B]) Eit
 	})
 }
 
-func MonadChainTo[A, E, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
+func MonadChainTo[E, A, B any](ma Either[E, A], mb Either[E, B]) Either[E, B] {
 	return mb
 }
 
@@ -104,8 +104,8 @@ func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(E
 	}
 }
 
-func ChainTo[A, E, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
-	return F.Bind2nd(MonadChainTo[A, E, B], mb)
+func ChainTo[E, A, B any](mb Either[E, B]) func(Either[E, A]) Either[E, B] {
+	return F.Bind2nd(MonadChainTo[E, A, B], mb)
 }
 
 func Chain[E, A, B any](f func(a A) Either[E, B]) func(Either[E, A]) Either[E, B] {

either/logger.go

@@ -41,7 +41,7 @@ func Logger[E, A any](loggers ...*log.Logger) func(string) func(Either[E, A]) Ei
 		return func(ma Either[E, A]) Either[E, A] {
 			return F.Pipe1(
 				delegate(ma),
-				ChainTo[A](ma),
+				ChainTo[E, A](ma),
 			)
 		}
 	}

internal/eithert/either.go

@@ -32,17 +32,6 @@ func MonadAlt[LAZY ~func() HKTFA, E, A, HKTFA any](
 	return fchain(first, ET.Fold(F.Ignore1of1[E](second), F.Flow2(ET.Of[E, A], fof)))
 }
 
-func Alt[LAZY ~func() HKTFA, E, A, HKTFA any](
-	fof func(ET.Either[E, A]) HKTFA,
-	fchain func(HKTFA, func(ET.Either[E, A]) HKTFA) HKTFA,
-
-	second LAZY) func(HKTFA) HKTFA {
-
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
-}
-
 // HKTFA = HKT<F, Either<E, A>>
 // HKTFB = HKT<F, Either<E, B>>
 func MonadMap[E, A, B, HKTFA, HKTFB any](fmap func(HKTFA, func(ET.Either[E, A]) ET.Either[E, B]) HKTFB, fa HKTFA, f func(A) B) HKTFB {

internal/optiont/option.go

@@ -49,16 +49,6 @@ func MonadChain[A, B, HKTFA, HKTFB any](
 	return fchain(ma, O.Fold(F.Nullary2(O.None[B], fof), f))
 }
 
-func Chain[A, B, HKTFA, HKTFB any](
-	fchain func(HKTFA, func(O.Option[A]) HKTFB) HKTFB,
-	fof func(O.Option[B]) HKTFB,
-	f func(A) HKTFB) func(ma HKTFA) HKTFB {
-	// dispatch to the even more generic implementation
-	return func(ma HKTFA) HKTFB {
-		return MonadChain(fchain, fof, ma, f)
-	}
-}
-
 func MonadAp[A, B, HKTFAB, HKTFGAB, HKTFA, HKTFB any](
 	fap func(HKTFGAB, HKTFA) HKTFB,
 	fmap func(HKTFAB, func(O.Option[func(A) B]) func(O.Option[A]) O.Option[B]) HKTFGAB,
@@ -88,24 +78,3 @@ func MonadChainOptionK[A, B, HKTA, HKTB any](
 ) HKTB {
 	return MonadChain(fchain, fof, ma, FromOptionK(fof, f))
 }
-
-func MonadAlt[LAZY ~func() HKTFA, A, HKTFA any](
-	fof func(O.Option[A]) HKTFA,
-	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
-
-	first HKTFA,
-	second LAZY) HKTFA {
-
-	return fchain(first, O.Fold(second, F.Flow2(O.Of[A], fof)))
-}
-
-func Alt[LAZY ~func() HKTFA, A, HKTFA any](
-	fof func(O.Option[A]) HKTFA,
-	fchain func(HKTFA, func(O.Option[A]) HKTFA) HKTFA,
-
-	second LAZY) func(HKTFA) HKTFA {
-
-	return func(fa HKTFA) HKTFA {
-		return MonadAlt(fof, fchain, fa, second)
-	}
-}

io/generic/ap.go

@@ -16,7 +16,6 @@
 package generic
 
 import (
-	F "github.com/IBM/fp-go/function"
 	G "github.com/IBM/fp-go/internal/apply"
 )
 
@@ -28,10 +27,7 @@ const (
 // MonadApSeq implements the applicative on a single thread by first executing mab and the ma
 func MonadApSeq[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB {
 	return MakeIO[GB](func() B {
-		return F.Pipe1(
-			ma(),
-			mab(),
-		)
+		return mab()(ma())
 	})
 }
 

io/generic/resource.go

@@ -1,30 +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 (
-	F "github.com/IBM/fp-go/function"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GA ~func() A,
-	GR ~func() R,
-	GANY ~func() ANY,
-	R, A, ANY any](onCreate GR, onRelease func(R) GANY) func(func(R) GA) GA {
-	// simply map to implementation of bracket
-	return F.Bind13of3(Bracket[GR, GA, GANY, R, A, ANY])(onCreate, F.Ignore2of2[A](onRelease))
-}

io/resource.go

@@ -1,27 +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 io
-
-import (
-	G "github.com/IBM/fp-go/io/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	R, A, ANY any](onCreate IO[R], onRelease func(R) IO[ANY]) func(func(R) IO[A]) IO[A] {
-	// just dispatch
-	return G.WithResource[IO[A], IO[R], IO[ANY]](onCreate, onRelease)
-}

ioeither/generic/ioeither.go

@@ -336,14 +336,3 @@ func MonadFlap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B]
 func Flap[GEAB ~func() ET.Either[E, func(A) B], GEB ~func() ET.Either[E, B], E, B, A any](a A) func(GEAB) GEB {
 	return FC.Flap(MonadMap[GEAB, GEB], a)
 }
-
-func ToIOOption[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {
-	return F.Pipe1(
-		ioe,
-		IO.Map[GEA, GA](ET.ToOption[E, A]),
-	)
-}
-
-func FromIOOption[GEA ~func() ET.Either[E, A], GA ~func() O.Option[A], E, A any](onNone func() E) func(ioo GA) GEA {
-	return IO.Map[GA, GEA](ET.FromOption[A](onNone))
-}

ioeither/generic/traverse.go

@@ -111,183 +111,3 @@ func TraverseRecordWithIndex[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E
 func SequenceRecord[GA ~func() ET.Either[E, A], GAS ~func() ET.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() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArraySeq transforms an array
-func TraverseArraySeq[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexSeq transforms an array
-func MonadTraverseArrayWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexSeq transforms an array
-func TraverseArrayWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArraySeq converts a homogeneous sequence of either into an either of sequence
-func SequenceArraySeq[GA ~func() ET.Either[E, A], GAS ~func() ET.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() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordSeq transforms an array
-func TraverseRecordSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexSeq transforms an array
-func TraverseRecordWithIndexSeq[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApSeq[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordSeq[GA ~func() ET.Either[E, A], GAS ~func() ET.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() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayPar transforms an array
-func TraverseArrayPar[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// MonadTraverseArrayWithIndexPar transforms an array
-func MonadTraverseArrayWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseArrayWithIndexPar transforms an array
-func TraverseArrayWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceArrayPar converts a homogeneous sequence of either into an either of sequence
-func SequenceArrayPar[GA ~func() ET.Either[E, A], GAS ~func() ET.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() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		tas,
-		f,
-	)
-}
-
-// TraverseRecordPar transforms an array
-func TraverseRecordPar[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// TraverseRecordWithIndexPar transforms an array
-func TraverseRecordWithIndexPar[GB ~func() ET.Either[E, B], GBS ~func() ET.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() ET.Either[E, func(B) BBS], E, BBS, func(B) BBS],
-		ApPar[GBS, func() ET.Either[E, func(B) BBS], GB],
-
-		f,
-	)
-}
-
-// SequenceRecordPar converts a homogeneous sequence of either into an either of sequence
-func SequenceRecordPar[GA ~func() ET.Either[E, A], GAS ~func() ET.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])
-}

ioeither/ioeither.go

@@ -19,7 +19,6 @@ import (
 	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
 	G "github.com/IBM/fp-go/ioeither/generic"
-	IOO "github.com/IBM/fp-go/iooption"
 	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
@@ -64,10 +63,6 @@ func FromOption[A, E any](onNone func() E) func(o O.Option[A]) IOEither[E, A] {
 	return G.FromOption[IOEither[E, A]](onNone)
 }
 
-func FromIOOption[A, E any](onNone func() E) func(o IOO.IOOption[A]) IOEither[E, A] {
-	return G.FromIOOption[IOEither[E, A], IOO.IOOption[A]](onNone)
-}
-
 func ChainOptionK[A, B, E any](onNone func() E) func(func(A) O.Option[B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ChainOptionK[IOEither[E, A], IOEither[E, B]](onNone)
 }
@@ -197,12 +192,12 @@ func GetOrElse[E, A any](onLeft func(E) I.IO[A]) func(IOEither[E, A]) I.IO[A] {
 }
 
 // MonadChainTo composes to the second monad ignoring the return value of the first
-func MonadChainTo[A, E, B any](fa IOEither[E, A], fb IOEither[E, B]) IOEither[E, B] {
+func MonadChainTo[E, A, B any](fa IOEither[E, A], fb IOEither[E, B]) IOEither[E, B] {
 	return G.MonadChainTo(fa, fb)
 }
 
 // ChainTo composes to the second [IOEither] monad ignoring the return value of the first
-func ChainTo[A, E, B any](fb IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
+func ChainTo[E, A, B any](fb IOEither[E, B]) func(IOEither[E, A]) IOEither[E, B] {
 	return G.ChainTo[IOEither[E, A]](fb)
 }
 
@@ -271,8 +266,3 @@ func MonadFlap[E, B, A any](fab IOEither[E, func(A) B], a A) IOEither[E, B] {
 func Flap[E, B, A any](a A) func(IOEither[E, func(A) B]) IOEither[E, B] {
 	return G.Flap[IOEither[E, func(A) B], IOEither[E, B]](a)
 }
-
-// ToIOOption converts an [IOEither] to an [IOO.IOOption]
-func ToIOOption[E, A any](ioe IOEither[E, A]) IOO.IOOption[A] {
-	return G.ToIOOption[IOO.IOOption[A]](ioe)
-}

ioeither/traverse.go

@@ -48,63 +48,3 @@ func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) IOEither[E,
 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)
 }
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}
-
-// 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)
-}

iooption/generic/iooption.go

@@ -20,7 +20,6 @@ import (
 
 	ET "github.com/IBM/fp-go/either"
 	F "github.com/IBM/fp-go/function"
-	C "github.com/IBM/fp-go/internal/chain"
 	FI "github.com/IBM/fp-go/internal/fromio"
 	"github.com/IBM/fp-go/internal/optiont"
 	IO "github.com/IBM/fp-go/io/generic"
@@ -65,6 +64,13 @@ func FromEither[GA ~func() O.Option[A], E, A any](e ET.Either[E, A]) GA {
 	)
 }
 
+func FromIOEither[GA ~func() O.Option[A], GEA ~func() ET.Either[E, A], E, A any](ioe GEA) GA {
+	return F.Pipe1(
+		ioe,
+		IO.Map[GEA, GA](ET.ToOption[E, A]),
+	)
+}
+
 func MonadMap[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA, f func(A) B) GB {
 	return optiont.MonadMap(IO.MonadMap[GA, GB, O.Option[A], O.Option[B]], fa, f)
 }
@@ -77,48 +83,8 @@ func MonadChain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](fa GA,
 	return optiont.MonadChain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], fa, f)
 }
 
-// MonadChainFirst runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) GB) GA {
-	return C.MonadChainFirst(
-		MonadChain[GA, GA, A, A],
-		MonadMap[GB, GA, B, A],
-		ma,
-		f,
-	)
-}
-
-// ChainFirst runs the monad returned by the function but returns the result of the original monad
-func ChainFirst[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GA {
-	return C.ChainFirst(
-		MonadChain[GA, GA, A, A],
-		MonadMap[GB, GA, B, A],
-		f,
-	)
-}
-
-// MonadChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](first GA, f func(A) GIOB) GA {
-	return FI.MonadChainFirstIOK(
-		MonadChain[GA, GA, A, A],
-		MonadMap[func() O.Option[B], GA, B, A],
-		FromIO[func() O.Option[B], GIOB, B],
-		first,
-		f,
-	)
-}
-
-// ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func ChainFirstIOK[GA ~func() O.Option[A], GIOB ~func() B, A, B any](f func(A) GIOB) func(GA) GA {
-	return FI.ChainFirstIOK(
-		MonadChain[GA, GA, A, A],
-		MonadMap[func() O.Option[B], GA, B, A],
-		FromIO[func() O.Option[B], GIOB, B],
-		f,
-	)
-}
-
 func Chain[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](f func(A) GB) func(GA) GB {
-	return optiont.Chain(IO.MonadChain[GA, GB, O.Option[A], O.Option[B]], IO.MonadOf[GB, O.Option[B]], f)
+	return F.Bind2nd(MonadChain[GA, GB, A, B], f)
 }
 
 func MonadChainOptionK[GA ~func() O.Option[A], GB ~func() O.Option[B], A, B any](ma GA, f func(A) O.Option[B]) GB {
@@ -228,17 +194,3 @@ func Fold[GA ~func() O.Option[A], GB ~func() B, A, B any](onNone func() GB, onSo
 func Defer[GA ~func() O.Option[A], A any](gen func() GA) GA {
 	return IO.Defer[GA](gen)
 }
-
-func MonadAlt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](first GIOA, second LAZY) GIOA {
-	return optiont.MonadAlt(
-		IO.Of[GIOA],
-		IO.MonadChain[GIOA, GIOA],
-
-		first,
-		second,
-	)
-}
-
-func Alt[LAZY ~func() GIOA, GIOA ~func() O.Option[A], A any](second LAZY) func(GIOA) GIOA {
-	return F.Bind2nd(MonadAlt[LAZY], second)
-}

iooption/generic/resource.go

@@ -1,31 +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 (
-	F "github.com/IBM/fp-go/function"
-	O "github.com/IBM/fp-go/option"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	GA ~func() O.Option[A],
-	GR ~func() O.Option[R],
-	GANY ~func() O.Option[ANY],
-	R, A, ANY any](onCreate GR, onRelease func(R) GANY) func(func(R) GA) GA {
-	// simply map to implementation of bracket
-	return F.Bind13of3(Bracket[GR, GA, GANY, R, A, ANY])(onCreate, F.Ignore2of2[O.Option[A]](onRelease))
-}

iooption/iooption.go

@@ -18,9 +18,8 @@ package iooption
 import (
 	ET "github.com/IBM/fp-go/either"
 	I "github.com/IBM/fp-go/io"
-	IO "github.com/IBM/fp-go/io"
+	IOE "github.com/IBM/fp-go/ioeither"
 	G "github.com/IBM/fp-go/iooption/generic"
-	L "github.com/IBM/fp-go/lazy"
 	O "github.com/IBM/fp-go/option"
 )
 
@@ -130,37 +129,12 @@ func Defer[A any](gen func() IOOption[A]) IOOption[A] {
 	return G.Defer[IOOption[A]](gen)
 }
 
+// FromIOEither converts an [IOEither] into an [IOOption]
+func FromIOEither[E, A any](ioe IOE.IOEither[E, A]) IOOption[A] {
+	return G.FromIOEither[IOOption[A]](ioe)
+}
+
 // FromEither converts an [Either] into an [IOOption]
 func FromEither[E, A any](e ET.Either[E, A]) IOOption[A] {
 	return G.FromEither[IOOption[A]](e)
 }
-
-// MonadAlt identifies an associative operation on a type constructor
-func MonadAlt[A any](first IOOption[A], second L.Lazy[IOOption[A]]) IOOption[A] {
-	return G.MonadAlt(first, second)
-}
-
-// Alt identifies an associative operation on a type constructor
-func Alt[A any](second L.Lazy[IOOption[A]]) func(IOOption[A]) IOOption[A] {
-	return G.Alt(second)
-}
-
-// MonadChainFirst runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirst[A, B any](ma IOOption[A], f func(A) IOOption[B]) IOOption[A] {
-	return G.MonadChainFirst[IOOption[A], IOOption[B]](ma, f)
-}
-
-// ChainFirst runs the monad returned by the function but returns the result of the original monad
-func ChainFirst[A, B any](f func(A) IOOption[B]) func(IOOption[A]) IOOption[A] {
-	return G.ChainFirst[IOOption[A], IOOption[B]](f)
-}
-
-// MonadChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func MonadChainFirstIOK[A, B any](first IOOption[A], f func(A) IO.IO[B]) IOOption[A] {
-	return G.MonadChainFirstIOK[IOOption[A], IO.IO[B]](first, f)
-}
-
-// ChainFirstIOK runs the monad returned by the function but returns the result of the original monad
-func ChainFirstIOK[A, B any](f func(A) IO.IO[B]) func(IOOption[A]) IOOption[A] {
-	return G.ChainFirstIOK[IOOption[A], IO.IO[B]](f)
-}

iooption/resource.go

@@ -1,27 +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 iooption
-
-import (
-	G "github.com/IBM/fp-go/iooption/generic"
-)
-
-// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
-func WithResource[
-	R, A, ANY any](onCreate IOOption[R], onRelease func(R) IOOption[ANY]) func(func(R) IOOption[A]) IOOption[A] {
-	// just dispatch
-	return G.WithResource[IOOption[A], IOOption[R], IOOption[ANY]](onCreate, onRelease)
-}

iterator/stateless/uniq.go

@@ -19,13 +19,13 @@ import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 )
 
-// StrictUniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items
+// StrictUniq converts an [Iterator] or arbitrary items into an [Iterator] or unique items
 // where uniqueness is determined by the built-in uniqueness constraint
 func StrictUniq[A comparable](as Iterator[A]) Iterator[A] {
 	return G.StrictUniq[Iterator[A]](as)
 }
 
-// Uniq converts an [Iterator] of arbitrary items into an [Iterator] or unique items
+// Uniq converts an [Iterator] or arbitrary items into an [Iterator] or unique items
 // where uniqueness is determined based on a key extractor function
 func Uniq[A any, K comparable](f func(A) K) func(as Iterator[A]) Iterator[A] {
 	return G.Uniq[Iterator[A], K](f)

option/array.go

@@ -65,7 +65,7 @@ func SequenceArray[A any](ma []Option[A]) Option[[]A] {
 func CompactArrayG[A1 ~[]Option[A], A2 ~[]A, A any](fa A1) A2 {
 	return RA.Reduce(fa, func(out A2, value Option[A]) A2 {
 		return MonadFold(value, F.Constant(out), F.Bind1st(RA.Append[A2, A], out))
-	}, make(A2, 0, len(fa)))
+	}, make(A2, len(fa)))
 }
 
 // CompactArray discards the none values and keeps the some values

option/array_test.go

@@ -34,14 +34,3 @@ func TestSequenceArray(t *testing.T) {
 
 	assert.Equal(t, res, Of([]int{1, 2}))
 }
-
-func TestCompactArray(t *testing.T) {
-	ar := []Option[string]{
-		Of("ok"),
-		None[string](),
-		Of("ok"),
-	}
-
-	res := CompactArray(ar)
-	assert.Equal(t, 2, len(res))
-}

samples/tuples/option_test.go

@@ -52,7 +52,7 @@ func TestIOEitherToOption2(t *testing.T) {
 		content,
 		IOEF.WriteFile(filepath.Join(tmpDir, "test.txt"), os.ModePerm),
 		IOE.Swap[error, []byte],
-		IOE.ToIOOption[[]byte, error],
+		IOO.FromIOEither[[]byte, error],
 	)
 
 	fmt.Println(resIOO())