diff --git a/context/reader/array.go b/context/reader/array.go index c43a5ec..b7dd9bc 100644 --- a/context/reader/array.go +++ b/context/reader/array.go @@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) Reader[B]) func([]A) Reader[[]B] { return R.TraverseArray[Reader[B], Reader[[]B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[A, B any](f func(int, A) Reader[B]) func([]A) Reader[[]B] { + return R.TraverseArrayWithIndex[Reader[B], Reader[[]B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[A any](ma []Reader[A]) Reader[[]A] { return R.SequenceArray[Reader[A], Reader[[]A]](ma) diff --git a/context/readereither/array.go b/context/readereither/array.go index 86d08de..18a547b 100644 --- a/context/readereither/array.go +++ b/context/readereither/array.go @@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderEither[B]) func([]A) ReaderEither[[ return RE.TraverseArray[ReaderEither[B], ReaderEither[[]B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderEither[B]) func([]A) ReaderEither[[]B] { + return RE.TraverseArrayWithIndex[ReaderEither[B], ReaderEither[[]B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[A any](ma []ReaderEither[A]) ReaderEither[[]A] { return RE.SequenceArray[ReaderEither[A], ReaderEither[[]A]](ma) diff --git a/context/readerio/array.go b/context/readerio/array.go index 20174de..da73f53 100644 --- a/context/readerio/array.go +++ b/context/readerio/array.go @@ -25,6 +25,11 @@ func TraverseArray[A, B any](f func(A) ReaderIO[B]) func([]A) ReaderIO[[]B] { return R.TraverseArray[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIO[B]) func([]A) ReaderIO[[]B] { + return R.TraverseArrayWithIndex[ReaderIO[B], ReaderIO[[]B], IO.IO[B], IO.IO[[]B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[A any](ma []ReaderIO[A]) ReaderIO[[]A] { return R.SequenceArray[ReaderIO[A], ReaderIO[[]A]](ma) diff --git a/context/readerioeither/generic/traverse.go b/context/readerioeither/generic/traverse.go index 86c7e37..9f15a51 100644 --- a/context/readerioeither/generic/traverse.go +++ b/context/readerioeither/generic/traverse.go @@ -62,6 +62,25 @@ func TraverseArray[ ) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[ + 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], + Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB], + + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[ AS ~[]A, @@ -115,6 +134,26 @@ func TraverseRecord[K comparable, ) } +// TraverseRecordWithIndex transforms a record +func TraverseRecordWithIndex[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], + Ap[GRBS, func(context.Context) func() E.Either[error, func(B) BS], GRB], + + f, + ) +} + // SequenceRecord converts a homogeneous sequence of either into an either of sequence func SequenceRecord[K comparable, AS ~map[K]A, diff --git a/context/readerioeither/traverse.go b/context/readerioeither/traverse.go index 6859c05..b7aa4de 100644 --- a/context/readerioeither/traverse.go +++ b/context/readerioeither/traverse.go @@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) ReaderIOEither[B]) func([]A) ReaderIOEith return G.TraverseArray[[]A, ReaderIOEither[[]B]](f) } +// TraverseArrayWithIndex uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]] +func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOEither[B]) func([]A) ReaderIOEither[[]B] { + return G.TraverseArrayWithIndex[[]A, ReaderIOEither[[]B]](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] { return G.SequenceArray[[]A, []ReaderIOEither[A], ReaderIOEither[[]A]](ma) @@ -34,6 +39,11 @@ func TraverseRecord[K comparable, A, B any](f func(A) ReaderIOEither[B]) func(ma return G.TraverseRecord[K, map[K]A, ReaderIOEither[map[K]B]](f) } +// TraverseRecordWithIndex uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]] +func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) func(map[K]A) ReaderIOEither[map[K]B] { + return G.TraverseRecordWithIndex[K, map[K]A, ReaderIOEither[map[K]B]](f) +} + // SequenceRecord converts a homogeneous sequence of either into an either of sequence 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) diff --git a/either/array.go b/either/array.go index cf713df..f3151dd 100644 --- a/either/array.go +++ b/either/array.go @@ -20,7 +20,7 @@ import ( RA "github.com/IBM/fp-go/internal/array" ) -// TraverseArray transforms an array +// TraverseArrayG transforms an array func TraverseArrayG[GA ~[]A, GB ~[]B, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] { return RA.Traverse[GA]( Of[E, GB], @@ -36,6 +36,22 @@ func TraverseArray[E, A, B any](f func(A) Either[E, B]) func([]A) Either[E, []B] return TraverseArrayG[[]A, []B](f) } +// TraverseArrayWithIndexG transforms an array +func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, E, A, B any](f func(int, A) Either[E, B]) func(GA) Either[E, GB] { + return RA.TraverseWithIndex[GA]( + Of[E, GB], + Map[E, GB, func(B) GB], + Ap[GB, E, B], + + f, + ) +} + +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[E, A, B any](f func(int, A) Either[E, B]) func([]A) Either[E, []B] { + return TraverseArrayWithIndexG[[]A, []B](f) +} + func SequenceArrayG[GA ~[]A, GOA ~[]Either[E, A], E, A any](ma GOA) Either[E, GA] { return TraverseArrayG[GOA, GA](F.Identity[Either[E, A]])(ma) } diff --git a/either/record.go b/either/record.go index bd326f1..0058f23 100644 --- a/either/record.go +++ b/either/record.go @@ -20,7 +20,7 @@ import ( RR "github.com/IBM/fp-go/internal/record" ) -// TraverseRecord transforms a record of options into an option of a record +// TraverseRecordG transforms a record of options into an option of a record func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(A) Either[E, B]) func(GA) Either[E, GB] { return RR.Traverse[GA]( Of[E, GB], @@ -35,6 +35,21 @@ func TraverseRecord[K comparable, E, A, B any](f func(A) Either[E, B]) func(map[ return TraverseRecordG[map[K]A, map[K]B](f) } +// TraverseRecordWithIndexG transforms a record of options into an option of a record +func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, E, A, B any](f func(K, A) Either[E, B]) func(GA) Either[E, GB] { + return RR.TraverseWithIndex[GA]( + Of[E, GB], + Map[E, GB, func(B) GB], + Ap[GB, E, B], + f, + ) +} + +// TraverseRecordWithIndex transforms a record of eithers into an either of a record +func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) Either[E, B]) func(map[K]A) Either[E, map[K]B] { + return TraverseRecordWithIndexG[map[K]A, map[K]B](f) +} + func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Either[E, A], K comparable, E, A any](ma GOA) Either[E, GA] { return TraverseRecordG[GOA, GA](F.Identity[Either[E, A]])(ma) } diff --git a/internal/array/traverse.go b/internal/array/traverse.go index 1f0f6af..df3ef39 100644 --- a/internal/array/traverse.go +++ b/internal/array/traverse.go @@ -37,6 +37,24 @@ func MonadTraverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any]( return MonadTraverseReduce(fof, fmap, fap, ta, f, Append[GB, B], Empty[GB]()) } +/* +* +We need to pass the members of the applicative explicitly, because golang does neither support higher kinded types nor template methods on structs or interfaces + +HKTRB = HKT +HKTB = HKT +HKTAB = HKT +*/ +func MonadTraverseWithIndex[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any]( + fof func(GB) HKTRB, + fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, + fap func(HKTB) func(HKTAB) HKTRB, + + ta GA, + f func(int, A) HKTB) HKTRB { + return MonadTraverseReduceWithIndex(fof, fmap, fap, ta, f, Append[GB, B], Empty[GB]()) +} + func Traverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any]( fof func(GB) HKTRB, fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, @@ -49,6 +67,18 @@ func Traverse[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any]( } } +func TraverseWithIndex[GA ~[]A, GB ~[]B, A, B, HKTB, HKTAB, HKTRB any]( + fof func(GB) HKTRB, + fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, + fap func(HKTB) func(HKTAB) HKTRB, + + f func(int, A) HKTB) func(GA) HKTRB { + + return func(ma GA) HKTRB { + return MonadTraverseWithIndex(fof, fmap, fap, ma, f) + } +} + func MonadTraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( fof func(GB) HKTRB, fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, @@ -71,6 +101,28 @@ func MonadTraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( }, fof(initial)) } +func MonadTraverseReduceWithIndex[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( + fof func(GB) HKTRB, + fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, + fap func(HKTB) func(HKTAB) HKTRB, + + ta GA, + + transform func(int, A) HKTB, + reduce func(GB, B) GB, + initial GB, +) HKTRB { + mmap := fmap(F.Curry2(reduce)) + + return ReduceWithIndex(ta, func(idx int, r HKTRB, a A) HKTRB { + return F.Pipe2( + r, + mmap, + fap(transform(idx, a)), + ) + }, fof(initial)) +} + func TraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( fof func(GB) HKTRB, fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, @@ -84,3 +136,17 @@ func TraverseReduce[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( return MonadTraverseReduce(fof, fmap, fap, ta, transform, reduce, initial) } } + +func TraverseReduceWithIndex[GA ~[]A, GB, A, B, HKTB, HKTAB, HKTRB any]( + fof func(GB) HKTRB, + fmap func(func(GB) func(B) GB) func(HKTRB) HKTAB, + fap func(HKTB) func(HKTAB) HKTRB, + + transform func(int, A) HKTB, + reduce func(GB, B) GB, + initial GB, +) func(GA) HKTRB { + return func(ta GA) HKTRB { + return MonadTraverseReduceWithIndex(fof, fmap, fap, ta, transform, reduce, initial) + } +} diff --git a/io/generic/traverse.go b/io/generic/traverse.go index 2a2121f..71e256c 100644 --- a/io/generic/traverse.go +++ b/io/generic/traverse.go @@ -42,6 +42,16 @@ func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any]( ) } +func TraverseArrayWithIndex[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(int, A) GB) func(AAS) GBS { + return RA.TraverseWithIndex[AAS]( + Of[GBS, BBS], + Map[GBS, func() func(B) BBS, BBS, func(B) BBS], + Ap[GBS, func() func(B) BBS, GB], + + f, + ) +} + func SequenceArray[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS { return MonadTraverseArray[GA, GAS](tas, F.Identity[GA]) } @@ -66,6 +76,16 @@ func TraverseRecord[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K co ) } +// TraverseRecordWithIndex transforms a record using an IO transform an IO of a record +func TraverseRecordWithIndex[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[K]B, K comparable, A, B any](f func(K, A) GB) func(MA) GBS { + return RR.TraverseWithIndex[MA]( + Of[GBS, MB], + Map[GBS, func() func(B) MB, MB, func(B) MB], + Ap[GBS, func() func(B) MB, GB], + f, + ) +} + func SequenceRecord[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS { return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA]) } diff --git a/io/traverse.go b/io/traverse.go index e52026a..4065afa 100644 --- a/io/traverse.go +++ b/io/traverse.go @@ -29,6 +29,12 @@ func TraverseArray[A, B any](f func(A) IO[B]) func([]A) IO[[]B] { return G.TraverseArray[IO[B], IO[[]B], []A](f) } +// TraverseArrayWithIndex applies a function returning an [IO] to all elements in an array and the +// transforms this into an [IO] of that array +func TraverseArrayWithIndex[A, B any](f func(int, A) IO[B]) func([]A) IO[[]B] { + return G.TraverseArrayWithIndex[IO[B], IO[[]B], []A](f) +} + // SequenceArray converts an array of [IO] to an [IO] of an array func SequenceArray[A any](tas []IO[A]) IO[[]A] { return G.SequenceArray[IO[A], IO[[]A]](tas) @@ -38,12 +44,18 @@ func MonadTraverseRecord[K comparable, A, B any](tas map[K]A, f func(A) IO[B]) I return G.MonadTraverseRecord[IO[B], IO[map[K]B]](tas, f) } -// TraverseArray applies a function returning an [IO] to all elements in a record and the +// TraverseRecord applies a function returning an [IO] to all elements in a record and the // transforms this into an [IO] of that record func TraverseRecord[K comparable, A, B any](f func(A) IO[B]) func(map[K]A) IO[map[K]B] { return G.TraverseRecord[IO[B], IO[map[K]B], map[K]A](f) } +// TraverseRecordWithIndex applies a function returning an [IO] to all elements in a record and the +// transforms this into an [IO] of that record +func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) IO[B]) func(map[K]A) IO[map[K]B] { + return G.TraverseRecordWithIndex[IO[B], IO[map[K]B], map[K]A](f) +} + // SequenceRecord converts a record of [IO] to an [IO] of a record func SequenceRecord[K comparable, A any](tas map[K]IO[A]) IO[map[K]A] { return G.SequenceRecord[IO[A], IO[map[K]A]](tas) diff --git a/ioeither/generic/traverse.go b/ioeither/generic/traverse.go index b84a601..358b92c 100644 --- a/ioeither/generic/traverse.go +++ b/ioeither/generic/traverse.go @@ -45,6 +45,29 @@ func TraverseArray[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], AA ) } +// MonadTraverseArrayWithIndex transforms an array +func MonadTraverseArrayWithIndex[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], + Ap[GBS, func() ET.Either[E, func(B) BBS], GB], + + tas, + f, + ) +} + +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[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], + Ap[GBS, func() ET.Either[E, func(B) BBS], GB], + + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[GA ~func() ET.Either[E, A], GAS ~func() ET.Either[E, AAS], AAS ~[]A, GAAS ~[]GA, E, A any](tas GAAS) GAS { return MonadTraverseArray[GA, GAS](tas, F.Identity[GA]) @@ -73,6 +96,17 @@ func TraverseRecord[GB ~func() ET.Either[E, B], GBS ~func() ET.Either[E, BBS], A ) } +// TraverseRecordWithIndex transforms an array +func TraverseRecordWithIndex[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], + Ap[GBS, func() ET.Either[E, func(B) BBS], GB], + + f, + ) +} + // SequenceRecord converts a homogeneous sequence of either into an either of sequence 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]) diff --git a/ioeither/traverse.go b/ioeither/traverse.go index dda411c..21846ed 100644 --- a/ioeither/traverse.go +++ b/ioeither/traverse.go @@ -24,6 +24,11 @@ func TraverseArray[E, A, B any](f func(A) IOEither[E, B]) func([]A) IOEither[E, return G.TraverseArray[IOEither[E, B], IOEither[E, []B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[E, A, B any](f func(int, A) IOEither[E, B]) func([]A) IOEither[E, []B] { + return G.TraverseArrayWithIndex[IOEither[E, B], IOEither[E, []B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[E, A any](ma []IOEither[E, A]) IOEither[E, []A] { return G.SequenceArray[IOEither[E, A], IOEither[E, []A]](ma) @@ -34,6 +39,11 @@ func TraverseRecord[K comparable, E, A, B any](f func(A) IOEither[E, B]) func(ma return G.TraverseRecord[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f) } +// TraverseRecordWithIndex transforms a record +func TraverseRecordWithIndex[K comparable, E, A, B any](f func(K, A) IOEither[E, B]) func(map[K]A) IOEither[E, map[K]B] { + return G.TraverseRecordWithIndex[IOEither[E, B], IOEither[E, map[K]B], map[K]A](f) +} + // SequenceRecord converts a homogeneous sequence of either into an either of sequence func SequenceRecord[K comparable, E, A any](ma map[K]IOEither[E, A]) IOEither[E, map[K]A] { return G.SequenceRecord[IOEither[E, A], IOEither[E, map[K]A]](ma) diff --git a/ioeither/traverse_test.go b/ioeither/traverse_test.go new file mode 100644 index 0000000..4158192 --- /dev/null +++ b/ioeither/traverse_test.go @@ -0,0 +1,37 @@ +// 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 ioeither + +import ( + "fmt" + "testing" + + A "github.com/IBM/fp-go/array" + E "github.com/IBM/fp-go/either" + "github.com/stretchr/testify/assert" +) + +func TestTraverseArray(t *testing.T) { + + src := A.From("A", "B") + + trfrm := TraverseArrayWithIndex(func(idx int, data string) IOEither[error, string] { + return Of[error](fmt.Sprintf("idx: %d, data: %s", idx, data)) + }) + + assert.Equal(t, E.Of[error](A.From("idx: 0, data: A", "idx: 1, data: B")), trfrm(src)()) + +} diff --git a/iooption/array.go b/iooption/array.go index 1b8b2d9..93327b5 100644 --- a/iooption/array.go +++ b/iooption/array.go @@ -24,6 +24,11 @@ func TraverseArray[A, B any](f func(A) IOOption[B]) func([]A) IOOption[[]B] { return G.TraverseArray[IOOption[B], IOOption[[]B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[A, B any](f func(int, A) IOOption[B]) func([]A) IOOption[[]B] { + return G.TraverseArrayWithIndex[IOOption[B], IOOption[[]B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[A any](ma []IOOption[A]) IOOption[[]A] { return G.SequenceArray[IOOption[A], IOOption[[]A], []IOOption[A], []A, A](ma) diff --git a/iooption/generic/traverse.go b/iooption/generic/traverse.go index 9c51fdf..6d0aa16 100644 --- a/iooption/generic/traverse.go +++ b/iooption/generic/traverse.go @@ -28,6 +28,13 @@ func TraverseArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]A, GB ) } +func TraverseArrayWithIndex[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]A, GB ~[]B, A, B any](f func(int, A) TB) func(GA) TBS { + return F.Flow2( + I.TraverseArrayWithIndex[TB, func() []O.Option[B], GA](f), + I.Map[func() []O.Option[B], TBS](O.SequenceArrayG[GB, []O.Option[B], B]), + ) +} + func SequenceArray[TB ~func() O.Option[B], TBS ~func() O.Option[GB], GA ~[]TB, GB ~[]B, A, B any](ma GA) TBS { return TraverseArray[TB, TBS, GA](F.Identity[TB])(ma) } diff --git a/lazy/traverse.go b/lazy/traverse.go index 3e3ee0f..3498569 100644 --- a/lazy/traverse.go +++ b/lazy/traverse.go @@ -29,6 +29,12 @@ func TraverseArray[A, B any](f func(A) Lazy[B]) func([]A) Lazy[[]B] { return G.TraverseArray[Lazy[B], Lazy[[]B], []A](f) } +// TraverseArrayWithIndex applies a function returning an [IO] to all elements in an array and the +// transforms this into an [IO] of that array +func TraverseArrayWithIndex[A, B any](f func(int, A) Lazy[B]) func([]A) Lazy[[]B] { + return G.TraverseArrayWithIndex[Lazy[B], Lazy[[]B], []A](f) +} + // SequenceArray converts an array of [IO] to an [IO] of an array func SequenceArray[A any](tas []Lazy[A]) Lazy[[]A] { return G.SequenceArray[Lazy[A], Lazy[[]A]](tas) @@ -38,12 +44,18 @@ func MonadTraverseRecord[K comparable, A, B any](tas map[K]A, f func(A) Lazy[B]) return G.MonadTraverseRecord[Lazy[B], Lazy[map[K]B]](tas, f) } -// TraverseArray applies a function returning an [IO] to all elements in a record and the +// TraverseRecord applies a function returning an [IO] to all elements in a record and the // transforms this into an [IO] of that record func TraverseRecord[K comparable, A, B any](f func(A) Lazy[B]) func(map[K]A) Lazy[map[K]B] { return G.TraverseRecord[Lazy[B], Lazy[map[K]B], map[K]A](f) } +// TraverseRecord applies a function returning an [IO] to all elements in a record and the +// transforms this into an [IO] of that record +func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) Lazy[B]) func(map[K]A) Lazy[map[K]B] { + return G.TraverseRecordWithIndex[Lazy[B], Lazy[map[K]B], map[K]A](f) +} + // SequenceRecord converts a record of [IO] to an [IO] of a record func SequenceRecord[K comparable, A any](tas map[K]Lazy[A]) Lazy[map[K]A] { return G.SequenceRecord[Lazy[A], Lazy[map[K]A]](tas) diff --git a/option/array.go b/option/array.go index 19c273e..2fd02b1 100644 --- a/option/array.go +++ b/option/array.go @@ -36,6 +36,22 @@ func TraverseArray[A, B any](f func(A) Option[B]) func([]A) Option[[]B] { return TraverseArrayG[[]A, []B](f) } +// TraverseArrayWithIndexG transforms an array +func TraverseArrayWithIndexG[GA ~[]A, GB ~[]B, A, B any](f func(int, A) Option[B]) func(GA) Option[GB] { + return RA.TraverseWithIndex[GA]( + Of[GB], + Map[GB, func(B) GB], + Ap[GB, B], + + f, + ) +} + +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[A, B any](f func(int, A) Option[B]) func([]A) Option[[]B] { + return TraverseArrayWithIndexG[[]A, []B](f) +} + func SequenceArrayG[GA ~[]A, GOA ~[]Option[A], A any](ma GOA) Option[GA] { return TraverseArrayG[GOA, GA](F.Identity[Option[A]])(ma) } diff --git a/option/record.go b/option/record.go index af9181b..eff5222 100644 --- a/option/record.go +++ b/option/record.go @@ -20,7 +20,7 @@ import ( RR "github.com/IBM/fp-go/internal/record" ) -// TraverseRecord transforms a record of options into an option of a record +// TraverseRecordG transforms a record of options into an option of a record func TraverseRecordG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(A) Option[B]) func(GA) Option[GB] { return RR.Traverse[GA]( Of[GB], @@ -36,6 +36,22 @@ func TraverseRecord[K comparable, A, B any](f func(A) Option[B]) func(map[K]A) O return TraverseRecordG[map[K]A, map[K]B](f) } +// TraverseRecordWithIndexG transforms a record of options into an option of a record +func TraverseRecordWithIndexG[GA ~map[K]A, GB ~map[K]B, K comparable, A, B any](f func(K, A) Option[B]) func(GA) Option[GB] { + return RR.TraverseWithIndex[GA]( + Of[GB], + Map[GB, func(B) GB], + Ap[GB, B], + + f, + ) +} + +// TraverseRecordWithIndex transforms a record of options into an option of a record +func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) Option[B]) func(map[K]A) Option[map[K]B] { + return TraverseRecordWithIndexG[map[K]A, map[K]B](f) +} + func SequenceRecordG[GA ~map[K]A, GOA ~map[K]Option[A], K comparable, A any](ma GOA) Option[GA] { return TraverseRecordG[GOA, GA](F.Identity[Option[A]])(ma) } diff --git a/reader/array.go b/reader/array.go index de450cd..a19953b 100644 --- a/reader/array.go +++ b/reader/array.go @@ -24,6 +24,11 @@ func TraverseArray[R, A, B any](f func(A) Reader[R, B]) func([]A) Reader[R, []B] return G.TraverseArray[Reader[R, B], Reader[R, []B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[R, A, B any](f func(int, A) Reader[R, B]) func([]A) Reader[R, []B] { + return G.TraverseArrayWithIndex[Reader[R, B], Reader[R, []B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[R, A any](ma []Reader[R, A]) Reader[R, []A] { return G.SequenceArray[Reader[R, A], Reader[R, []A]](ma) diff --git a/reader/generic/array.go b/reader/generic/array.go index a97b29e..9fa58db 100644 --- a/reader/generic/array.go +++ b/reader/generic/array.go @@ -40,6 +40,16 @@ func TraverseArray[GB ~func(R) B, GBS ~func(R) BBS, AAS ~[]A, BBS ~[]B, R, A, B ) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[GB ~func(R) B, GBS ~func(R) BBS, AAS ~[]A, BBS ~[]B, R, A, B any](f func(int, A) GB) func(AAS) GBS { + return RA.TraverseWithIndex[AAS]( + Of[GBS, R, BBS], + Map[GBS, func(R) func(B) BBS, R, BBS, func(B) BBS], + Ap[GB, GBS, func(R) func(B) BBS, R, B, BBS], + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[GA ~func(R) A, GAS ~func(R) AAS, AAS ~[]A, GAAS ~[]GA, R, A any](ma GAAS) GAS { return MonadTraverseArray[GA, GAS](ma, F.Identity[GA]) diff --git a/readereither/array.go b/readereither/array.go index f0f0653..0a940e2 100644 --- a/readereither/array.go +++ b/readereither/array.go @@ -24,6 +24,11 @@ func TraverseArray[E, L, A, B any](f func(A) ReaderEither[E, L, B]) func([]A) Re return G.TraverseArray[ReaderEither[E, L, B], ReaderEither[E, L, []B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[E, L, A, B any](f func(int, A) ReaderEither[E, L, B]) func([]A) ReaderEither[E, L, []B] { + return G.TraverseArrayWithIndex[ReaderEither[E, L, B], ReaderEither[E, L, []B], []A](f) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[E, L, A any](ma []ReaderEither[E, L, A]) ReaderEither[E, L, []A] { return G.SequenceArray[ReaderEither[E, L, A], ReaderEither[E, L, []A]](ma) diff --git a/readereither/generic/array.go b/readereither/generic/array.go index 43d99a2..f18411f 100644 --- a/readereither/generic/array.go +++ b/readereither/generic/array.go @@ -43,6 +43,17 @@ func TraverseArray[GB ~func(E) ET.Either[L, B], GBS ~func(E) ET.Either[L, BBS], ) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[GB ~func(E) ET.Either[L, B], GBS ~func(E) ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, L, E, A, B any](f func(int, A) GB) func(AAS) GBS { + return RA.TraverseWithIndex[AAS]( + Of[GBS, L, E, BBS], + Map[GBS, func(E) ET.Either[L, func(B) BBS], L, E, BBS, func(B) BBS], + Ap[GB, GBS, func(E) ET.Either[L, func(B) BBS], L, E, B, BBS], + + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[GA ~func(E) ET.Either[L, A], GAS ~func(E) ET.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, L, E, A any](ma GAAS) GAS { return MonadTraverseArray[GA, GAS](ma, F.Identity[GA]) diff --git a/readerio/array.go b/readerio/array.go index 6592aad..53cc03f 100644 --- a/readerio/array.go +++ b/readerio/array.go @@ -25,6 +25,11 @@ func TraverseArray[R, A, B any](f func(A) ReaderIO[R, B]) func([]A) ReaderIO[R, return G.TraverseArray[ReaderIO[R, B], ReaderIO[R, []B], IO.IO[B], IO.IO[[]B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[R, A, B any](f func(int, A) ReaderIO[R, B]) func([]A) ReaderIO[R, []B] { + return G.TraverseArrayWithIndex[ReaderIO[R, B], ReaderIO[R, []B], IO.IO[B], IO.IO[[]B], []A](f) +} + // SequenceArray converts a homogeneous sequence of Readers into a Reader of sequence func SequenceArray[R, A any](ma []ReaderIO[R, A]) ReaderIO[R, []A] { return G.SequenceArray[ReaderIO[R, A], ReaderIO[R, []A]](ma) diff --git a/readerio/generic/array.go b/readerio/generic/array.go index 996cb66..a9f63d2 100644 --- a/readerio/generic/array.go +++ b/readerio/generic/array.go @@ -42,6 +42,17 @@ func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() B, GIOBS ~ ) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() B, GIOBS ~func() BBS, AAS ~[]A, BBS ~[]B, E, A, B any](f func(int, A) GB) func(AAS) GBS { + return RA.TraverseWithIndex[AAS]( + Of[GBS, GIOBS, E, BBS], + Map[GBS, func(E) func() func(B) BBS, GIOBS, func() func(B) BBS, E, BBS, func(B) BBS], + Ap[GB, GBS, func(E) func() func(B) BBS, GIOB, GIOBS, func() func(B) BBS, E, B, BBS], + + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() A, GIOAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, E, A any](ma GAAS) GAS { return MonadTraverseArray[GA, GAS](ma, F.Identity[GA]) diff --git a/readerioeither/generic/traverse.go b/readerioeither/generic/traverse.go index 003f49e..d935a19 100644 --- a/readerioeither/generic/traverse.go +++ b/readerioeither/generic/traverse.go @@ -44,6 +44,17 @@ func TraverseArray[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[ ) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[GB ~func(E) GIOB, GBS ~func(E) GIOBS, GIOB ~func() ET.Either[L, B], GIOBS ~func() ET.Either[L, BBS], AAS ~[]A, BBS ~[]B, E, L, A, B any](f func(int, A) GB) func(AAS) GBS { + return RA.TraverseWithIndex[AAS]( + Of[GBS, GIOBS, E, L, BBS], + Map[GBS, func(E) func() ET.Either[L, func(B) BBS], GIOBS, func() ET.Either[L, func(B) BBS], E, L, BBS, func(B) BBS], + Ap[GB, GBS, func(E) func() ET.Either[L, func(B) BBS], GIOB, GIOBS, func() ET.Either[L, func(B) BBS], E, L, B, BBS], + + f, + ) +} + // SequenceArray converts a homogeneous sequence of either into an either of sequence func SequenceArray[GA ~func(E) GIOA, GAS ~func(E) GIOAS, GIOA ~func() ET.Either[L, A], GIOAS ~func() ET.Either[L, AAS], AAS ~[]A, GAAS ~[]GA, E, L, A any](ma GAAS) GAS { return MonadTraverseArray[GA, GAS](ma, F.Identity[GA]) @@ -61,7 +72,7 @@ func MonadTraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.E ) } -// TraverseRecord transforms an array +// TraverseRecord transforms a record func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(A) GB) func(AAS) GBS { return RR.Traverse[AAS]( Of[GBS, GIOBS, C, E, BBS], @@ -72,6 +83,17 @@ func TraverseRecord[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either ) } +// TraverseRecordWithIndex transforms a record +func TraverseRecordWithIndex[GB ~func(C) GIOB, GBS ~func(C) GIOBS, GIOB ~func() ET.Either[E, B], GIOBS ~func() ET.Either[E, BBS], AAS ~map[K]A, BBS ~map[K]B, K comparable, C, E, A, B any](f func(K, A) GB) func(AAS) GBS { + return RR.TraverseWithIndex[AAS]( + Of[GBS, GIOBS, C, E, BBS], + Map[GBS, func(C) func() ET.Either[E, func(B) BBS], GIOBS, func() ET.Either[E, func(B) BBS], C, E, BBS, func(B) BBS], + Ap[GB, GBS, func(C) func() ET.Either[E, func(B) BBS], GIOB, GIOBS, func() ET.Either[E, func(B) BBS], C, E, B, BBS], + + f, + ) +} + // SequenceRecord converts a homogeneous sequence of either into an either of sequence func SequenceRecord[GA ~func(C) GIOA, GAS ~func(C) GIOAS, GIOA ~func() ET.Either[E, A], GIOAS ~func() ET.Either[E, AAS], AAS ~map[K]A, GAAS ~map[K]GA, K comparable, C, E, A any](tas GAAS) GAS { return MonadTraverseRecord[GA, GAS](tas, F.Identity[GA]) diff --git a/readerioeither/traverse.go b/readerioeither/traverse.go index 0ac12e4..cf4aacd 100644 --- a/readerioeither/traverse.go +++ b/readerioeither/traverse.go @@ -25,6 +25,11 @@ func TraverseArray[R, E, A, B any](f func(A) ReaderIOEither[R, E, B]) func([]A) return G.TraverseArray[ReaderIOEither[R, E, B], ReaderIOEither[R, E, []B], IOE.IOEither[E, B], IOE.IOEither[E, []B], []A](f) } +// TraverseArrayWithIndex transforms an array +func TraverseArrayWithIndex[R, E, A, B any](f func(int, A) ReaderIOEither[R, E, B]) func([]A) ReaderIOEither[R, E, []B] { + return G.TraverseArrayWithIndex[ReaderIOEither[R, E, B], ReaderIOEither[R, E, []B], IOE.IOEither[E, B], IOE.IOEither[E, []B], []A](f) +} + // SequenceArray converts a homogeneous sequence of Readers into a Reader of a sequence func SequenceArray[R, E, A any](ma []ReaderIOEither[R, E, A]) ReaderIOEither[R, E, []A] { return G.SequenceArray[ReaderIOEither[R, E, A], ReaderIOEither[R, E, []A]](ma) @@ -35,6 +40,11 @@ func TraverseRecord[R any, K comparable, E, A, B any](f func(A) ReaderIOEither[R return G.TraverseRecord[ReaderIOEither[R, E, B], ReaderIOEither[R, E, map[K]B], IOE.IOEither[E, B], IOE.IOEither[E, map[K]B], map[K]A](f) } +// TraverseRecordWithIndex transforms an array +func TraverseRecordWithIndex[R any, K comparable, E, A, B any](f func(K, A) ReaderIOEither[R, E, B]) func(map[K]A) ReaderIOEither[R, E, map[K]B] { + return G.TraverseRecordWithIndex[ReaderIOEither[R, E, B], ReaderIOEither[R, E, map[K]B], IOE.IOEither[E, B], IOE.IOEither[E, map[K]B], map[K]A](f) +} + // SequenceRecord converts a homogeneous sequence of Readers into a Reader of a sequence func SequenceRecord[R any, K comparable, E, A any](ma map[K]ReaderIOEither[R, E, A]) ReaderIOEither[R, E, map[K]A] { return G.SequenceRecord[ReaderIOEither[R, E, A], ReaderIOEither[R, E, map[K]A]](ma)