mirror of
https://github.com/IBM/fp-go.git
synced 2025-08-08 22:27:07 +02:00
fix: add missing TraverseArraySeq
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
@@ -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])
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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(),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -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])
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user