diff --git a/context/readerioeither/generic/traverse.go b/context/readerioeither/generic/traverse.go index 9f15a51..664d4e8 100644 --- a/context/readerioeither/generic/traverse.go +++ b/context/readerioeither/generic/traverse.go @@ -166,3 +166,289 @@ 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]) +} diff --git a/context/readerioeither/traverse.go b/context/readerioeither/traverse.go index b7aa4de..f85739e 100644 --- a/context/readerioeither/traverse.go +++ b/context/readerioeither/traverse.go @@ -48,3 +48,63 @@ 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) +} diff --git a/io/generic/ap.go b/io/generic/ap.go index cd88ea7..2b5b39c 100644 --- a/io/generic/ap.go +++ b/io/generic/ap.go @@ -16,6 +16,7 @@ package generic import ( + F "github.com/IBM/fp-go/function" G "github.com/IBM/fp-go/internal/apply" ) @@ -27,7 +28,10 @@ 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 mab()(ma()) + return F.Pipe1( + ma(), + mab(), + ) }) } diff --git a/ioeither/generic/traverse.go b/ioeither/generic/traverse.go index 358b92c..92165df 100644 --- a/ioeither/generic/traverse.go +++ b/ioeither/generic/traverse.go @@ -111,3 +111,183 @@ 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]) +} diff --git a/ioeither/traverse.go b/ioeither/traverse.go index 21846ed..f406c14 100644 --- a/ioeither/traverse.go +++ b/ioeither/traverse.go @@ -48,3 +48,63 @@ 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) +}