From 6ab6ff094bfd34dcc56c835aa1d93f574ab633bc Mon Sep 17 00:00:00 2001 From: "Dr. Carsten Leue" Date: Fri, 16 Feb 2024 15:46:12 +0100 Subject: [PATCH] fix: correct sequence order of TraverseArraySeq for IO Signed-off-by: Dr. Carsten Leue --- io/generic/ap.go | 9 +-- io/generic/traverse.go | 138 ++++++++++++++++++++++++++++++++++++++ io/sequence_test.go | 47 +++++++++++++ io/traverse.go | 42 ++++++++++++ ioeither/sequence_test.go | 48 +++++++++++++ 5 files changed, 277 insertions(+), 7 deletions(-) create mode 100644 io/sequence_test.go create mode 100644 ioeither/sequence_test.go diff --git a/io/generic/ap.go b/io/generic/ap.go index 2b5b39c..f1b509e 100644 --- a/io/generic/ap.go +++ b/io/generic/ap.go @@ -27,16 +27,11 @@ 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 MonadChain(mab, F.Bind1st(MonadMap[GA, GB], ma)) } // MonadApPar implements the applicative on two threads, the main thread executes mab and the actuall -// apply operation and the second thred computes ma. Communication between the threads happens via a channel +// apply operation and the second thread computes ma. Communication between the threads happens via a channel func MonadApPar[GA ~func() A, GB ~func() B, GAB ~func() func(A) B, A, B any](mab GAB, ma GA) GB { return MakeIO[GB](func() B { c := make(chan A) diff --git a/io/generic/traverse.go b/io/generic/traverse.go index 613c882..99c799b 100644 --- a/io/generic/traverse.go +++ b/io/generic/traverse.go @@ -32,6 +32,28 @@ func MonadTraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B ) } +func MonadTraverseArraySeq[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](tas AAS, f func(A) GB) GBS { + return RA.MonadTraverse( + Of[GBS, BBS], + Map[GBS, func() func(B) BBS, BBS, func(B) BBS], + ApSeq[GBS, func() func(B) BBS, GB], + + tas, + f, + ) +} + +func MonadTraverseArrayPar[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](tas AAS, f func(A) GB) GBS { + return RA.MonadTraverse( + Of[GBS, BBS], + Map[GBS, func() func(B) BBS, BBS, func(B) BBS], + ApPar[GBS, func() func(B) BBS, GB], + + tas, + f, + ) +} + func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS { return RA.Traverse[AAS]( Of[GBS, BBS], @@ -42,6 +64,26 @@ func TraverseArray[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any]( ) } +func TraverseArraySeq[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS { + return RA.Traverse[AAS]( + Of[GBS, BBS], + Map[GBS, func() func(B) BBS, BBS, func(B) BBS], + ApSeq[GBS, func() func(B) BBS, GB], + + f, + ) +} + +func TraverseArrayPar[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A, B any](f func(A) GB) func(AAS) GBS { + return RA.Traverse[AAS]( + Of[GBS, BBS], + Map[GBS, func() func(B) BBS, BBS, func(B) BBS], + ApPar[GBS, func() func(B) BBS, GB], + + f, + ) +} + 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], @@ -52,10 +94,38 @@ func TraverseArrayWithIndex[GB ~func() B, GBS ~func() BBS, AAS ~[]A, BBS ~[]B, A ) } +func TraverseArrayWithIndexSeq[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], + ApSeq[GBS, func() func(B) BBS, GB], + + f, + ) +} + +func TraverseArrayWithIndexPar[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], + ApPar[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]) } +func SequenceArraySeq[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS { + return MonadTraverseArraySeq[GA, GAS](tas, F.Identity[GA]) +} + +func SequenceArrayPar[GA ~func() A, GAS ~func() AAS, AAS ~[]A, GAAS ~[]GA, A any](tas GAAS) GAS { + return MonadTraverseArrayPar[GA, GAS](tas, F.Identity[GA]) +} + // MonadTraverseRecord transforms a record using an IO transform an IO of a record func MonadTraverseRecord[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS { return RR.MonadTraverse[MA]( @@ -89,3 +159,71 @@ func TraverseRecordWithIndex[GB ~func() B, GBS ~func() MB, MA ~map[K]A, MB ~map[ 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[GAS](tas, F.Identity[GA]) } + +// MonadTraverseRecordSeq transforms a record using an IO transform an IO of a record +func MonadTraverseRecordSeq[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS { + return RR.MonadTraverse[MA]( + Of[GBS, MB], + Map[GBS, func() func(B) MB, MB, func(B) MB], + ApSeq[GBS, func() func(B) MB, GB], + ma, f, + ) +} + +// TraverseRecordSeq transforms a record using an IO transform an IO of a record +func TraverseRecordSeq[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](f func(A) GB) func(MA) GBS { + return RR.Traverse[MA]( + Of[GBS, MB], + Map[GBS, func() func(B) MB, MB, func(B) MB], + ApSeq[GBS, func() func(B) MB, GB], + f, + ) +} + +// TraverseRecordWithIndexSeq transforms a record using an IO transform an IO of a record +func TraverseRecordWithIndexSeq[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], + ApSeq[GBS, func() func(B) MB, GB], + f, + ) +} + +func SequenceRecordSeq[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS { + return MonadTraverseRecordSeq[GAS](tas, F.Identity[GA]) +} + +// MonadTraverseRecordPar transforms a record using an IO transform an IO of a record +func MonadTraverseRecordPar[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](ma MA, f func(A) GB) GBS { + return RR.MonadTraverse[MA]( + Of[GBS, MB], + Map[GBS, func() func(B) MB, MB, func(B) MB], + ApPar[GBS, func() func(B) MB, GB], + ma, f, + ) +} + +// TraverseRecordPar transforms a record using an IO transform an IO of a record +func TraverseRecordPar[GBS ~func() MB, MA ~map[K]A, GB ~func() B, MB ~map[K]B, K comparable, A, B any](f func(A) GB) func(MA) GBS { + return RR.Traverse[MA]( + Of[GBS, MB], + Map[GBS, func() func(B) MB, MB, func(B) MB], + ApPar[GBS, func() func(B) MB, GB], + f, + ) +} + +// TraverseRecordWithIndexPar transforms a record using an IO transform an IO of a record +func TraverseRecordWithIndexPar[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], + ApPar[GBS, func() func(B) MB, GB], + f, + ) +} + +func SequenceRecordPar[GA ~func() A, GAS ~func() AAS, AAS ~map[K]A, GAAS ~map[K]GA, K comparable, A any](tas GAAS) GAS { + return MonadTraverseRecordPar[GAS](tas, F.Identity[GA]) +} diff --git a/io/sequence_test.go b/io/sequence_test.go new file mode 100644 index 0000000..9f5133a --- /dev/null +++ b/io/sequence_test.go @@ -0,0 +1,47 @@ +// 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 ( + A "github.com/IBM/fp-go/array" + F "github.com/IBM/fp-go/function" + "github.com/stretchr/testify/assert" + + "testing" +) + +func TestMapSeq(t *testing.T) { + var results []string + + handler := func(value string) IO[string] { + return func() string { + results = append(results, value) + return value + } + } + + src := A.From("a", "b", "c") + + res := F.Pipe2( + src, + TraverseArraySeq(handler), + Map(func(data []string) bool { + return assert.Equal(t, data, results) + }), + ) + + assert.True(t, res()) +} diff --git a/io/traverse.go b/io/traverse.go index 6fdf192..1213051 100644 --- a/io/traverse.go +++ b/io/traverse.go @@ -60,3 +60,45 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) IO[B]) func(ma 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) } + +func MonadTraverseArraySeq[A, B any](tas []A, f func(A) IO[B]) IO[[]B] { + return G.MonadTraverseArraySeq[IO[B], IO[[]B]](tas, f) +} + +// TraverseArraySeq applies a function returning an [IO] to all elements in an array and the +// transforms this into an [IO] of that array +func TraverseArraySeq[A, B any](f func(A) IO[B]) func([]A) IO[[]B] { + return G.TraverseArraySeq[IO[B], IO[[]B], []A](f) +} + +// TraverseArrayWithIndexSeq applies a function returning an [IO] to all elements in an array and the +// transforms this into an [IO] of that array +func TraverseArrayWithIndexSeq[A, B any](f func(int, A) IO[B]) func([]A) IO[[]B] { + return G.TraverseArrayWithIndexSeq[IO[B], IO[[]B], []A](f) +} + +// SequenceArraySeq converts an array of [IO] to an [IO] of an array +func SequenceArraySeq[A any](tas []IO[A]) IO[[]A] { + return G.SequenceArraySeq[IO[A], IO[[]A]](tas) +} + +func MonadTraverseRecordSeq[K comparable, A, B any](tas map[K]A, f func(A) IO[B]) IO[map[K]B] { + return G.MonadTraverseRecordSeq[IO[map[K]B]](tas, 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 TraverseRecordSeq[K comparable, A, B any](f func(A) IO[B]) func(map[K]A) IO[map[K]B] { + return G.TraverseRecordSeq[IO[map[K]B], map[K]A, IO[B]](f) +} + +// TraverseRecordWithIndexSeq applies a function returning an [IO] to all elements in a record and the +// transforms this into an [IO] of that record +func TraverseRecordWithIndeSeq[K comparable, A, B any](f func(K, A) IO[B]) func(map[K]A) IO[map[K]B] { + return G.TraverseRecordWithIndexSeq[IO[B], IO[map[K]B], map[K]A](f) +} + +// SequenceRecordSeq converts a record of [IO] to an [IO] of a record +func SequenceRecordSeq[K comparable, A any](tas map[K]IO[A]) IO[map[K]A] { + return G.SequenceRecordSeq[IO[A], IO[map[K]A]](tas) +} diff --git a/ioeither/sequence_test.go b/ioeither/sequence_test.go new file mode 100644 index 0000000..22fde42 --- /dev/null +++ b/ioeither/sequence_test.go @@ -0,0 +1,48 @@ +// 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 ( + A "github.com/IBM/fp-go/array" + E "github.com/IBM/fp-go/either" + F "github.com/IBM/fp-go/function" + "github.com/stretchr/testify/assert" + + "testing" +) + +func TestMapSeq(t *testing.T) { + var results []string + + handler := func(value string) IOEither[error, string] { + return func() E.Either[error, string] { + results = append(results, value) + return E.Of[error](value) + } + } + + src := A.From("a", "b", "c") + + res := F.Pipe2( + src, + TraverseArraySeq(handler), + Map[error](func(data []string) bool { + return assert.Equal(t, data, results) + }), + ) + + assert.Equal(t, E.Of[error](true), res()) +}