Merge pull request #31 from IBM/cleue-add-cache

fix: implement simple cache for pure functions

.github/workflows/build.yml

@@ -17,22 +17,25 @@ on:
 env:
   # Currently no way to detect automatically
   DEFAULT_BRANCH: main
-  GO_VERSION: 1.20.5 # renovate: datasource=golang-version depName=golang
+  GO_VERSION: 1.20.6 # renovate: datasource=golang-version depName=golang
   NODE_VERSION: 18
   DRY_RUN: true
 
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: [ '1.20.x', '1.21.x' ]
     steps:
       # full checkout for semantic-release
       - uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3.5.3
         with:
           fetch-depth: 0
-      - name: Set up go ${{env.GO_VERSION}}
+      - name: Set up go ${{ matrix.go-version }}
         uses: actions/setup-go@v4
         with:
-          go-version: ${{env.GO_VERSION}}
+          go-version: ${{ matrix.go-version }}
       -
         name: Tests
         run: |

README.md

@@ -73,7 +73,7 @@ This library aims to provide a set of data types and functions that make it easy
 
 The library itself also comprises many small functions, but it's admittedly harder to maintain than code that uses it. However this asymmetry is intended because it offloads complexity from users into a central component.
 
-## Comparation to Idiomatic Go
+## Comparison to Idiomatic Go
 
 In this section we discuss how the functional APIs differ from idiomatic go function signatures and how to convert back and forth.
 
@@ -181,7 +181,7 @@ The `Map` operation for `ReaderIOEither` is defined as:
 func Map[R, E, A, B any](f func(A) B) func(fa ReaderIOEither[R, E, A]) ReaderIOEither[R, E, B]
 ```
 
-and in fact the equivalent operations for all other mondas follow the same pattern, we could try to introduce a new type for `ReaderIOEither` (without a parameter) as a HKT, e.g. like so (made-up syntax, does not work in go):
+and in fact the equivalent operations for all other monads follow the same pattern, we could try to introduce a new type for `ReaderIOEither` (without a parameter) as a HKT, e.g. like so (made-up syntax, does not work in go):
 
 ```go
 func Map[HKT, R, E, A, B any](f func(A) B) func(HKT[R, E, A]) HKT[R, E, B]

array/array.go

@@ -108,10 +108,16 @@ func MonadFilterMap[A, B any](fa []A, f func(a A) O.Option[B]) []B {
 	return G.MonadFilterMap[[]A, []B](fa, f)
 }
 
+// FilterChain maps an array with an iterating function that returns an [O.Option] and it keeps only the Some values discarding the Nones.
 func FilterMap[A, B any](f func(a A) O.Option[B]) func([]A) []B {
 	return G.FilterMap[[]A, []B](f)
 }
 
+// FilterChain maps an array with an iterating function that returns an [O.Option] of an array. It keeps only the Some values discarding the Nones and then flattens the result.
+func FilterChain[A, B any](f func(A) O.Option[[]B]) func([]A) []B {
+	return G.FilterChain[[]A](f)
+}
+
 func FilterMapRef[A, B any](pred func(a *A) bool, f func(a *A) B) func([]A) []B {
 	return func(fa []A) []B {
 		return filterMapRef(fa, pred, f)
@@ -237,7 +243,7 @@ func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
 }
 
 func Flatten[A any](mma [][]A) []A {
-	return MonadChain(mma, F.Identity[[]A])
+	return G.Flatten(mma)
 }
 
 func Slice[A any](low, high int) func(as []A) []A {
@@ -288,3 +294,17 @@ func SliceRight[A any](start int) func([]A) []A {
 func Copy[A any](b []A) []A {
 	return G.Copy(b)
 }
+
+// FoldMap maps and folds an array. Map the Array passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[A, B any](m M.Monoid[B]) func(func(A) B) func([]A) B {
+	return G.FoldMap[[]A](m)
+}
+
+// Fold folds the array using the provided Monoid.
+func Fold[A any](m M.Monoid[A]) func([]A) A {
+	return G.Fold[[]A](m)
+}
+
+func Push[A any](a A) func([]A) []A {
+	return G.Push[[]A](a)
+}

array/array_test.go

@@ -16,6 +16,7 @@
 package array
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -142,3 +143,52 @@ func TestPartition(t *testing.T) {
 	assert.Equal(t, T.MakeTuple2(Empty[int](), Empty[int]()), Partition(pred)(Empty[int]()))
 	assert.Equal(t, T.MakeTuple2(From(1), From(3)), Partition(pred)(From(1, 3)))
 }
+
+func TestFilterChain(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[[]string] {
+		if i%2 != 0 {
+			return O.Of(From(fmt.Sprintf("a%d", i), fmt.Sprintf("b%d", i)))
+		}
+		return O.None[[]string]()
+	}
+
+	res := FilterChain(f)(src)
+
+	assert.Equal(t, From("a1", "b1", "a3", "b3"), res)
+}
+
+func TestFilterMap(t *testing.T) {
+	src := From(1, 2, 3)
+
+	f := func(i int) O.Option[string] {
+		if i%2 != 0 {
+			return O.Of(fmt.Sprintf("a%d", i))
+		}
+		return O.None[string]()
+	}
+
+	res := FilterMap(f)(src)
+
+	assert.Equal(t, From("a1", "a3"), res)
+}
+
+func TestFoldMap(t *testing.T) {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	assert.Equal(t, "ABC", fold(src))
+}
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}

array/examples_basic_test.go

@@ -0,0 +1,59 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Example_basic adapts examples from [https://github.com/inato/fp-ts-cheatsheet#basic-manipulation]
+func Example_basic() {
+
+	someArray := From(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) // []int
+
+	isEven := func(num int) bool {
+		return num%2 == 0
+	}
+
+	square := func(num int) int {
+		return num * num
+	}
+
+	// filter and map
+	result := F.Pipe2(
+		someArray,
+		Filter(isEven),
+		Map(square),
+	) // [0 4 16 36 64]
+
+	// or in one go with filterMap
+	resultFilterMap := F.Pipe1(
+		someArray,
+		FilterMap(
+			F.Flow2(O.FromPredicate(isEven), O.Map(square)),
+		),
+	)
+
+	fmt.Println(result)
+	fmt.Println(resultFilterMap)
+
+	// Output:
+	// [0 4 16 36 64]
+	// [0 4 16 36 64]
+}

array/examples_sort_test.go

@@ -0,0 +1,92 @@
+// 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 array
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/number/integer"
+	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/ord"
+	S "github.com/IBM/fp-go/string"
+)
+
+type user struct {
+	name string
+	age  O.Option[int]
+}
+
+func (user user) GetName() string {
+	return user.name
+}
+
+func (user user) GetAge() O.Option[int] {
+	return user.age
+}
+
+// Example_sort adapts examples from [https://github.com/inato/fp-ts-cheatsheet#sort-elements-with-ord]
+func Example_sort() {
+
+	strings := From("zyx", "abc", "klm")
+
+	sortedStrings := F.Pipe1(
+		strings,
+		Sort(S.Ord),
+	) // => ['abc', 'klm', 'zyx']
+
+	// reverse sort
+	reverseSortedStrings := F.Pipe1(
+		strings,
+		Sort(ord.Reverse(S.Ord)),
+	) // => ['zyx', 'klm', 'abc']
+
+	// sort Option
+	optionalNumbers := From(O.Some(1337), O.None[int](), O.Some(42))
+
+	sortedNums := F.Pipe1(
+		optionalNumbers,
+		Sort(O.Ord(I.Ord)),
+	)
+
+	// complex object with different rules
+	byName := F.Pipe1(
+		S.Ord,
+		ord.Contramap(user.GetName),
+	) // ord.Ord[user]
+
+	byAge := F.Pipe1(
+		O.Ord(I.Ord),
+		ord.Contramap(user.GetAge),
+	) // ord.Ord[user]
+
+	sortedUsers := F.Pipe1(
+		From(user{name: "a", age: O.Of(30)}, user{name: "d", age: O.Of(10)}, user{name: "c"}, user{name: "b", age: O.Of(10)}),
+		SortBy(From(byAge, byName)),
+	)
+
+	fmt.Println(sortedStrings)
+	fmt.Println(reverseSortedStrings)
+	fmt.Println(sortedNums)
+	fmt.Println(sortedUsers)
+
+	// Output:
+	// [abc klm zyx]
+	// [zyx klm abc]
+	// [None[int] Some[int](42) Some[int](1337)]
+	// [{c {false 0}} {b {true 10}} {d {true 10}} {a {true 30}}]
+
+}

array/generic/array.go

@@ -18,6 +18,7 @@ package generic
 import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/array"
+	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
 	"github.com/IBM/fp-go/tuple"
 )
@@ -27,6 +28,14 @@ func Of[GA ~[]A, A any](value A) GA {
 	return GA{value}
 }
 
+func Reduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
+	return array.Reduce(fa, f, initial)
+}
+
+func ReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
+	return array.ReduceWithIndex(fa, f, initial)
+}
+
 // From constructs an array from a set of variadic arguments
 func From[GA ~[]A, A any](data ...A) GA {
 	return data
@@ -104,6 +113,10 @@ func MonadMap[GA ~[]A, GB ~[]B, A, B any](as GA, f func(a A) B) GB {
 	return array.MonadMap[GA, GB](as, f)
 }
 
+func Map[GA ~[]A, GB ~[]B, A, B any](f func(a A) B) func(GA) GB {
+	return F.Bind2nd(MonadMap[GA, GB, A, B], f)
+}
+
 func Size[GA ~[]A, A any](as GA) int {
 	return len(as)
 }
@@ -118,6 +131,17 @@ func MonadFilterMap[GA ~[]A, GB ~[]B, A, B any](fa GA, f func(a A) O.Option[B])
 	return filterMap[GA, GB](fa, f)
 }
 
+func FilterChain[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[GB]) func(GA) GB {
+	return F.Flow2(
+		FilterMap[GA, []GB](f),
+		Flatten[[]GB],
+	)
+}
+
+func Flatten[GAA ~[]GA, GA ~[]A, A any](mma GAA) GA {
+	return MonadChain(mma, F.Identity[GA])
+}
+
 func FilterMap[GA ~[]A, GB ~[]B, A, B any](f func(a A) O.Option[B]) func(GA) GB {
 	return F.Bind2nd(MonadFilterMap[GA, GB, A, B], f)
 }
@@ -198,3 +222,23 @@ func Copy[AS ~[]A, A any](b AS) AS {
 	copy(buf, b)
 	return buf
 }
+
+func FoldMap[AS ~[]A, A, B any](m M.Monoid[B]) func(func(A) B) func(AS) B {
+	return func(f func(A) B) func(AS) B {
+		return func(as AS) B {
+			return array.Reduce(as, func(cur B, a A) B {
+				return m.Concat(cur, f(a))
+			}, m.Empty())
+		}
+	}
+}
+
+func Fold[AS ~[]A, A any](m M.Monoid[A]) func(AS) A {
+	return func(as AS) A {
+		return array.Reduce(as, m.Concat, m.Empty())
+	}
+}
+
+func Push[GA ~[]A, A any](a A) func(GA) GA {
+	return F.Bind2nd(array.Push[GA, A], a)
+}

array/generic/sort.go

@@ -18,11 +18,17 @@ package generic
 import (
 	"sort"
 
+	F "github.com/IBM/fp-go/function"
 	O "github.com/IBM/fp-go/ord"
 )
 
 // Sort implements a stable sort on the array given the provided ordering
 func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
