Merge pull request #48 from IBM/cleue-some-benchmarking

fix: add some benchmarks

iterator/stateless/benchmark_test.go

@@ -0,0 +1,65 @@
+// 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 stateless
+
+import (
+	"testing"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+func BenchmarkMulti(b *testing.B) {
+	// run the Fib function b.N times
+	for n := 0; n < b.N; n++ {
+		single()
+	}
+}
+
+func single() int64 {
+
+	length := 10000
+	nums := make([]int, 0, length)
+	for i := 0; i < length; i++ {
+		nums = append(nums, i+1)
+	}
+
+	return F.Pipe6(
+		nums,
+		FromArray[int],
+		Filter(func(n int) bool {
+			return n%2 == 0
+		}),
+		Map(func(t int) int64 {
+			return int64(t)
+		}),
+		Filter(func(t int64) bool {
+			n := t
+			for n/10 != 0 {
+				if n%10 == 4 {
+					return false
+				}
+				n = n / 10
+			}
+			return true
+		}),
+		Map(func(t int64) int {
+			return int(t)
+		}),
+		Reduce(func(n int64, r int) int64 {
+			return n + int64(r)
+		}, int64(0)),
+	)
+}

iterator/stateless/generic/iterator.go

@@ -82,6 +82,7 @@ func Map[GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU,
 			m,
 		)
 	}
+
 	m = O.Map(T.Map2(recurse, f))
 
 	return recurse

samples/http/http_test.go

@@ -74,9 +74,7 @@ func TestMultipleHttpRequests(t *testing.T) {
 	assert.Equal(t, E.Of[error](count), result())
 }
 
-// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
-// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
-func TestHeterogeneousHttpRequests(t *testing.T) {
+func heterogeneousHttpRequests() R.ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
 	// prepare the http client
 	client := H.MakeClient(HTTP.DefaultClient)
 	// readSinglePost sends a GET request and parses the response as [PostItem]
@@ -84,7 +82,7 @@ func TestHeterogeneousHttpRequests(t *testing.T) {
 	// readSingleCatFact sends a GET request and parses the response as [CatFact]
 	readSingleCatFact := H.ReadJson[CatFact](client)
 
-	data := F.Pipe3(
+	return F.Pipe3(
 		T.MakeTuple2("https://jsonplaceholder.typicode.com/posts/1", "https://catfact.ninja/fact"),
 		T.Map2(H.MakeGetRequest, H.MakeGetRequest),
 		R.TraverseTuple2(
@@ -94,7 +92,21 @@ func TestHeterogeneousHttpRequests(t *testing.T) {
 		R.ChainFirstIOK(IO.Logf[T.Tuple2[PostItem, CatFact]]("Log Result: %v")),
 	)
 
+}
+
+// TestHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func TestHeterogeneousHttpRequests(t *testing.T) {
+	data := heterogeneousHttpRequests()
+
 	result := data(context.Background())
 
 	fmt.Println(result())
 }
+
+// BenchmarkHeterogeneousHttpRequests shows how to execute multiple HTTP requests in parallel when
+// the response structure of these requests is different. We use [R.TraverseTuple2] to account for the different types
+func BenchmarkHeterogeneousHttpRequests(b *testing.B) {
+
+	heterogeneousHttpRequests()(context.Background())
+}