+	return SortByKey[GA](ord, F.Identity[T])
+}
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[GA ~[]T, K, T any](ord O.Ord[K], f func(T) K) func(ma GA) GA {
 
 	return func(ma GA) GA {
 		// nothing to sort
@@ -34,8 +40,17 @@ func Sort[GA ~[]T, T any](ord O.Ord[T]) func(ma GA) GA {
 		cpy := make(GA, l)
 		copy(cpy, ma)
 		sort.Slice(cpy, func(i, j int) bool {
-			return ord.Compare(cpy[i], cpy[j]) < 0
+			return ord.Compare(f(cpy[i]), f(cpy[j])) < 0
 		})
 		return cpy
 	}
 }
+
+// SortBy implements a stable sort on the array given the provided ordering
+func SortBy[GA ~[]T, GO ~[]O.Ord[T], T any](ord GO) func(ma GA) GA {
+	return F.Pipe2(
+		ord,
+		Fold[GO](O.Monoid[T]()),
+		Sort[GA, T],
+	)
+}

array/sort.go

@@ -24,3 +24,13 @@ import (
 func Sort[T any](ord O.Ord[T]) func(ma []T) []T {
 	return G.Sort[[]T](ord)
 }
+
+// SortByKey implements a stable sort on the array given the provided ordering on an extracted key
+func SortByKey[K, T any](ord O.Ord[K], f func(T) K) func(ma []T) []T {
+	return G.SortByKey[[]T](ord, f)
+}
+
+// SortBy implements a stable sort on the array given the provided ordering
+func SortBy[T any](ord []O.Ord[T]) func(ma []T) []T {
+	return G.SortBy[[]T, []O.Ord[T]](ord)
+}

cli/apply.go

@@ -388,7 +388,7 @@ func generateApplyHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/bind.go

@@ -266,7 +266,7 @@ func generateBindHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n", pkg)
 

cli/either.go

@@ -150,7 +150,7 @@ func generateEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/header.go

@@ -27,5 +27,5 @@ func writePackage(f *os.File, pkg string) {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 }

cli/identity.go

@@ -62,7 +62,7 @@ func generateIdentityHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/io.go

@@ -81,7 +81,7 @@ func generateIOHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/ioeither.go

@@ -217,7 +217,7 @@ func generateIOEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/iooption.go

@@ -81,7 +81,7 @@ func generateIOOptionHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/option.go

@@ -148,7 +148,7 @@ func generateOptionHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/pipe.go

@@ -337,7 +337,7 @@ func generatePipeHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n", pkg)
 

cli/reader.go

@@ -12,6 +12,7 @@
 // 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 cli
 
 import (
@@ -117,7 +118,7 @@ func generateReaderHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/readerioeither.go

@@ -169,7 +169,7 @@ func generateReaderIOEitherHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 

cli/tuple.go

@@ -20,6 +20,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	C "github.com/urfave/cli/v2"
@@ -36,8 +37,51 @@ func writeTupleType(f *os.File, symbol string, i int) {
 	fmt.Fprintf(f, "]")
 }
 
+func makeTupleType(name string) func(i int) string {
+	return func(i int) string {
+		var buf strings.Builder
+		buf.WriteString(fmt.Sprintf("Tuple%d[", i))
+		for j := 0; j < i; j++ {
+			if j > 0 {
+				buf.WriteString(", ")
+			}
+			buf.WriteString(fmt.Sprintf("%s%d", name, j+1))
+		}
+		buf.WriteString("]")
+
+		return buf.String()
+	}
+}
+
+func generatePush(f *os.File, i int) {
+	tuple1 := makeTupleType("T")(i)
+	tuple2 := makeTupleType("T")(i + 1)
+	// Create the replicate version
+	fmt.Fprintf(f, "\n// Push%d creates a [Tuple%d] from a [Tuple%d] by appending a constant value\n", i, i+1, i)
+	fmt.Fprintf(f, "func Push%d[", i)
+	// function prototypes
+	for j := 0; j <= i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "T%d", j+1)
+	}
+	fmt.Fprintf(f, " any](value T%d) func(%s) %s {\n", i+1, tuple1, tuple2)
+	fmt.Fprintf(f, "  return func(t %s) %s {\n", tuple1, tuple2)
+	fmt.Fprintf(f, "    return MakeTuple%d(", i+1)
+	for j := 0; j < i; j++ {
+		if j > 0 {
+			fmt.Fprintf(f, ", ")
+		}
+		fmt.Fprintf(f, "t.F%d", j+1)
+	}
+	fmt.Fprintf(f, ", value)\n")
+	fmt.Fprintf(f, "  }\n")
+	fmt.Fprintf(f, "}\n")
+}
+
 func generateReplicate(f *os.File, i int) {
-	// Create the optionize version
+	// Create the replicate version
 	fmt.Fprintf(f, "\n// Replicate%d creates a [Tuple%d] with all fields set to the input value `t`\n", i, i)
 	fmt.Fprintf(f, "func Replicate%d[T any](t T) Tuple%d[", i, i)
 	for j := 1; j <= i; j++ {
@@ -355,7 +399,7 @@ func generateTupleHelpers(filename string, count int) error {
 	// some header
 	fmt.Fprintln(f, "// Code generated by go generate; DO NOT EDIT.")
 	fmt.Fprintln(f, "// This file was generated by robots at")
-	fmt.Fprintf(f, "// %s\n", time.Now())
+	fmt.Fprintf(f, "// %s\n\n", time.Now())
 
 	fmt.Fprintf(f, "package %s\n\n", pkg)
 
@@ -398,6 +442,10 @@ import (
 		generateToArray(f, i)
 		// generate fromArray
 		generateFromArray(f, i)
+		// generate push
+		if i < count {
+			generatePush(f, i)
+		}
 	}
 
 	return nil

context/readerioeither/gen.go

@@ -1,23 +1,8 @@
-// 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 readerioeither
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
+// 2023-08-17 22:58:56.457404 +0200 CEST m=+0.024265101
 
 import (
 	"context"

context/readerioeither/generic/gen.go

@@ -1,23 +1,8 @@
-// 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 generic
 
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:20.012425 +0200 CEST m=+0.019517901
+// 2023-08-17 22:58:56.457404 +0200 CEST m=+0.024265101
 
 import (
 	"context"

either/doc.go

@@ -13,6 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package option defines the [Either] datastructure and its monadic operations
 package either
 
 //go:generate go run .. either --count 10 --filename gen.go

either/either.go

@@ -146,8 +146,8 @@ func FromOption[E, A any](onNone func() E) func(O.Option[A]) Either[E, A] {
 	return O.Fold(F.Nullary2(onNone, Left[A, E]), Right[E, A])
 }
 
-func ToOption[E, A any]() func(Either[E, A]) O.Option[A] {
-	return Fold(F.Ignore1of1[E](O.None[A]), O.Some[A])
+func ToOption[E, A any](ma Either[E, A]) O.Option[A] {
+	return MonadFold(ma, F.Ignore1of1[E](O.None[A]), O.Some[A])
 }
 
 func FromError[A any](f func(a A) error) func(A) Either[error, A] {
@@ -182,7 +182,7 @@ func FromPredicate[E, A any](pred func(A) bool, onFalse func(A) E) func(A) Eithe
 	}
 }
 
-func FromNillable[E, A any](e E) func(*A) Either[E, *A] {
+func FromNillable[A, E any](e E) func(*A) Either[E, *A] {
 	return FromPredicate(F.IsNonNil[A], F.Constant1[*A](e))
 }
 

either/examples_create_test.go

@@ -0,0 +1,58 @@
+// 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 either
+
+import (
+	"fmt"
+
+	"github.com/IBM/fp-go/errors"
+)
+
+func ExampleEither_creation() {
+	// Build an Either
+	leftValue := Left[string](fmt.Errorf("some error"))
+	rightValue := Right[error]("value")
+
+	// Build from a value
+	fromNillable := FromNillable[string](fmt.Errorf("value was nil"))
+	leftFromNil := fromNillable(nil)
+	value := "value"
+	rightFromPointer := fromNillable(&value)
+
+	// some predicate
+	isEven := func(num int) bool {
+		return num%2 == 0
+	}
+	fromEven := FromPredicate(isEven, errors.OnSome[int]("%d is an odd number"))
+	leftFromPred := fromEven(3)
+	rightFromPred := fromEven(4)
+
+	fmt.Println(leftValue)
+	fmt.Println(rightValue)
+	fmt.Println(leftFromNil)
+	fmt.Println(IsRight(rightFromPointer))
+	fmt.Println(leftFromPred)
+	fmt.Println(rightFromPred)
+
+	// Output:
+	// Left[*errors.errorString, string](some error)
+	// Right[<nil>, string](value)
+	// Left[*errors.errorString, *string](value was nil)
+	// true
+	// Left[*errors.errorString, int](3 is an odd number)
+	// Right[<nil>, int](4)
+
+}

either/examples_extract_test.go

@@ -0,0 +1,64 @@
+// 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 either
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+)
+
+func ExampleEither_extraction() {
+	leftValue := Left[int](fmt.Errorf("Division by Zero!"))
+	rightValue := Right[error](10)
+
+	// Convert Either[E, A] to A with a default value
+	leftWithDefault := GetOrElse(F.Constant1[error](0))(leftValue)   // 0
+	rightWithDefault := GetOrElse(F.Constant1[error](0))(rightValue) // 10
+
+	// Apply a different function on Left(...)/Right(...)
+	doubleOrZero := Fold(F.Constant1[error](0), N.Mul(2)) // func(Either[error, int]) int
+	doubleFromLeft := doubleOrZero(leftValue)             // 0
+	doubleFromRight := doubleOrZero(rightValue)           // 20
+
+	// Pro-tip: Fold is short for the following:
+	doubleOrZeroBis := F.Flow2(
+		Map[error](N.Mul(2)),
+		GetOrElse(F.Constant1[error](0)),
+	)
+	doubleFromLeftBis := doubleOrZeroBis(leftValue)   // 0
+	doubleFromRightBis := doubleOrZeroBis(rightValue) // 20
+
+	fmt.Println(leftValue)
+	fmt.Println(rightValue)
+	fmt.Println(leftWithDefault)
+	fmt.Println(rightWithDefault)
+	fmt.Println(doubleFromLeft)
+	fmt.Println(doubleFromRight)
+	fmt.Println(doubleFromLeftBis)
+	fmt.Println(doubleFromRightBis)
+
+	// Output:
+	// Left[*errors.errorString, int](Division by Zero!)
+	// Right[<nil>, int](10)
+	// 0
+	// 10
+	// 0
+	// 20
+	// 0
+	// 20
+}

either/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:23.165015 +0200 CEST m=+0.038998801
+// 2023-08-17 22:58:57.9925506 +0200 CEST m=+0.033401101
+
 package either
 
 import (

endomorphism/monoid.go

@@ -21,16 +21,12 @@ import (
 	S "github.com/IBM/fp-go/semigroup"
 )
 
-func concat[A any](first, second func(A) A) func(A) A {
-	return F.Flow2(first, second)
-}
-
 // Semigroup for the Endomorphism where the `concat` operation is the usual function composition.
 func Semigroup[A any]() S.Semigroup[func(A) A] {
-	return S.MakeSemigroup(concat[A])
+	return S.MakeSemigroup(F.Flow2[func(A) A, func(A) A])
 }
 
 // Monoid for the Endomorphism where the `concat` operation is the usual function composition.
 func Monoid[A any]() M.Monoid[func(A) A] {
-	return M.MakeMonoid(concat[A], F.Identity[A])
+	return M.MakeMonoid(F.Flow2[func(A) A, func(A) A], F.Identity[A])
 }

errors/messages.go

@@ -28,6 +28,22 @@ func OnNone(msg string, args ...any) func() error {
 	}
 }
 
+// OnSome generates a unary function that produces a formatted error
+func OnSome[T any](msg string, args ...any) func(T) error {
+	l := len(args)
+	if l == 0 {
+		return func(value T) error {
+			return fmt.Errorf(msg, value)
+		}
+	}
+	return func(value T) error {
+		data := make([]any, l)
+		copy(data[1:], args)
+		data[0] = value
+		return fmt.Errorf(msg, data...)
+	}
+}
+
 // OnError generates a unary function that produces a formatted error. The argument
 // to that function is the root cause of the error and the message will be augmented with
 // a format string containing %w

function/binds.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:40.161663 +0200 CEST m=+0.009458101
+// 2023-08-17 22:59:01.9404821 +0200 CEST m=+0.161366801
+
 package function
 
 // Combinations for a total of 1 arguments

function/cache.go

@@ -0,0 +1,30 @@
+// 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 function
+
+import (
+	G "github.com/IBM/fp-go/function/generic"
+)
+
+// Cache converts a unary function into a unary function that caches the value depending on the parameter
+func Cache[K comparable, T any](f func(K) T) func(K) T {
+	return G.Cache(f)
+}
+
+// ContramapCache converts a unary function into a unary function that caches the value depending on the parameter
+func ContramapCache[A any, K comparable, T any](kf func(A) K) func(func(A) T) func(A) T {
+	return G.ContramapCache[func(A) T](kf)
+}

function/cache_test.go

@@ -0,0 +1,50 @@
+// 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 function
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCache(t *testing.T) {
+	var count int
+
+	withSideEffect := func(n int) int {
+		count++
+		return n
+	}
+
+	cached := Cache(withSideEffect)
+
+	assert.Equal(t, 0, count)
+
+	assert.Equal(t, 10, cached(10))
+	assert.Equal(t, 1, count)
+
+	assert.Equal(t, 10, cached(10))
+	assert.Equal(t, 1, count)
+
+	assert.Equal(t, 20, cached(20))
+	assert.Equal(t, 2, count)
+
+	assert.Equal(t, 20, cached(20))
+	assert.Equal(t, 2, count)
+
+	assert.Equal(t, 10, cached(10))
+	assert.Equal(t, 2, count)
+}

function/doc.go

@@ -13,6 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package function implements function composition primitives, most prominently [Pipe2] and [Flow2]
 package function
 
 //go:generate go run .. pipe --count 20 --filename gen.go

function/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:27.8029852 +0200 CEST m=+0.051432001
+// 2023-08-17 22:58:59.8663985 +0200 CEST m=+0.103744101
+
 package function
 
 // Pipe0 takes an initial value t0 and successively applies 0 functions where the input of a function is the return value of the previous function

function/generic/cache.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 generic
+
+import (
+	"sync"
+
+	L "github.com/IBM/fp-go/internal/lazy"
+)
+
+// Cache converts a unary function into a unary function that caches the value depending on the parameter
+func Cache[F ~func(K) T, K comparable, T any](f F) F {
+	return ContramapCache[F](func(k K) K { return k })(f)
+}
+
+// ContramapCache converts a unary function into a unary function that caches the value depending on the parameter
+func ContramapCache[F ~func(A) T, KF func(A) K, A any, K comparable, T any](kf KF) func(F) F {
+	return CacheCallback[F](kf, getOrCreate[K, T]())
+}
+
+// getOrCreate is a naive implementation of a cache, without bounds
+func getOrCreate[K comparable, T any]() func(K, func() func() T) func() T {
+	cache := make(map[K]func() T)
+	var l sync.Mutex
+
+	return func(k K, cb func() func() T) func() T {
+		// only lock to access a lazy accessor to the value
+		l.Lock()
+		existing, ok := cache[k]
+		if !ok {
+			existing = cb()
+			cache[k] = existing
+		}
+		l.Unlock()
+		// compute the value outside of the lock
+		return existing
+	}
+}
+
+// CacheCallback converts a unary function into a unary function that caches the value depending on the parameter
+func CacheCallback[F ~func(A) T, KF func(A) K, C ~func(K, func() func() T) func() T, A any, K comparable, T any](kf KF, getOrCreate C) func(F) F {
+	return func(f F) F {
+		return func(a A) T {
+			// cache entry
+			return getOrCreate(kf(a), func() func() T {
+				return L.Memoize[func() T](func() T {
+					return f(a)
+				})
+			})()
+		}
+	}
+}

function/pipe_test.go

@@ -0,0 +1,62 @@
+// 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 function
+
+import (
+	"fmt"
+)
+
+func addSthg(value int) int {
+	return value + 1
+}
+
+func doSthgElse(value int) int {
+	return value * 2
+}
+
+func doFinalSthg(value int) string {
+	return fmt.Sprintf("final value: %d", value)
+}
+
+func Example() {
+	// start point
+	value := 1
+	// imperative style
+	value1 := addSthg(value)                    // 2
+	value2 := doSthgElse(value1)                // 4
+	finalValueImperative := doFinalSthg(value2) // "final value: 4"
+
+	// the same but inline
+	finalValueInline := doFinalSthg(doSthgElse(addSthg(value)))
+
+	// with pipe
+	finalValuePipe := Pipe3(value, addSthg, doSthgElse, doFinalSthg)
+
+	// with flow
+	transform := Flow3(addSthg, doSthgElse, doFinalSthg)
+	finalValueFlow := transform(value)
+
+	fmt.Println(finalValueImperative)
+	fmt.Println(finalValueInline)
+	fmt.Println(finalValuePipe)
+	fmt.Println(finalValueFlow)
+
+	// Output:
+	// final value: 4
+	// final value: 4
+	// final value: 4
+	// final value: 4
+}

identity/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:46.7920356 +0200 CEST m=+0.045177201
+// 2023-08-17 22:59:06.2987136 +0200 CEST m=+0.049156901
+
 package identity
 
 import (

internal/apply/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:49.4210571 +0200 CEST m=+0.040316501
+// 2023-08-17 22:59:08.1313362 +0200 CEST m=+0.111171801
+
 package apply
 
 import (

internal/array/array.go

@@ -42,10 +42,27 @@ func Reduce[GA ~[]A, A, B any](fa GA, f func(B, A) B, initial B) B {
 	return current
 }
 
+func ReduceWithIndex[GA ~[]A, A, B any](fa GA, f func(int, B, A) B, initial B) B {
+	current := initial
+	count := len(fa)
+	for i := 0; i < count; i++ {
+		current = f(i, current, fa[i])
+	}
+	return current
+}
+
 func Append[GA ~[]A, A any](as GA, a A) GA {
 	return append(as, a)
 }
 
+func Push[GA ~[]A, A any](as GA, a A) GA {
+	l := len(as)
+	cpy := make(GA, l+1)
+	copy(cpy, as)
+	cpy[l] = a
+	return cpy
+}
+
 func Empty[GA ~[]A, A any]() GA {
 	return make(GA, 0)
 }

internal/bindt/bind.go

@@ -0,0 +1,75 @@
+// 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 bindt
+
+import (
+	F "github.com/IBM/fp-go/function"
+	I "github.com/IBM/fp-go/identity"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func Bind[SET ~func(B) func(S1) S2, FCT ~func(S1) HKTB, S1, S2, B, HKTS1, HKTS2, HKTB any](
+	mchain func(func(S1) HKTS2) func(HKTS1) HKTS2,
+	mmap func(func(B) S2) func(HKTB) HKTS2,
+	s SET,
+	f FCT,
+) func(HKTS1) HKTS2 {
+	return mchain(F.Flow3(
+		T.Replicate2[S1],
+		T.Map2(F.Flow2(
+			I.Ap[S2, S1],
+			F.Flow2(
+				F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s),
+				mmap,
+			)), f),
+		T.Tupled2(I.MonadAp[HKTS2, HKTB]),
+	))
+}
+
+func BindTo[SET ~func(B) S2, S2, B, HKTS2, HKTB any](
+	mmap func(func(B) S2) func(HKTB) HKTS2,
+	s SET,
+) func(HKTB) HKTS2 {
+	return mmap(s)
+}
+
+func ApS[
+	SET ~func(B) func(S1) S2,
+	S1, S2, B, HKTS1S2, HKTS1, HKTS2, HKTB any,
+](
+	ap func(HKTS1) func(HKTS1S2) HKTS2,
+	mmap func(func(B) func(S1) S2) func(HKTB) HKTS1S2,
+	s SET, fb HKTB) func(HKTS1) HKTS2 {
+
+	return F.Flow2(
+		ap,
+		I.Ap[HKTS2, HKTS1S2](mmap(s)(fb)),
+	)
+}
+
+func Let[SET ~func(B) func(S1) S2, FCT ~func(S1) B, S1, S2, B, HKTS1, HKTS2 any](
+	mmap func(func(S1) S2) func(HKTS1) HKTS2,
+	s SET,
+	f FCT,
+) func(HKTS1) HKTS2 {
+	return mmap(F.Flow3(
+		T.Replicate2[S1],
+		T.Map2(F.Flow2(
+			I.Ap[S2, S1],
+			F.Bind1st(F.Flow2[SET, func(func(S1) S2) S2], s)), f),
+		T.Tupled2(I.MonadAp[S2, B]),
+	))
+}

internal/lazy/memoize.go

@@ -0,0 +1,34 @@
+// 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 lazy
+
+import "sync"
+
+// Memoize computes the value of the provided IO monad lazily but exactly once
+func Memoize[GA ~func() A, A any](ma GA) GA {
+	// synchronization primitives
+	var once sync.Once
+	var result A
+	// callback
+	gen := func() {
+		result = ma()
+	}
+	// returns our memoized wrapper
+	return func() A {
+		once.Do(gen)
+		return result
+	}
+}

io/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:57.7378739 +0200 CEST m=+0.063371401
+// 2023-08-17 22:59:10.1040409 +0200 CEST m=+0.089470201
+
 package io
 
 import (

io/generic/ap.go

@@ -64,6 +64,28 @@ func MonadApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](f
 	)
 }
 
+// MonadApFirstPar combines two effectful actions, keeping only the result of the first.
+func MonadApFirstPar[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](first GA, second GB) GA {
+	return G.MonadApFirst(
+		MonadApPar[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		first,
+		second,
+	)
+}
+
+// MonadApFirstSeq combines two effectful actions, keeping only the result of the first.
+func MonadApFirstSeq[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](first GA, second GB) GA {
+	return G.MonadApFirst(
+		MonadApSeq[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		first,
+		second,
+	)
+}
+
 // ApFirst combines two effectful actions, keeping only the result of the first.
 func ApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
 	return G.ApFirst(
@@ -74,6 +96,26 @@ func ApFirst[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second
 	)
 }
 
+// ApFirstPar combines two effectful actions, keeping only the result of the first.
+func ApFirstPar[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
+	return G.ApFirst(
+		MonadApPar[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		second,
+	)
+}
+
+// ApFirstSeq combines two effectful actions, keeping only the result of the first.
+func ApFirstSeq[GA ~func() A, GB ~func() B, GBA ~func() func(B) A, A, B any](second GB) func(GA) GA {
+	return G.ApFirst(
+		MonadApSeq[GB, GA, GBA, B, A],
+		MonadMap[GA, GBA, A, func(B) A],
+
+		second,
+	)
+}
+
 // MonadApSecond combines two effectful actions, keeping only the result of the second.
 func MonadApSecond[GA ~func() A, GB ~func() B, GBB ~func() func(B) B, A, B any](first GA, second GB) GB {
 	return G.MonadApSecond(

io/generic/gen.go

@@ -1,21 +1,6 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:48:57.7499229 +0200 CEST m=+0.075420401
+// 2023-08-17 22:59:10.1132645 +0200 CEST m=+0.098693801
 package generic
 
 import (

io/generic/io.go

@@ -16,11 +16,11 @@
 package generic
 
 import (
-	"sync"
 	"time"
 
 	F "github.com/IBM/fp-go/function"
 	C "github.com/IBM/fp-go/internal/chain"
+	L "github.com/IBM/fp-go/internal/lazy"
 )
 
 // type IO[A any] = func() A
@@ -119,18 +119,7 @@ func Flatten[GA ~func() A, GAA ~func() GA, A any](mma GAA) GA {
 
 // Memoize computes the value of the provided IO monad lazily but exactly once
 func Memoize[GA ~func() A, A any](ma GA) GA {
-	// synchronization primitives
-	var once sync.Once
-	var result A
-	// callback
-	gen := func() {
-		result = ma()
-	}
-	// returns our memoized wrapper
-	return func() A {
-		once.Do(gen)
-		return result
-	}
+	return L.Memoize[GA, A](ma)
 }
 
 // Delay creates an operation that passes in the value after some delay

ioeither/bind.go

@@ -0,0 +1,44 @@
+// 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 (
+	G "github.com/IBM/fp-go/ioeither/generic"
+)
+
+// Bind applies a function to an input state and merges the result into that state
+func Bind[E, A, S1, S2 any](s func(A) func(S1) S2, f func(S1) IOEither[E, A]) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.Bind[IOEither[E, S1], IOEither[E, S2], IOEither[E, A], func(S1) IOEither[E, A]](s, f)
+}
+
+// BindTo initializes some state based on a value
+func BindTo[
+	E, A, S2 any](s func(A) S2) func(IOEither[E, A]) IOEither[E, S2] {
+	return G.BindTo[IOEither[E, S2], IOEither[E, A]](s)
+}
+
+func ApS[
+	E, A, S1, S2 any,
+](s func(A) func(S1) S2, fa IOEither[E, A]) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.ApS[IOEither[E, S1], IOEither[E, S2], IOEither[E, A], IOEither[E, func(S1) S2]](s, fa)
+}
+
+func Let[E, A, S1, S2 any](
+	s func(A) func(S1) S2,
+	f func(S1) A,
+) func(IOEither[E, S1]) IOEither[E, S2] {
+	return G.Let[IOEither[E, S1], IOEither[E, S2]](s, f)
+}

ioeither/examples_create_test.go

@@ -0,0 +1,57 @@
+// 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"
+
+	E "github.com/IBM/fp-go/either"
+)
+
+func ExampleIOEither_creation() {
+	// Build an IOEither
+	leftValue := Left[string](fmt.Errorf("some error"))
+	rightValue := Right[error]("value")
+
+	// Convert from Either
+	eitherValue := E.Of[error](42)
+	ioFromEither := FromEither(eitherValue)
+
+	// some predicate
+	isEven := func(num int) (int, error) {
+		if num%2 == 0 {
+			return num, nil
+		}
+		return 0, fmt.Errorf("%d is an odd number", num)
+	}
+	fromEven := Eitherize1(isEven)
+	leftFromPred := fromEven(3)
+	rightFromPred := fromEven(4)
+
+	fmt.Println(leftValue())
+	fmt.Println(rightValue())
+	fmt.Println(ioFromEither())
+	fmt.Println(leftFromPred())
+	fmt.Println(rightFromPred())
+
+	// Output:
+	// Left[*errors.errorString, string](some error)
+	// Right[<nil>, string](value)
+	// Right[<nil>, int](42)
+	// Left[*errors.errorString, int](3 is an odd number)
+	// Right[<nil>, int](4)
+
+}

ioeither/examples_do_test.go

@@ -0,0 +1,57 @@
+// 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"
+	"log"
+
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func ExampleIOEither_do() {
+	foo := Of[error]("foo")
+	bar := Of[error](1)
+
+	// quux consumes the state of three bindings and returns an [IO] instead of an [IOEither]
+	quux := func(t T.Tuple3[string, int, string]) IO.IO[any] {
+		return IO.FromImpure(func() {
+			log.Printf("t1: %s, t2: %d, t3: %s", t.F1, t.F2, t.F3)
+		})
+	}
+
+	transform := func(t T.Tuple3[string, int, string]) int {
+		return len(t.F1) + t.F2 + len(t.F3)
+	}
+
+	b := F.Pipe5(
+		foo,
+		BindTo[error](T.Of[string]),
+		ApS(T.Push1[string, int], bar),
+		Bind(T.Push2[string, int, string], func(t T.Tuple2[string, int]) IOEither[error, string] {
+			return Of[error](fmt.Sprintf("%s%d", t.F1, t.F2))
+		}),
+		ChainFirstIOK[error](quux),
+		Map[error](transform),
+	)
+
+	fmt.Println(b())
+
+	// Output:
+	// Right[<nil>, int](8)
+}

ioeither/examples_extract_test.go

@@ -0,0 +1,45 @@
+// 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"
+
+	E "github.com/IBM/fp-go/either"
+	F "github.com/IBM/fp-go/function"
+	IO "github.com/IBM/fp-go/io"
+)
+
+func ExampleIOEither_extraction() {
+	// IOEither
+	someIOEither := Right[error](42)
+	eitherValue := someIOEither()                            // E.Right(42)
+	value := E.GetOrElse(F.Constant1[error](0))(eitherValue) // 42
+
+	// Or more directly
+	infaillibleIO := GetOrElse(F.Constant1[error](IO.Of(0)))(someIOEither) // => IO.Right(42)
+	valueFromIO := infaillibleIO()                                         // => 42
+
+	fmt.Println(eitherValue)
+	fmt.Println(value)
+	fmt.Println(valueFromIO)
+
+	// Output:
+	// Right[<nil>, int](42)
+	// 42
+	// 42
+
+}

ioeither/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:00.7618943 +0200 CEST m=+0.065441701
+// 2023-08-17 22:59:12.0033119 +0200 CEST m=+0.096740401
+
 package ioeither
 
 import (

ioeither/generic/bind.go

@@ -0,0 +1,79 @@
+// 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 generic
+
+import (
+	ET "github.com/IBM/fp-go/either"
+	G "github.com/IBM/fp-go/internal/bindt"
+)
+
+// Bind applies a function to an input state and merges the result into that state
+func Bind[
+	GS1 ~func() ET.Either[E, S1],
+	GS2 ~func() ET.Either[E, S2],
+	GA ~func() ET.Either[E, A],
+	FCT ~func(S1) GA,
+	E any,
+	SET ~func(A) func(S1) S2,
+	A, S1, S2 any](s SET, f FCT) func(GS1) GS2 {
+	return G.Bind(
+		Chain[GS1, GS2, E, S1, S2],
+		Map[GA, GS2, E, A, S2],
+		s,
+		f,
+	)
+}
+
+// BindTo initializes some state based on a value
+func BindTo[
+	GS2 ~func() ET.Either[E, S2],
+	GA ~func() ET.Either[E, A],
+	E any,
+	SET ~func(A) S2,
+	A, S2 any](s SET) func(GA) GS2 {
+	return G.BindTo(
+		Map[GA, GS2, E, A, S2],
+		s,
+	)
+}
+
+func ApS[
+	GS1 ~func() ET.Either[E, S1],
+	GS2 ~func() ET.Either[E, S2],
+	GB ~func() ET.Either[E, B],
+	GS1S2 ~func() ET.Either[E, func(S1) S2],
+	SET ~func(B) func(S1) S2,
+	E, S1, S2, B any,
+](s SET, fb GB) func(GS1) GS2 {
+	return G.ApS[SET, S1, S2, B, GS1S2, GS1, GS2, GB](
+		Ap[GS2, GS1S2, GS1, E, S1, S2],
+		Map[GB, GS1S2, E, B, func(S1) S2],
+		s,
+		fb,
+	)
+}
+
+func Let[
+	GS1 ~func() ET.Either[E, S1],
+	GS2 ~func() ET.Either[E, S2],
+	SET ~func(B) func(S1) S2,
+	FCT ~func(S1) B,
+	E, S1, S2, B any](
+	s SET,
+	f FCT,
+) func(GS1) GS2 {
+	return G.Let[SET, FCT, S1, S2, B, GS1, GS2](Map[GS1, GS2, E, S1, S2], s, f)
+}

ioeither/generic/gen.go

@@ -1,21 +1,6 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:00.7765028 +0200 CEST m=+0.080050201
+// 2023-08-17 22:59:12.0246635 +0200 CEST m=+0.118092001
 package generic
 
 import (

iooption/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:03.8471425 +0200 CEST m=+0.087124201
+// 2023-08-17 22:59:14.0582736 +0200 CEST m=+0.248503201
+
 package iooption
 
 import (

iooption/generic/gen.go

@@ -1,21 +1,6 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:03.8541587 +0200 CEST m=+0.094140401
+// 2023-08-17 22:59:14.0642289 +0200 CEST m=+0.254458501
 package generic
 
 import (

iterator/stateless/first.go

@@ -0,0 +1,26 @@
+// 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 (
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// First returns the first item in an iterator if such an item exists
+func First[U any](mu Iterator[U]) O.Option[U] {
+	return G.First[Iterator[U]](mu)
+}

iterator/stateless/first_test.go

@@ -0,0 +1,41 @@
+// 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"
+
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFirst(t *testing.T) {
+
+	seq := From(1, 2, 3)
+
+	fst := First(seq)
+
+	assert.Equal(t, O.Of(1), fst)
+}
+
+func TestNoFirst(t *testing.T) {
+
+	seq := Empty[int]()
+
+	fst := First(seq)
+
+	assert.Equal(t, O.None[int](), fst)
+}

iterator/stateless/generic/first.go

@@ -0,0 +1,30 @@
+// 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 generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// First returns the first item in an iterator if such an item exists
+func First[GU ~func() O.Option[T.Tuple2[GU, U]], U any](mu GU) O.Option[U] {
+	return F.Pipe1(
+		mu(),
+		O.Map(T.Second[GU, U]),
+	)
+}

iterator/stateless/generic/iterator.go

@@ -20,6 +20,7 @@ import (
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
 	IO "github.com/IBM/fp-go/iooption/generic"
+	M "github.com/IBM/fp-go/monoid"
 	N "github.com/IBM/fp-go/number"
 	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
@@ -49,18 +50,21 @@ func FromArray[GU ~func() O.Option[T.Tuple2[GU, U]], US ~[]U, U any](as US) GU {
 	})(as)
 }
 
+// reduce applies a function for each value of the iterator with a floating result
+func reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](as GU, f func(V, U) V, initial V) V {
+	next, ok := O.Unwrap(as())
+	current := initial
+	for ok {
+		// next (with bad side effect)
+		current = f(current, next.F2)
+		next, ok = O.Unwrap(next.F1())
+	}
+	return current
+}
+
 // Reduce applies a function for each value of the iterator with a floating result
 func Reduce[GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](f func(V, U) V, initial V) func(GU) V {
-	return func(as GU) V {
-		next, ok := O.Unwrap(as())
-		current := initial
-		for ok {
-			// next (with bad side effect)
-			current = f(current, next.F2)
-			next, ok = O.Unwrap(next.F1())
-		}
-		return current
-	}
+	return F.Bind23of3(reduce[GU, U, V])(f, initial)
 }
 
 // ToArray converts the iterator to an array
@@ -216,3 +220,22 @@ func Ap[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tu
 func MonadAp[GUV ~func() O.Option[T.Tuple2[GUV, func(U) V]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], U, V any](fab GUV, ma GU) GV {
 	return Ap[GUV, GV, GU](ma)(fab)
 }
+
+func FilterChain[GVV ~func() O.Option[T.Tuple2[GVV, GV]], GV ~func() O.Option[T.Tuple2[GV, V]], GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) O.Option[GV], U, V any](f FCT) func(ma GU) GV {
+	return F.Flow2(
+		FilterMap[GVV, GU](f),
+		Flatten[GVV],
+	)
+}
+
+func FoldMap[GU ~func() O.Option[T.Tuple2[GU, U]], FCT ~func(U) V, U, V any](m M.Monoid[V]) func(FCT) func(ma GU) V {
+	return func(f FCT) func(ma GU) V {
+		return Reduce[GU](func(cur V, a U) V {
+			return m.Concat(cur, f(a))
+		}, m.Empty())
+	}
+}
+
+func Fold[GU ~func() O.Option[T.Tuple2[GU, U]], U any](m M.Monoid[U]) func(ma GU) U {
+	return Reduce[GU](m.Concat, m.Empty())
+}

iterator/stateless/generic/last.go

@@ -0,0 +1,27 @@
+// 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 generic
+
+import (
+	F "github.com/IBM/fp-go/function"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+// Last returns the last item in an iterator if such an item exists
+func Last[GU ~func() O.Option[T.Tuple2[GU, U]], U any](mu GU) O.Option[U] {
+	return reduce(mu, F.Ignore1of2[O.Option[U]](O.Of[U]), O.None[U]())
+}

iterator/stateless/generic/reflect.go

@@ -0,0 +1,53 @@
+// 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 generic
+
+import (
+	R "reflect"
+
+	F "github.com/IBM/fp-go/function"
+	LG "github.com/IBM/fp-go/io/generic"
+	L "github.com/IBM/fp-go/lazy"
+	N "github.com/IBM/fp-go/number"
+	I "github.com/IBM/fp-go/number/integer"
+	O "github.com/IBM/fp-go/option"
+	T "github.com/IBM/fp-go/tuple"
+)
+
+func FromReflect[GR ~func() O.Option[T.Tuple2[GR, R.Value]]](val R.Value) GR {
+	// recursive callback
+	var recurse func(idx int) GR
+
+	// limits the index
+	fromPred := O.FromPredicate(I.Between(0, val.Len()))
+
+	recurse = func(idx int) GR {
+		return F.Pipe3(
+			idx,
+			L.Of[int],
+			L.Map(fromPred),
+			LG.Map[L.Lazy[O.Option[int]], GR](O.Map(
+				F.Flow2(
+					T.Replicate2[int],
+					T.Map2(F.Flow2(N.Add(1), recurse), val.Index),
+				),
+			)),
+		)
+	}
+
+	// start the recursion
+	return recurse(0)
+}

iterator/stateless/iterator.go

@@ -18,6 +18,7 @@ package stateless
 import (
 	G "github.com/IBM/fp-go/iterator/stateless/generic"
 	L "github.com/IBM/fp-go/lazy"
+	M "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
 	T "github.com/IBM/fp-go/tuple"
 )
@@ -118,3 +119,18 @@ func Repeat[U any](n int, a U) Iterator[U] {
 func Count(start int) Iterator[int] {
 	return G.Count[Iterator[int]](start)
 }
+
+// FilterChain filters and transforms the content of an iterator
+func FilterChain[U, V any](f func(U) O.Option[Iterator[V]]) func(ma Iterator[U]) Iterator[V] {
+	return G.FilterChain[Iterator[Iterator[V]], Iterator[V], Iterator[U]](f)
+}
+
+// FoldMap maps and folds an iterator. Map the iterator passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[U, V any](m M.Monoid[V]) func(func(U) V) func(ma Iterator[U]) V {
+	return G.FoldMap[Iterator[U], func(U) V, U, V](m)
+}
+
+// Fold folds the iterator using the provided Monoid.
+func Fold[U any](m M.Monoid[U]) func(Iterator[U]) U {
+	return G.Fold[Iterator[U]](m)
+}

iterator/stateless/iterator_test.go

@@ -18,12 +18,14 @@ package stateless
 import (
 	"fmt"
 	"math"
+	"strings"
 	"testing"
 
 	A "github.com/IBM/fp-go/array"
 	F "github.com/IBM/fp-go/function"
 	"github.com/IBM/fp-go/internal/utils"
 	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -102,3 +104,14 @@ func TestAp(t *testing.T) {
 
 	assert.Equal(t, A.From("a-1-c", "a-1-d", "a-2-c", "a-2-d", "b-1-c", "b-1-d", "b-2-c", "b-2-d"), it)
 }
+
+func ExampleFoldMap() {
+	src := From("a", "b", "c")
+
+	fold := FoldMap[string](S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}

iterator/stateless/last.go

@@ -0,0 +1,27 @@
+// 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 (
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+	O "github.com/IBM/fp-go/option"
+)
+
+// Last returns the last item in an iterator if such an item exists
+// Note that the function will consume the [Iterator] in this call completely, to identify the last element. Do not use this for infinite iterators
+func Last[U any](mu Iterator[U]) O.Option[U] {
+	return G.Last[Iterator[U]](mu)
+}

iterator/stateless/last_test.go

@@ -0,0 +1,41 @@
+// 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"
+
+	O "github.com/IBM/fp-go/option"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLast(t *testing.T) {
+
+	seq := From(1, 2, 3)
+
+	fst := Last(seq)
+
+	assert.Equal(t, O.Of(3), fst)
+}
+
+func TestNoLast(t *testing.T) {
+
+	seq := Empty[int]()
+
+	fst := Last(seq)
+
+	assert.Equal(t, O.None[int](), fst)
+}

iterator/stateless/reflect.go

@@ -0,0 +1,27 @@
+// 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 (
+	R "reflect"
+
+	G "github.com/IBM/fp-go/iterator/stateless/generic"
+)
+
+// FromReflect creates an iterator that can iterate over types that define [R.Index] and [R.Len]
+func FromReflect(val R.Value) Iterator[R.Value] {
+	return G.FromReflect[Iterator[R.Value]](val)
+}

iterator/stateless/reflect_test.go

@@ -0,0 +1,38 @@
+// 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 (
+	"reflect"
+	"testing"
+
+	A "github.com/IBM/fp-go/array"
+	F "github.com/IBM/fp-go/function"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestReflect(t *testing.T) {
+	ar := A.From("a", "b", "c")
+
+	res := F.Pipe3(
+		reflect.ValueOf(ar),
+		FromReflect,
+		ToArray[reflect.Value],
+		A.Map(reflect.Value.String),
+	)
+
+	assert.Equal(t, ar, res)
+}

json/type.go

@@ -32,6 +32,6 @@ func ToTypeE[A any](src any) E.Either[error, A] {
 func ToTypeO[A any](src any) O.Option[A] {
 	return F.Pipe1(
 		ToTypeE[A](src),
-		E.ToOption[error, A](),
+		E.ToOption[error, A],
 	)
 }

lazy/example_lazy_test.go

@@ -0,0 +1,38 @@
+// 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 lazy
+
+import (
+	"fmt"
+	"strconv"
+
+	F "github.com/IBM/fp-go/function"
+)
+
+func ExampleLazy_creation() {
+	// lazy function of a constant value
+	val := Of(42)
+	// create another function to transform this
+	valS := F.Pipe1(
+		val,
+		Map(strconv.Itoa),
+	)
+
+	fmt.Println(valS())
+
+	// Output:
+	// 42
+}

lazy/lazy.go

@@ -72,18 +72,18 @@ func Chain[A, B any](f func(A) Lazy[B]) func(Lazy[A]) Lazy[B] {
 }
 
 func MonadAp[B, A any](mab Lazy[func(A) B], ma Lazy[A]) Lazy[B] {
-	return G.MonadAp[Lazy[A], Lazy[B]](mab, ma)
+	return G.MonadApSeq[Lazy[A], Lazy[B]](mab, ma)
 }
 
 func Ap[B, A any](ma Lazy[A]) func(Lazy[func(A) B]) Lazy[B] {
-	return G.Ap[Lazy[B], Lazy[func(A) B], Lazy[A]](ma)
+	return G.ApSeq[Lazy[B], Lazy[func(A) B], Lazy[A]](ma)
 }
 
 func Flatten[A any](mma Lazy[Lazy[A]]) Lazy[A] {
 	return G.Flatten(mma)
 }
 
-// Memoize computes the value of the provided IO monad lazily but exactly once
+// Memoize computes the value of the provided [Lazy] monad lazily but exactly once
 func Memoize[A any](ma Lazy[A]) Lazy[A] {
 	return G.Memoize(ma)
 }

number/utils.go

@@ -30,6 +30,13 @@ func Add[T Number](left T) func(T) T {
 	}
 }
 
+// Mul is a curried function used to add two numbers
+func Mul[T Number](coeff T) func(T) T {
+	return func(value T) T {
+		return coeff * value
+	}
+}
+
 // Inc is a function that increments a number
 func Inc[T Number](value T) T {
 	return value + 1

option/doc.go

@@ -13,6 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Package option defines the [Option] datastructure and its monadic operations
 package option
 
 //go:generate go run .. option --count 10 --filename gen.go

option/examples_create_test.go

@@ -0,0 +1,55 @@
+// 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 option
+
+import "fmt"
+
+func ExampleOption_creation() {
+
+	// Build an Option
+	none1 := None[int]()
+	some1 := Some("value")
+
+	// Build from a value
+	fromNillable := FromNillable[string]
+	nonFromNil := fromNillable(nil) // None[*string]
+	value := "value"
+	someFromPointer := fromNillable(&value) // Some[*string](xxx)
+
+	// some predicate
+	isEven := func(num int) bool {
+		return num%2 == 0
+	}
+
+	fromEven := FromPredicate(isEven)
+	noneFromPred := fromEven(3) // None[int]
+	someFromPred := fromEven(4) // Some[int](4)
+
+	fmt.Println(none1)
+	fmt.Println(some1)
+	fmt.Println(nonFromNil)
+	fmt.Println(IsSome(someFromPointer))
+	fmt.Println(noneFromPred)
+	fmt.Println(someFromPred)
+
+	// Output:
+	// None[int]
+	// Some[string](value)
+	// None[*string]
+	// true
+	// None[int]
+	// Some[int](4)
+}

option/examples_extract_test.go

@@ -0,0 +1,73 @@
+// 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 option
+
+import (
+	"fmt"
+
+	F "github.com/IBM/fp-go/function"
+	N "github.com/IBM/fp-go/number"
+)
+
+func ExampleOption_extraction() {
+
+	noneValue := None[int]()
+	someValue := Of(42)
+
+	// Convert Option[T] to T
+	fromNone, okFromNone := Unwrap(noneValue) // 0, false
+	fromSome, okFromSome := Unwrap(someValue) // 42, true
+
+	// Convert Option[T] with a default value
+	noneWithDefault := GetOrElse(F.Constant(0))(noneValue) // 0
+	someWithDefault := GetOrElse(F.Constant(0))(someValue) // 42
+
+	// Apply a different function on None/Some(...)
+	doubleOrZero := Fold(
+		F.Constant(0), // none case
+		N.Mul(2),      // some case
+	) // func(ma Option[int]) int
+
+	doubleFromNone := doubleOrZero(noneValue) // 0
+	doubleFromSome := doubleOrZero(someValue) // 84
+
+	// Pro-tip: Fold is short for the following:
+	doubleOfZeroBis := F.Flow2(
+		Map(N.Mul(2)),            // some case
+		GetOrElse(F.Constant(0)), // none case
+	)
+	doubleFromNoneBis := doubleOfZeroBis(noneValue) // 0
+	doubleFromSomeBis := doubleOfZeroBis(someValue) // 84
+
+	fmt.Printf("%d, %t\n", fromNone, okFromNone)
+	fmt.Printf("%d, %t\n", fromSome, okFromSome)
+	fmt.Println(noneWithDefault)
+	fmt.Println(someWithDefault)
+	fmt.Println(doubleFromNone)
+	fmt.Println(doubleFromSome)
+	fmt.Println(doubleFromNoneBis)
+	fmt.Println(doubleFromSomeBis)
+
+	// Output:
+	// 0, false
+	// 42, true
+	// 0
+	// 42
+	// 0
+	// 84
+	// 0
+	// 84
+}

option/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:06.6236747 +0200 CEST m=+0.039283301
+// 2023-08-17 22:59:16.3450991 +0200 CEST m=+0.104894201
+
 package option
 
 import (

option/ord.go

@@ -0,0 +1,38 @@
+// 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 option
+
+import (
+	C "github.com/IBM/fp-go/constraints"
+	F "github.com/IBM/fp-go/function"
+	"github.com/IBM/fp-go/ord"
+)
+
+// Constructs an order for [Option]
+func Ord[A any](a ord.Ord[A]) ord.Ord[Option[A]] {
+	// some convenient shortcuts
+	fld := Fold(
+		F.Constant(Fold(F.Constant(0), F.Constant1[A](-1))),
+		F.Flow2(F.Curry2(a.Compare), F.Bind1st(Fold[A, int], F.Constant(1))),
+	)
+	// convert to an ordering predicate
+	return ord.MakeOrd(F.Uncurry2(fld), Eq(ord.ToEq(a)).Equals)
+}
+
+// FromStrictCompare constructs an [Ord] from the canonical comparison function
+func FromStrictCompare[A C.Ordered]() ord.Ord[Option[A]] {
+	return Ord(ord.FromStrictCompare[A]())
+}

option/ord_test.go

@@ -0,0 +1,46 @@
+// 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 option
+
+import (
+	"testing"
+
+	S "github.com/IBM/fp-go/string"
+	"github.com/stretchr/testify/assert"
+)
+
+// it('getOrd', () => {
+//     const OS = _.getOrd(S.Ord)
+//     U.deepStrictEqual(OS.compare(_.none, _.none), 0)
+//     U.deepStrictEqual(OS.compare(_.some('a'), _.none), 1)
+//     U.deepStrictEqual(OS.compare(_.none, _.some('a')), -1)
+//     U.deepStrictEqual(OS.compare(_.some('a'), _.some('a')), 0)
+//     U.deepStrictEqual(OS.compare(_.some('a'), _.some('b')), -1)
+//     U.deepStrictEqual(OS.compare(_.some('b'), _.some('a')), 1)
+//   })
+
+func TestOrd(t *testing.T) {
+
+	os := Ord(S.Ord)
+
+	assert.Equal(t, 0, os.Compare(None[string](), None[string]()))
+	assert.Equal(t, 1, os.Compare(Some("a"), None[string]()))
+	assert.Equal(t, -1, os.Compare(None[string](), Some("a")))
+	assert.Equal(t, 0, os.Compare(Some("a"), Some("a")))
+	assert.Equal(t, -1, os.Compare(Some("a"), Some("b")))
+	assert.Equal(t, 1, os.Compare(Some("b"), Some("a")))
+
+}

ord/ord.go

@@ -40,6 +40,11 @@ func (self ord[T]) Compare(x, y T) int {
 	return self.c(x, y)
 }
 
+// ToEq converts an [Ord] to [E.Eq]
+func ToEq[T any](o Ord[T]) E.Eq[T] {
+	return o
+}
+
 // MakeOrd creates an instance of an Ord
 func MakeOrd[T any](c func(x, y T) int, e func(x, y T) bool) Ord[T] {
 	return ord[T]{c: c, e: e}

reader/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
+// 2023-08-17 22:59:18.4448291 +0200 CEST m=+0.161369001
+
 package reader
 
 import (

reader/generic/gen.go

@@ -1,21 +1,6 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:14.4173227 +0200 CEST m=+0.013163201
+// 2023-08-17 22:59:18.5047315 +0200 CEST m=+0.221271401
 package generic
 
 // From0 converts a function with 1 parameters returning a [R] into a function with 0 parameters returning a [GRA]

readerioeither/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:16.5272334 +0200 CEST m=+0.043108701
+// 2023-08-17 22:59:21.3704716 +0200 CEST m=+0.110126101
+
 package readerioeither
 
 import (

readerioeither/generic/gen.go

@@ -1,21 +1,6 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:16.5292332 +0200 CEST m=+0.045108501
+// 2023-08-17 22:59:21.3811525 +0200 CEST m=+0.120807001
 package generic
 
 import (

record/doc.go

@@ -0,0 +1,17 @@
+// 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 record contains monadic operations for maps as well as a rich set of utility functions
+package record

record/generic/monoid.go

@@ -16,6 +16,7 @@
 package generic
 
 import (
+	F "github.com/IBM/fp-go/function"
 	M "github.com/IBM/fp-go/monoid"
 	S "github.com/IBM/fp-go/semigroup"
 )
@@ -26,3 +27,17 @@ func UnionMonoid[N ~map[K]V, K comparable, V any](s S.Semigroup[V]) M.Monoid[N]
 		Empty[N](),
 	)
 }
+
+func UnionLastMonoid[N ~map[K]V, K comparable, V any]() M.Monoid[N] {
+	return M.MakeMonoid(
+		unionLast[N],
+		Empty[N](),
+	)
+}
+
+func UnionFirstMonoid[N ~map[K]V, K comparable, V any]() M.Monoid[N] {
+	return M.MakeMonoid(
+		F.Swap(unionLast[N]),
+		Empty[N](),
+	)
+}

record/generic/record.go

@@ -16,10 +16,14 @@
 package generic
 
 import (
+	"sort"
+
 	F "github.com/IBM/fp-go/function"
 	G "github.com/IBM/fp-go/internal/record"
 	Mg "github.com/IBM/fp-go/magma"
+	Mo "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/ord"
 	T "github.com/IBM/fp-go/tuple"
 )
 
@@ -39,6 +43,46 @@ func Values[M ~map[K]V, GV ~[]V, K comparable, V any](r M) GV {
 	return collect[M, GV](r, F.Second[K, V])
 }
 
+func KeysOrd[M ~map[K]V, GK ~[]K, K comparable, V any](o ord.Ord[K]) func(r M) GK {
+	return func(r M) GK {
+		return collectOrd[M, GK](o, r, F.First[K, V])
+	}
+}
+
+func ValuesOrd[M ~map[K]V, GV ~[]V, K comparable, V any](o ord.Ord[K]) func(r M) GV {
+	return func(r M) GV {
+		return collectOrd[M, GV](o, r, F.Second[K, V])
+	}
+}
+
+func collectOrd[M ~map[K]V, GR ~[]R, K comparable, V, R any](o ord.Ord[K], r M, f func(K, V) R) GR {
+	// create the entries
+	entries := toEntriesOrd[M, []T.Tuple2[K, V]](o, r)
+	// collect this array
+	ft := T.Tupled2(f)
+	count := len(entries)
+	result := make(GR, count)
+	for i := count - 1; i >= 0; i-- {
+		result[i] = ft(entries[i])
+	}
+	// done
+	return result
+}
+
+func reduceOrd[M ~map[K]V, K comparable, V, R any](o ord.Ord[K], r M, f func(K, R, V) R, initial R) R {
+	// create the entries
+	entries := toEntriesOrd[M, []T.Tuple2[K, V]](o, r)
+	// collect this array
+	current := initial
+	count := len(entries)
+	for i := 0; i < count; i++ {
+		t := entries[i]
+		current = f(T.First(t), current, T.Second(t))
+	}
+	// done
+	return current
+}
+
 func collect[M ~map[K]V, GR ~[]R, K comparable, V, R any](r M, f func(K, V) R) GR {
 	count := len(r)
 	result := make(GR, count)
@@ -82,6 +126,34 @@ func MonadMap[M ~map[K]V, N ~map[K]R, K comparable, V, R any](r M, f func(V) R)
 	return MonadMapWithIndex[M, N](r, F.Ignore1of2[K](f))
 }
 
+func MonadChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N], r M, f func(K, V1) N) N {
+	return G.ReduceWithIndex(r, func(k K, dst N, b V1) N {
+		return m.Concat(dst, f(k, b))
+	}, m.Empty())
+}
+
+func MonadChain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N], r M, f func(V1) N) N {
+	return G.Reduce(r, func(dst N, b V1) N {
+		return m.Concat(dst, f(b))
+	}, m.Empty())
+}
+
+func ChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(K, V1) N) func(M) N {
+	return func(f func(K, V1) N) func(M) N {
+		return func(ma M) N {
+			return MonadChainWithIndex(m, ma, f)
+		}
+	}
+}
+
+func Chain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(V1) N) func(M) N {
+	return func(f func(V1) N) func(M) N {
+		return func(ma M) N {
+			return MonadChain(m, ma, f)
+		}
+	}
+}
+
 func MonadMapWithIndex[M ~map[K]V, N ~map[K]R, K comparable, V, R any](r M, f func(K, V) R) N {
 	return G.ReduceWithIndex(r, func(k K, dst N, v V) N {
 		return upsertAtReadWrite(dst, k, f(k, v))
@@ -114,15 +186,14 @@ func MapRefWithIndex[M ~map[K]V, N ~map[K]R, K comparable, V, R any](f func(K, *
 	return F.Bind2nd(MonadMapRefWithIndex[M, N, K, V, R], f)
 }
 
-func lookup[M ~map[K]V, K comparable, V any](r M, k K) O.Option[V] {
-	if val, ok := r[k]; ok {
-		return O.Some(val)
-	}
-	return O.None[V]()
-}
-
 func Lookup[M ~map[K]V, K comparable, V any](k K) func(M) O.Option[V] {
-	return F.Bind2nd(lookup[M, K, V], k)
+	n := O.None[V]()
+	return func(m M) O.Option[V] {
+		if val, ok := m[k]; ok {
+			return O.Some(val)
+		}
+		return n
+	}
 }
 
 func Has[M ~map[K]V, K comparable, V any](k K, r M) bool {
@@ -161,6 +232,31 @@ func union[M ~map[K]V, K comparable, V any](m Mg.Magma[V], left M, right M) M {
 	return result
 }
 
+func unionLast[M ~map[K]V, K comparable, V any](left M, right M) M {
+	lenLeft := len(left)
+
+	if lenLeft == 0 {
+		return right
+	}
+
+	lenRight := len(right)
+	if lenRight == 0 {
+		return left
+	}
+
+	result := make(M, lenLeft+lenRight)
+
+	for k, v := range left {
+		result[k] = v
+	}
+
+	for k, v := range right {
+		result[k] = v
+	}
+
+	return result
+}
+
 func Union[M ~map[K]V, K comparable, V any](m Mg.Magma[V]) func(M) func(M) M {
 	return func(right M) func(M) M {
 		return func(left M) M {
@@ -169,6 +265,22 @@ func Union[M ~map[K]V, K comparable, V any](m Mg.Magma[V]) func(M) func(M) M {
 	}
 }
 
+func UnionLast[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return func(left M) M {
+		return unionLast(left, right)
+	}
+}
+
+func Merge[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return UnionLast(right)
+}
+
+func UnionFirst[M ~map[K]V, K comparable, V any](right M) func(M) M {
+	return func(left M) M {
+		return unionLast(right, left)
+	}
+}
+
 func Empty[M ~map[K]V, K comparable, V any]() M {
 	return make(M)
 }
@@ -181,6 +293,27 @@ func ToArray[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](r M) GT {
 	return collect[M, GT](r, T.MakeTuple2[K, V])
 }
 
+func toEntriesOrd[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](o ord.Ord[K], r M) GT {
+	// total number of elements
+	count := len(r)
+	// produce an array that we can sort by key
+	entries := make(GT, count)
+	idx := 0
+	for k, v := range r {
+		entries[idx] = T.MakeTuple2(k, v)
+		idx++
+	}
+	sort.Slice(entries, func(i, j int) bool {
+		return o.Compare(T.First(entries[i]), T.First(entries[j])) < 0
+	})
+	// final entries
+	return entries
+}
+
+func ToEntriesOrd[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](o ord.Ord[K]) func(r M) GT {
+	return F.Bind1st(toEntriesOrd[M, GT, K, V], o)
+}
+
 func ToEntries[M ~map[K]V, GT ~[]T.Tuple2[K, V], K comparable, V any](r M) GT {
 	return ToArray[M, GT](r)
 }
@@ -269,6 +402,33 @@ func FilterMap[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](f func(V1) O.
 	return F.Bind2nd(filterMapWithIndex[M, N, K, V1, V2], F.Ignore1of2[K](f))
 }
 
+// Flatten converts a nested map into a regular map
+func Flatten[M ~map[K]N, N ~map[K]V, K comparable, V any](m Mo.Monoid[N]) func(M) N {
+	return Chain[M, N](m)(F.Identity[N])
+}
+
+// FilterChainWithIndex creates a new map with only the elements for which the transformation function creates a Some
+func FilterChainWithIndex[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(K, V1) O.Option[N]) func(M) N {
+	flatten := Flatten[map[K]N, N](m)
+	return func(f func(K, V1) O.Option[N]) func(M) N {
+		return F.Flow2(
+			FilterMapWithIndex[M, map[K]N](f),
+			flatten,
+		)
+	}
+}
+
+// FilterChain creates a new map with only the elements for which the transformation function creates a Some
+func FilterChain[M ~map[K]V1, N ~map[K]V2, K comparable, V1, V2 any](m Mo.Monoid[N]) func(func(V1) O.Option[N]) func(M) N {
+	flatten := Flatten[map[K]N, N](m)
+	return func(f func(V1) O.Option[N]) func(M) N {
+		return F.Flow2(
+			FilterMap[M, map[K]N](f),
+			flatten,
+		)
+	}
+}
+
 // IsNil checks if the map is set to nil
 func IsNil[M ~map[K]V, K comparable, V any](m M) bool {
 	return m == nil
@@ -283,3 +443,67 @@ func IsNonNil[M ~map[K]V, K comparable, V any](m M) bool {
 func ConstNil[M ~map[K]V, K comparable, V any]() M {
 	return (M)(nil)
 }
+
+func FoldMap[AS ~map[K]A, K comparable, A, B any](m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+	return func(f func(A) B) func(AS) B {
+		return Reduce[AS](func(cur B, a A) B {
+			return m.Concat(cur, f(a))
+		}, m.Empty())
+	}
+}
+
+func Fold[AS ~map[K]A, K comparable, A any](m Mo.Monoid[A]) func(AS) A {
+	return Reduce[AS](m.Concat, m.Empty())
+}
+
+func FoldMapWithIndex[AS ~map[K]A, K comparable, A, B any](m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+	return func(f func(K, A) B) func(AS) B {
+		return ReduceWithIndex[AS](func(k K, cur B, a A) B {
+			return m.Concat(cur, f(k, a))
+		}, m.Empty())
+	}
+}
+
+func ReduceOrdWithIndex[M ~map[K]V, K comparable, V, R any](o ord.Ord[K]) func(func(K, R, V) R, R) func(M) R {
+	return func(f func(K, R, V) R, initial R) func(M) R {
+		return func(m M) R {
+			return reduceOrd(o, m, f, initial)
+		}
+	}
+}
+
+func ReduceOrd[M ~map[K]V, K comparable, V, R any](o ord.Ord[K]) func(func(R, V) R, R) func(M) R {
+	ro := ReduceOrdWithIndex[M, K, V, R](o)
+	return func(f func(R, V) R, initial R) func(M) R {
+		return ro(F.Ignore1of3[K](f), initial)
+	}
+}
+
+func FoldMapOrd[AS ~map[K]A, K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+	red := ReduceOrd[AS, K, A, B](o)
+	return func(m Mo.Monoid[B]) func(func(A) B) func(AS) B {
+		return func(f func(A) B) func(AS) B {
+			return red(func(cur B, a A) B {
+				return m.Concat(cur, f(a))
+			}, m.Empty())
+		}
+	}
+}
+
+func FoldOrd[AS ~map[K]A, K comparable, A any](o ord.Ord[K]) func(m Mo.Monoid[A]) func(AS) A {
+	red := ReduceOrd[AS, K, A, A](o)
+	return func(m Mo.Monoid[A]) func(AS) A {
+		return red(m.Concat, m.Empty())
+	}
+}
+
+func FoldMapOrdWithIndex[AS ~map[K]A, K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+	red := ReduceOrdWithIndex[AS, K, A, B](o)
+	return func(m Mo.Monoid[B]) func(func(K, A) B) func(AS) B {
+		return func(f func(K, A) B) func(AS) B {
+			return red(func(k K, cur B, a A) B {
+				return m.Concat(cur, f(k, a))
+			}, m.Empty())
+		}
+	}
+}

record/generic/semigroup.go

@@ -20,8 +20,19 @@ import (
 )
 
 func UnionSemigroup[N ~map[K]V, K comparable, V any](s S.Semigroup[V]) S.Semigroup[N] {
-	union := Union[N, K, V](s)
 	return S.MakeSemigroup(func(first N, second N) N {
-		return union(second)(first)
+		return union[N, K, V](S.ToMagma(s), first, second)
+	})
+}
+
+func UnionLastSemigroup[N ~map[K]V, K comparable, V any]() S.Semigroup[N] {
+	return S.MakeSemigroup(func(first N, second N) N {
+		return unionLast[N, K, V](first, second)
+	})
+}
+
+func UnionFirstSemigroup[N ~map[K]V, K comparable, V any]() S.Semigroup[N] {
+	return S.MakeSemigroup(func(first N, second N) N {
+		return unionLast[N, K, V](second, first)
 	})
 }

record/monoid.go

@@ -21,6 +21,22 @@ import (
 	S "github.com/IBM/fp-go/semigroup"
 )
 
+// UnionMonoid computes the union of two maps of the same type
 func UnionMonoid[K comparable, V any](s S.Semigroup[V]) M.Monoid[map[K]V] {
 	return G.UnionMonoid[map[K]V](s)
 }
+
+// UnionLastMonoid computes the union of two maps of the same type giving the last map precedence
+func UnionLastMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionLastMonoid[map[K]V]()
+}
+
+// UnionFirstMonoid computes the union of two maps of the same type giving the first map precedence
+func UnionFirstMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionFirstMonoid[map[K]V]()
+}
+
+// MergeMonoid computes the union of two maps of the same type giving the last map precedence
+func MergeMonoid[K comparable, V any]() M.Monoid[map[K]V] {
+	return G.UnionLastMonoid[map[K]V]()
+}

record/record.go

@@ -17,27 +17,34 @@ package record
 
 import (
 	Mg "github.com/IBM/fp-go/magma"
+	Mo "github.com/IBM/fp-go/monoid"
 	O "github.com/IBM/fp-go/option"
+	"github.com/IBM/fp-go/ord"
 	G "github.com/IBM/fp-go/record/generic"
 	T "github.com/IBM/fp-go/tuple"
 )
 
+// IsEmpty tests if a map is empty
 func IsEmpty[K comparable, V any](r map[K]V) bool {
 	return G.IsEmpty(r)
 }
 
+// IsNonEmpty tests if a map is not empty
 func IsNonEmpty[K comparable, V any](r map[K]V) bool {
 	return G.IsNonEmpty(r)
 }
 
+// Keys returns the key in a map
 func Keys[K comparable, V any](r map[K]V) []K {
 	return G.Keys[map[K]V, []K](r)
 }
 
+// Values returns the values in a map
 func Values[K comparable, V any](r map[K]V) []V {
 	return G.Values[map[K]V, []V](r)
 }
 
+// Collect applies a collector function to the key value pairs in a map and returns the result as an array
 func Collect[K comparable, V, R any](f func(K, V) R) func(map[K]V) []R {
 	return G.Collect[map[K]V, []R](f)
 }
@@ -90,10 +97,12 @@ func MapRefWithIndex[K comparable, V, R any](f func(K, *V) R) func(map[K]V) map[
 	return G.MapRefWithIndex[map[K]V, map[K]R](f)
 }
 
-func Lookup[K comparable, V any](k K) func(map[K]V) O.Option[V] {
+// Lookup returns the entry for a key in a map if it exists
+func Lookup[V any, K comparable](k K) func(map[K]V) O.Option[V] {
 	return G.Lookup[map[K]V](k)
 }
 
+// Has tests if a key is contained in a map
 func Has[K comparable, V any](k K, r map[K]V) bool {
 	return G.Has(k, r)
 }
@@ -102,10 +111,17 @@ func Union[K comparable, V any](m Mg.Magma[V]) func(map[K]V) func(map[K]V) map[K
 	return G.Union[map[K]V](m)
 }
 
+// Merge combines two maps giving the values in the right one precedence. Also refer to [MergeMonoid]
+func Merge[K comparable, V any](right map[K]V) func(map[K]V) map[K]V {
+	return G.Merge[map[K]V](right)
+}
+
+// Empty creates an empty map
 func Empty[K comparable, V any]() map[K]V {
 	return G.Empty[map[K]V]()
 }
 
+// Size returns the number of elements in a map
 func Size[K comparable, V any](r map[K]V) int {
 	return G.Size(r)
 }
@@ -130,6 +146,7 @@ func DeleteAt[K comparable, V any](k K) func(map[K]V) map[K]V {
 	return G.DeleteAt[map[K]V](k)
 }
 
+// Singleton creates a new map with a single entry
 func Singleton[K comparable, V any](k K, v V) map[K]V {
 	return G.Singleton[map[K]V](k, v)
 }
@@ -168,3 +185,84 @@ func IsNonNil[K comparable, V any](m map[K]V) bool {
 func ConstNil[K comparable, V any]() map[K]V {
 	return (map[K]V)(nil)
 }
+
+func MonadChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(K, V1) map[K]V2) map[K]V2 {
+	return G.MonadChainWithIndex(m, r, f)
+}
+
+func MonadChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2], r map[K]V1, f func(V1) map[K]V2) map[K]V2 {
+	return G.MonadChain(m, r, f)
+}
+
+func ChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) map[K]V2) func(map[K]V1) map[K]V2 {
+	return G.ChainWithIndex[map[K]V1](m)
+}
+
+func Chain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) map[K]V2) func(map[K]V1) map[K]V2 {
+	return G.Chain[map[K]V1](m)
+}
+
+// Flatten converts a nested map into a regular map
+func Flatten[K comparable, V any](m Mo.Monoid[map[K]V]) func(map[K]map[K]V) map[K]V {
+	return G.Flatten[map[K]map[K]V](m)
+}
+
+// FilterChainWithIndex creates a new map with only the elements for which the transformation function creates a Some
+func FilterChainWithIndex[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(K, V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2 {
+	return G.FilterChainWithIndex[map[K]V1](m)
+}
+
+// FilterChain creates a new map with only the elements for which the transformation function creates a Some
+func FilterChain[V1 any, K comparable, V2 any](m Mo.Monoid[map[K]V2]) func(func(V1) O.Option[map[K]V2]) func(map[K]V1) map[K]V2 {
+	return G.FilterChain[map[K]V1](m)
+}
+
+// FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMap[K comparable, A, B any](m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B {
+	return G.FoldMap[map[K]A](m)
+}
+
+// FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid.
+func FoldMapWithIndex[K comparable, A, B any](m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B {
+	return G.FoldMapWithIndex[map[K]A](m)
+}
+
+// Fold folds the record using the provided Monoid.
+func Fold[K comparable, A any](m Mo.Monoid[A]) func(map[K]A) A {
+	return G.Fold[map[K]A](m)
+}
+
+// ReduceOrdWithIndex reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order
+func ReduceOrdWithIndex[V, R any, K comparable](o ord.Ord[K]) func(func(K, R, V) R, R) func(map[K]V) R {
+	return G.ReduceOrdWithIndex[map[K]V, K, V, R](o)
+}
+
+// ReduceOrd reduces a map into a single value via a reducer function making sure that the keys are passed to the reducer in the specified order
+func ReduceOrd[V, R any, K comparable](o ord.Ord[K]) func(func(R, V) R, R) func(map[K]V) R {
+	return G.ReduceOrd[map[K]V, K, V, R](o)
+}
+
+// FoldMap maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order
+func FoldMapOrd[A, B any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(A) B) func(map[K]A) B {
+	return G.FoldMapOrd[map[K]A, K, A, B](o)
+}
+
+// Fold folds the record using the provided Monoid with the items passed in the given order
+func FoldOrd[A any, K comparable](o ord.Ord[K]) func(m Mo.Monoid[A]) func(map[K]A) A {
+	return G.FoldOrd[map[K]A, K, A](o)
+}
+
+// FoldMapWithIndex maps and folds a record. Map the record passing each value to the iterating function. Then fold the results using the provided Monoid and the items in the provided order
+func FoldMapOrdWithIndex[K comparable, A, B any](o ord.Ord[K]) func(m Mo.Monoid[B]) func(func(K, A) B) func(map[K]A) B {
+	return G.FoldMapOrdWithIndex[map[K]A, K, A, B](o)
+}
+
+// KeysOrd returns the keys in the map in their given order
+func KeysOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []K {
+	return G.KeysOrd[map[K]V, []K, K, V](o)
+}
+
+// ValuesOrd returns the values in the map ordered by their keys in the given order
+func ValuesOrd[V any, K comparable](o ord.Ord[K]) func(r map[K]V) []V {
+	return G.ValuesOrd[map[K]V, []V, K, V](o)
+}

record/record_test.go

@@ -16,11 +16,14 @@
 package record
 
 import (
+	"fmt"
 	"sort"
+	"strings"
 	"testing"
 
 	"github.com/IBM/fp-go/internal/utils"
 	O "github.com/IBM/fp-go/option"
+	S "github.com/IBM/fp-go/string"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -68,6 +71,63 @@ func TestLookup(t *testing.T) {
 		"b": "b",
 		"c": "c",
 	}
-	assert.Equal(t, O.Some("a"), Lookup[string, string]("a")(data))
-	assert.Equal(t, O.None[string](), Lookup[string, string]("a1")(data))
+	assert.Equal(t, O.Some("a"), Lookup[string]("a")(data))
+	assert.Equal(t, O.None[string](), Lookup[string]("a1")(data))
+}
+
+func TestFilterChain(t *testing.T) {
+	src := map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	}
+
+	f := func(k string, value int) O.Option[map[string]string] {
+		if value%2 != 0 {
+			return O.Of(map[string]string{
+				k: fmt.Sprintf("%s%d", k, value),
+			})
+		}
+		return O.None[map[string]string]()
+	}
+
+	// monoid
+	monoid := MergeMonoid[string, string]()
+
+	res := FilterChainWithIndex[int](monoid)(f)(src)
+
+	assert.Equal(t, map[string]string{
+		"a": "a1",
+		"c": "c3",
+	}, res)
+}
+
+func ExampleFoldMap() {
+	src := map[string]string{
+		"a": "a",
+		"b": "b",
+		"c": "c",
+	}
+
+	fold := FoldMapOrd[string, string](S.Ord)(S.Monoid)(strings.ToUpper)
+
+	fmt.Println(fold(src))
+
+	// Output: ABC
+
+}
+
+func ExampleValuesOrd() {
+	src := map[string]string{
+		"c": "a",
+		"b": "b",
+		"a": "c",
+	}
+
+	getValues := ValuesOrd[string](S.Ord)
+
+	fmt.Println(getValues(src))
+
+	// Output: [c b a]
+
 }

record/semigroup.go

@@ -12,6 +12,7 @@
 // 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 record
 
 import (
@@ -22,3 +23,11 @@ import (
 func UnionSemigroup[K comparable, V any](s S.Semigroup[V]) S.Semigroup[map[K]V] {
 	return G.UnionSemigroup[map[K]V](s)
 }
+
+func UnionLastSemigroup[K comparable, V any]() S.Semigroup[map[K]V] {
+	return G.UnionLastSemigroup[map[K]V]()
+}
+
+func UnionFirstSemigroup[K comparable, V any]() S.Semigroup[map[K]V] {
+	return G.UnionFirstSemigroup[map[K]V]()
+}

reflect/generic/reflect.go

@@ -0,0 +1,31 @@
+// 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 generic
+
+import (
+	R "reflect"
+)
+
+func Map[GA ~[]A, A any](f func(R.Value) A) func(R.Value) GA {
+	return func(val R.Value) GA {
+		l := val.Len()
+		res := make(GA, l)
+		for i := l - 1; i >= 0; i-- {
+			res[i] = f(val.Index(i))
+		}
+		return res
+	}
+}

reflect/reflect.go

@@ -0,0 +1,42 @@
+// 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 option
+
+import (
+	R "reflect"
+
+	F "github.com/IBM/fp-go/function"
+	G "github.com/IBM/fp-go/reflect/generic"
+)
+
+func ReduceWithIndex[A any](f func(int, A, R.Value) A, initial A) func(R.Value) A {
+	return func(val R.Value) A {
+		count := val.Len()
+		current := initial
+		for i := 0; i < count; i++ {
+			current = f(i, current, val.Index(i))
+		}
+		return current
+	}
+}
+
+func Reduce[A any](f func(A, R.Value) A, initial A) func(R.Value) A {
+	return ReduceWithIndex(F.Ignore1of3[int](f), initial)
+}
+
+func Map[A any](f func(R.Value) A) func(R.Value) []A {
+	return G.Map[[]A](f)
+}

semigroup/semigroup.go

@@ -59,3 +59,8 @@ func First[A any]() Semigroup[A] {
 func Last[A any]() Semigroup[A] {
 	return MakeSemigroup(F.Second[A, A])
 }
+
+// ToMagma converts a semigroup to a magma
+func ToMagma[A any](s Semigroup[A]) M.Magma[A] {
+	return s
+}

tuple/gen.go

@@ -1,21 +1,7 @@
-// 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.
-
 // Code generated by go generate; DO NOT EDIT.
 // This file was generated by robots at
-// 2023-07-28 22:49:18.7141124 +0200 CEST m=+0.109464201
+// 2023-08-17 22:59:23.6923568 +0200 CEST m=+0.056359401
+
 package tuple
 
 import (
@@ -219,6 +205,13 @@ func FromArray1[F1 ~func(R) T1, T1, R any](f1 F1) func(r []R) Tuple1[T1] {
 	}
 }
 
+// Push1 creates a [Tuple2] from a [Tuple1] by appending a constant value
+func Push1[T1, T2 any](value T2) func(Tuple1[T1]) Tuple2[T1, T2] {
+	return func(t Tuple1[T1]) Tuple2[T1, T2] {
+		return MakeTuple2(t.F1, value)
+	}
+}
+
 // MakeTuple2 is a function that converts its 2 parameters into a [Tuple2]
 func MakeTuple2[T1, T2 any](t1 T1, t2 T2) Tuple2[T1, T2] {
 	return Tuple2[T1, T2]{t1, t2}
@@ -329,6 +322,13 @@ func FromArray2[F1 ~func(R) T1, F2 ~func(R) T2, T1, T2, R any](f1 F1, f2 F2) fun
 	}
 }
 
+// Push2 creates a [Tuple3] from a [Tuple2] by appending a constant value
+func Push2[T1, T2, T3 any](value T3) func(Tuple2[T1, T2]) Tuple3[T1, T2, T3] {
+	return func(t Tuple2[T1, T2]) Tuple3[T1, T2, T3] {
+		return MakeTuple3(t.F1, t.F2, value)
+	}
+}
+
 // MakeTuple3 is a function that converts its 3 parameters into a [Tuple3]
 func MakeTuple3[T1, T2, T3 any](t1 T1, t2 T2, t3 T3) Tuple3[T1, T2, T3] {
 	return Tuple3[T1, T2, T3]{t1, t2, t3}
@@ -450,6 +450,13 @@ func FromArray3[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, T1, T2, T3, R an
 	}
 }
 
+// Push3 creates a [Tuple4] from a [Tuple3] by appending a constant value
+func Push3[T1, T2, T3, T4 any](value T4) func(Tuple3[T1, T2, T3]) Tuple4[T1, T2, T3, T4] {
+	return func(t Tuple3[T1, T2, T3]) Tuple4[T1, T2, T3, T4] {
+		return MakeTuple4(t.F1, t.F2, t.F3, value)
+	}
+}
+
 // MakeTuple4 is a function that converts its 4 parameters into a [Tuple4]
 func MakeTuple4[T1, T2, T3, T4 any](t1 T1, t2 T2, t3 T3, t4 T4) Tuple4[T1, T2, T3, T4] {
 	return Tuple4[T1, T2, T3, T4]{t1, t2, t3, t4}
@@ -582,6 +589,13 @@ func FromArray4[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push4 creates a [Tuple5] from a [Tuple4] by appending a constant value
+func Push4[T1, T2, T3, T4, T5 any](value T5) func(Tuple4[T1, T2, T3, T4]) Tuple5[T1, T2, T3, T4, T5] {
+	return func(t Tuple4[T1, T2, T3, T4]) Tuple5[T1, T2, T3, T4, T5] {
+		return MakeTuple5(t.F1, t.F2, t.F3, t.F4, value)
+	}
+}
+
 // MakeTuple5 is a function that converts its 5 parameters into a [Tuple5]
 func MakeTuple5[T1, T2, T3, T4, T5 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5) Tuple5[T1, T2, T3, T4, T5] {
 	return Tuple5[T1, T2, T3, T4, T5]{t1, t2, t3, t4, t5}
@@ -725,6 +739,13 @@ func FromArray5[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push5 creates a [Tuple6] from a [Tuple5] by appending a constant value
+func Push5[T1, T2, T3, T4, T5, T6 any](value T6) func(Tuple5[T1, T2, T3, T4, T5]) Tuple6[T1, T2, T3, T4, T5, T6] {
+	return func(t Tuple5[T1, T2, T3, T4, T5]) Tuple6[T1, T2, T3, T4, T5, T6] {
+		return MakeTuple6(t.F1, t.F2, t.F3, t.F4, t.F5, value)
+	}
+}
+
 // MakeTuple6 is a function that converts its 6 parameters into a [Tuple6]
 func MakeTuple6[T1, T2, T3, T4, T5, T6 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) Tuple6[T1, T2, T3, T4, T5, T6] {
 	return Tuple6[T1, T2, T3, T4, T5, T6]{t1, t2, t3, t4, t5, t6}
@@ -879,6 +900,13 @@ func FromArray6[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push6 creates a [Tuple7] from a [Tuple6] by appending a constant value
+func Push6[T1, T2, T3, T4, T5, T6, T7 any](value T7) func(Tuple6[T1, T2, T3, T4, T5, T6]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+	return func(t Tuple6[T1, T2, T3, T4, T5, T6]) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
+		return MakeTuple7(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, value)
+	}
+}
+
 // MakeTuple7 is a function that converts its 7 parameters into a [Tuple7]
 func MakeTuple7[T1, T2, T3, T4, T5, T6, T7 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7) Tuple7[T1, T2, T3, T4, T5, T6, T7] {
 	return Tuple7[T1, T2, T3, T4, T5, T6, T7]{t1, t2, t3, t4, t5, t6, t7}
@@ -1044,6 +1072,13 @@ func FromArray7[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push7 creates a [Tuple8] from a [Tuple7] by appending a constant value
+func Push7[T1, T2, T3, T4, T5, T6, T7, T8 any](value T8) func(Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+	return func(t Tuple7[T1, T2, T3, T4, T5, T6, T7]) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
+		return MakeTuple8(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, value)
+	}
+}
+
 // MakeTuple8 is a function that converts its 8 parameters into a [Tuple8]
 func MakeTuple8[T1, T2, T3, T4, T5, T6, T7, T8 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8) Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] {
 	return Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]{t1, t2, t3, t4, t5, t6, t7, t8}
@@ -1220,6 +1255,13 @@ func FromArray8[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push8 creates a [Tuple9] from a [Tuple8] by appending a constant value
+func Push8[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](value T9) func(Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+	return func(t Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
+		return MakeTuple9(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, value)
+	}
+}
+
 // MakeTuple9 is a function that converts its 9 parameters into a [Tuple9]
 func MakeTuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9) Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] {
 	return Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]{t1, t2, t3, t4, t5, t6, t7, t8, t9}
@@ -1407,6 +1449,13 @@ func FromArray9[F1 ~func(R) T1, F2 ~func(R) T2, F3 ~func(R) T3, F4 ~func(R) T4,
 	}
 }
 
+// Push9 creates a [Tuple10] from a [Tuple9] by appending a constant value
+func Push9[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](value T10) func(Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+	return func(t Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
+		return MakeTuple10(t.F1, t.F2, t.F3, t.F4, t.F5, t.F6, t.F7, t.F8, t.F9, value)
+	}
+}
+
 // MakeTuple10 is a function that converts its 10 parameters into a [Tuple10]
 func MakeTuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 any](t1 T1, t2 T2, t3 T3, t4 T4, t5 T5, t6 T6, t7 T7, t8 T8, t9 T9, t10 T10) Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] {
 	return Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]{t1, t2, t3, t4, t5, t6, t7, t8, t9, t10}

tuple/tuple.go

@@ -17,6 +17,10 @@
 // consider to use arrays for simplicity
 package tuple
 
+func Of[T1 any](t T1) Tuple1[T1] {
+	return MakeTuple1(t)
+}
+
 func First[T1, T2 any](t Tuple2[T1, T2]) T1 {
 	return t.F1
 }
@@ -29,7 +33,7 @@ func Swap[T1, T2 any](t Tuple2[T1, T2]) Tuple2[T2, T1] {
 	return MakeTuple2(t.F2, t.F1)
 }
 
-func Of[T1, T2 any](e T2) func(T1) Tuple2[T1, T2] {
+func Of2[T1, T2 any](e T2) func(T1) Tuple2[T1, T2] {
 	return func(t T1) Tuple2[T1, T2] {
 		return MakeTuple2(t, e)
 	}

writer/writer_test.go

@@ -31,7 +31,7 @@ func doubleAndLog(data int) Writer[[]string, int] {
 	}
 }
 
-func ExampleLoggingWriter() {
+func ExampleWriter_logging() {
 
 	m := A.Monoid[string]()
 	s := M.ToSemigroup(m)