go/fp-go
1
0
Fork 0
mirror of https://github.com/IBM/fp-go.git synced 2025-11-23 22:14:53 +02:00
Code Issues Releases Activity

fix: refactor

Browse Source 
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
2025-11-11 11:01:49 +01:00
parent 62fcd186a3
commit 600521b220
100 changed files with 1786 additions and 1618 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
v2/README.md
View File

@@ -269,7 +269,7 @@ import (
func process() IOET.IOEither[error, string] {
return IOEG.Map[error, int, string](
func(x int) string { return fmt.Sprintf("%d", x) },
strconv.Itoa,
)(fetchData())
}
```
@@ -285,7 +285,7 @@ type IOEither[A any] = ioeither.IOEither[error, A]
func process() IOEither[string] {
return ioeither.Map(
func(x int) string { return fmt.Sprintf("%d", x) },
strconv.Itoa,
)(fetchData())
}
```

16
v2/array/array.go
View File

@@ -82,7 +82,7 @@ func MapWithIndex[A, B any](f func(int, A) B) func([]A) []B {
//
//go:inline
func Map[A, B any](f func(a A) B) func([]A) []B {
return G.Map[[]A, []B, A, B](f)
return G.Map[[]A, []B](f)
}
// MapRef applies a function to a pointer to each element of an array, returning a new array with the results.
@@ -278,7 +278,7 @@ func Of[A any](a A) []A {
//
//go:inline
func MonadChain[A, B any](fa []A, f func(a A) []B) []B {
return G.MonadChain[[]A, []B](fa, f)
return G.MonadChain(fa, f)
}
// Chain applies a function that returns an array to each element and flattens the results.
@@ -291,7 +291,7 @@ func MonadChain[A, B any](fa []A, f func(a A) []B) []B {
//
//go:inline
func Chain[A, B any](f func(A) []B) func([]A) []B {
return G.Chain[[]A, []B](f)
return G.Chain[[]A](f)
}
// MonadAp applies an array of functions to an array of values, producing all combinations.
@@ -314,14 +314,14 @@ func Ap[B, A any](fa []A) func([]func(A) B) []B {
//
//go:inline
func Match[A, B any](onEmpty func() B, onNonEmpty func([]A) B) func([]A) B {
return G.Match[[]A](onEmpty, onNonEmpty)
return G.Match(onEmpty, onNonEmpty)
}
// MatchLeft performs pattern matching on an array, calling onEmpty if empty or onNonEmpty with head and tail if not.
//
//go:inline
func MatchLeft[A, B any](onEmpty func() B, onNonEmpty func(A, []A) B) func([]A) B {
return G.MatchLeft[[]A](onEmpty, onNonEmpty)
return G.MatchLeft(onEmpty, onNonEmpty)
}
// Tail returns all elements except the first, wrapped in an Option.
@@ -390,7 +390,7 @@ func Intersperse[A any](middle A) EM.Endomorphism[[]A] {
// Intercalate inserts a separator between elements and concatenates them using a Monoid.
func Intercalate[A any](m M.Monoid[A]) func(A) func([]A) A {
return func(middle A) func([]A) A {
return Match(m.Empty, F.Flow2(Intersperse(middle), ConcatAll[A](m)))
return Match(m.Empty, F.Flow2(Intersperse(middle), ConcatAll(m)))
}
}
@@ -519,7 +519,7 @@ func Push[A any](a A) EM.Endomorphism[[]A] {
//
//go:inline
func MonadFlap[B, A any](fab []func(A) B, a A) []B {
return G.MonadFlap[func(A) B, []func(A) B, []B, A, B](fab, a)
return G.MonadFlap[func(A) B, []func(A) B, []B](fab, a)
}
// Flap applies a value to an array of functions, producing an array of results.
@@ -527,7 +527,7 @@ func MonadFlap[B, A any](fab []func(A) B, a A) []B {
//
//go:inline
func Flap[B, A any](a A) func([]func(A) B) []B {
return G.Flap[func(A) B, []func(A) B, []B, A, B](a)
return G.Flap[func(A) B, []func(A) B, []B](a)
}
// Prepend adds an element to the beginning of an array, returning a new array.

2
v2/array/array_test.go
View File

@@ -97,7 +97,7 @@ func TestAp(t *testing.T) {
utils.Double,
utils.Triple,
},
Ap[int, int]([]int{1, 2, 3}),
Ap[int]([]int{1, 2, 3}),
),
)
}

12
v2/array/bind.go
View File

@@ -34,7 +34,7 @@ import (
func Do[S any](
empty S,
) []S {
return G.Do[[]S, S](empty)
return G.Do[[]S](empty)
}
// Bind attaches the result of a computation to a context S1 to produce a context S2.
@@ -58,7 +58,7 @@ func Bind[S1, S2, T any](
setter func(T) func(S1) S2,
f func(S1) []T,
) func([]S1) []S2 {
return G.Bind[[]S1, []S2, []T, S1, S2, T](setter, f)
return G.Bind[[]S1, []S2](setter, f)
}
// Let attaches the result of a pure computation to a context S1 to produce a context S2.
@@ -80,7 +80,7 @@ func Let[S1, S2, T any](
setter func(T) func(S1) S2,
f func(S1) T,
) func([]S1) []S2 {
return G.Let[[]S1, []S2, S1, S2, T](setter, f)
return G.Let[[]S1, []S2](setter, f)
}
// LetTo attaches a constant value to a context S1 to produce a context S2.
@@ -102,7 +102,7 @@ func LetTo[S1, S2, T any](
setter func(T) func(S1) S2,
b T,
) func([]S1) []S2 {
return G.LetTo[[]S1, []S2, S1, S2, T](setter, b)
return G.LetTo[[]S1, []S2](setter, b)
}
// BindTo initializes a new state S1 from a value T.
@@ -121,7 +121,7 @@ func LetTo[S1, S2, T any](
func BindTo[S1, T any](
setter func(T) S1,
) func([]T) []S1 {
return G.BindTo[[]S1, []T, S1, T](setter)
return G.BindTo[[]S1, []T](setter)
}
// ApS attaches a value to a context S1 to produce a context S2 by considering
@@ -144,5 +144,5 @@ func ApS[S1, S2, T any](
setter func(T) func(S1) S2,
fa []T,
) func([]S1) []S2 {
return G.ApS[[]S1, []S2, []T, S1, S2, T](setter, fa)
return G.ApS[[]S1, []S2](setter, fa)
}

8
v2/array/generic/array.go
View File

@@ -31,25 +31,25 @@ func Of[GA ~[]A, A any](value A) GA {
func Reduce[GA ~[]A, A, B any](f func(B, A) B, initial B) func(GA) B {
return func(as GA) B {
return MonadReduce[GA](as, f, initial)
return MonadReduce(as, f, initial)
}
}
func ReduceWithIndex[GA ~[]A, A, B any](f func(int, B, A) B, initial B) func(GA) B {
return func(as GA) B {
return MonadReduceWithIndex[GA](as, f, initial)
return MonadReduceWithIndex(as, f, initial)
}
}
func ReduceRight[GA ~[]A, A, B any](f func(A, B) B, initial B) func(GA) B {
return func(as GA) B {
return MonadReduceRight[GA](as, f, initial)
return MonadReduceRight(as, f, initial)
}
}
func ReduceRightWithIndex[GA ~[]A, A, B any](f func(int, A, B) B, initial B) func(GA) B {
return func(as GA) B {
return MonadReduceRightWithIndex[GA](as, f, initial)
return MonadReduceRightWithIndex(as, f, initial)
}
}

8
v2/array/generic/monad.go
View File

@@ -22,19 +22,19 @@ import (
type arrayMonad[A, B any, GA ~[]A, GB ~[]B, GAB ~[]func(A) B] struct{}
func (o *arrayMonad[A, B, GA, GB, GAB]) Of(a A) GA {
return Of[GA, A](a)
return Of[GA](a)
}
func (o *arrayMonad[A, B, GA, GB, GAB]) Map(f func(A) B) func(GA) GB {
return Map[GA, GB, A, B](f)
return Map[GA, GB](f)
}
func (o *arrayMonad[A, B, GA, GB, GAB]) Chain(f func(A) GB) func(GA) GB {
return Chain[GA, GB, A, B](f)
return Chain[GA](f)
}
func (o *arrayMonad[A, B, GA, GB, GAB]) Ap(fa GA) func(GAB) GB {
return Ap[GB, GAB, GA, B, A](fa)
return Ap[GB, GAB](fa)
}
// Monad implements the monadic operations for an array

4
v2/array/nonempty/array.go
View File

@@ -97,11 +97,11 @@ func Flatten[A any](mma NonEmptyArray[NonEmptyArray[A]]) NonEmptyArray[A] {
}
func MonadChain[A, B any](fa NonEmptyArray[A], f func(a A) NonEmptyArray[B]) NonEmptyArray[B] {
return G.MonadChain[NonEmptyArray[A], NonEmptyArray[B]](fa, f)
return G.MonadChain(fa, f)
}
func Chain[A, B any](f func(A) NonEmptyArray[B]) func(NonEmptyArray[A]) NonEmptyArray[B] {
return G.Chain[NonEmptyArray[A], NonEmptyArray[B]](f)
return G.Chain[NonEmptyArray[A]](f)
}
func MonadAp[B, A any](fab NonEmptyArray[func(A) B], fa NonEmptyArray[A]) NonEmptyArray[B] {

2
v2/array/sort.go
View File

@@ -94,5 +94,5 @@ func SortByKey[K, T any](ord O.Ord[K], f func(T) K) func(ma []T) []T {
//
//go:inline
func SortBy[T any](ord []O.Ord[T]) func(ma []T) []T {
return G.SortBy[[]T, []O.Ord[T]](ord)
return G.SortBy[[]T](ord)
}

2
v2/array/uniq.go
View File

@@ -18,7 +18,7 @@ import (
//
//go:inline
func StrictUniq[A comparable](as []A) []A {
return G.StrictUniq[[]A](as)
return G.StrictUniq(as)
}
// Uniq converts an array of arbitrary items into an array of unique items

4
v2/array/zip.go
View File

@@ -36,7 +36,7 @@ import (
//
//go:inline
func ZipWith[FCT ~func(A, B) C, A, B, C any](fa []A, fb []B, f FCT) []C {
return G.ZipWith[[]A, []B, []C, FCT](fa, fb, f)
return G.ZipWith[[]A, []B, []C](fa, fb, f)
}
// Zip takes two arrays and returns an array of corresponding pairs (tuples).
@@ -79,5 +79,5 @@ func Zip[A, B any](fb []B) func([]A) []T.Tuple2[A, B] {
//
//go:inline
func Unzip[A, B any](cs []T.Tuple2[A, B]) T.Tuple2[[]A, []B] {
return G.Unzip[[]A, []B, []T.Tuple2[A, B]](cs)
return G.Unzip[[]A, []B](cs)
}

2
v2/bounded/bounded.go
View File

@@ -53,7 +53,7 @@ func MakeBounded[T any](o ord.Ord[T], t, b T) Bounded[T] {
// Clamp returns a function that clamps against the bounds defined in the bounded type
func Clamp[T any](b Bounded[T]) func(T) T {
return ord.Clamp[T](b)(b.Bottom(), b.Top())
return ord.Clamp(b)(b.Bottom(), b.Top())
}
// Reverse reverses the ordering and swaps the bounds

2
v2/constant/const_test.go
View File

@@ -27,7 +27,7 @@ import (
func TestMap(t *testing.T) {
fa := Make[string, int]("foo")
assert.Equal(t, fa, F.Pipe1(fa, Map[string, int](utils.Double)))
assert.Equal(t, fa, F.Pipe1(fa, Map[string](utils.Double)))
}
func TestOf(t *testing.T) {

11
v2/context/ioeither/ioeither.go → v2/context/ioresult/ioeither.go
View File

@@ -13,20 +13,19 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package ioeither
package ioresult
import (
"context"
"github.com/IBM/fp-go/v2/either"
IOE "github.com/IBM/fp-go/v2/ioeither"
"github.com/IBM/fp-go/v2/result"
)
// withContext wraps an existing IOEither and performs a context check for cancellation before delegating
func WithContext[A any](ctx context.Context, ma IOE.IOEither[error, A]) IOE.IOEither[error, A] {
return func() either.Either[error, A] {
func WithContext[A any](ctx context.Context, ma IOResult[A]) IOResult[A] {
return func() Result[A] {
if err := context.Cause(ctx); err != nil {
return either.Left[A](err)
return result.Left[A](err)
}
return ma()
}

11
v2/context/ioresult/types.go Normal file
View File

@@ -0,0 +1,11 @@
package ioresult
import (
"github.com/IBM/fp-go/v2/ioresult"
"github.com/IBM/fp-go/v2/result"
)
type (
IOResult[T any] = ioresult.IOResult[T]
Result[T any] = result.Result[T]
)

251
v2/context/readerioeither/coverage.out
View File

@@ -1,251 +0,0 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:27.21,29.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:35.47,42.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:48.47,54.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:60.47,66.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:71.46,76.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/bind.go:82.47,89.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/bracket.go:33.21,44.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/cancel.go:35.65,36.47 1 1
github.com/IBM/fp-go/v2/context/readerioeither/cancel.go:36.47,37.44 1 1
github.com/IBM/fp-go/v2/context/readerioeither/cancel.go:37.44,39.4 1 1
github.com/IBM/fp-go/v2/context/readerioeither/cancel.go:40.3,40.40 1 1
github.com/IBM/fp-go/v2/context/readerioeither/eq.go:42.84,44.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:18.91,20.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:24.93,26.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:30.101,32.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:36.103,38.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:43.36,48.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:53.36,58.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:63.36,68.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:71.98,76.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:79.101,84.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:87.101,92.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:95.129,96.68 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:96.68,102.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:106.132,107.68 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:107.68,113.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:117.132,118.68 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:118.68,124.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:129.113,131.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:135.115,137.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:143.40,150.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:156.40,163.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:169.40,176.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:179.126,185.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:188.129,194.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:197.129,203.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:206.185,207.76 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:207.76,215.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:219.188,220.76 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:220.76,228.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:232.188,233.76 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:233.76,241.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:246.125,248.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:252.127,254.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:261.44,270.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:277.44,286.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:293.44,302.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:305.154,312.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:315.157,322.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:325.157,332.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:335.241,336.84 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:336.84,346.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:350.244,351.84 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:351.84,361.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:365.244,366.84 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:366.84,376.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:381.137,383.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:387.139,389.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:397.48,408.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:416.48,427.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:435.48,446.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:449.182,457.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:460.185,468.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:471.185,479.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:482.297,483.92 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:483.92,495.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:499.300,500.92 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:500.92,512.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:516.300,517.92 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:517.92,529.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:534.149,536.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:540.151,542.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:551.52,564.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:573.52,586.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:595.52,608.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:611.210,620.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:623.213,632.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:635.213,644.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:647.353,648.100 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:648.100,662.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:666.356,667.100 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:667.100,681.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:685.356,686.100 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:686.100,700.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:705.161,707.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:711.163,713.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:723.56,738.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:748.56,763.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:773.56,788.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:791.238,801.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:804.241,814.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:817.241,827.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:830.409,831.108 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:831.108,847.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:851.412,852.108 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:852.108,868.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:872.412,873.108 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:873.108,889.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:894.173,896.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:900.175,902.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:913.60,930.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:941.60,958.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:969.60,986.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:989.266,1000.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1003.269,1014.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1017.269,1028.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1031.465,1032.116 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1032.116,1050.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1054.468,1055.116 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1055.116,1073.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1077.468,1078.116 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1078.116,1096.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1101.185,1103.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1107.187,1109.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1121.64,1140.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1152.64,1171.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1183.64,1202.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1205.294,1217.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1220.297,1232.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1235.297,1247.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1250.521,1251.124 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1251.124,1271.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1275.524,1276.124 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1276.124,1296.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1300.524,1301.124 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1301.124,1321.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1326.197,1328.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1332.199,1334.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1347.68,1368.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1381.68,1402.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1415.68,1436.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1439.322,1452.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1455.325,1468.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1471.325,1484.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1487.577,1488.132 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1488.132,1510.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1514.580,1515.132 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1515.132,1537.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1541.580,1542.132 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1542.132,1564.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1569.210,1571.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1575.212,1577.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1591.74,1614.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1628.74,1651.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1665.74,1688.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1691.356,1705.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1708.359,1722.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1725.359,1739.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1742.645,1743.144 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1743.144,1767.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1771.648,1772.144 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1772.144,1796.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1800.648,1801.144 1 0
github.com/IBM/fp-go/v2/context/readerioeither/gen.go:1801.144,1825.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/monoid.go:36.61,43.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/monoid.go:52.64,59.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/monoid.go:68.64,75.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/monoid.go:85.61,93.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/monoid.go:103.63,108.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:42.55,44.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:52.45,54.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:62.42,64.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:74.78,76.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:85.75,87.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:97.72,99.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:108.69,110.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:120.96,122.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:131.93,133.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:143.101,145.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:154.71,156.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:165.39,167.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:169.93,173.56 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:173.56,174.32 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:174.32,174.47 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:189.98,194.47 3 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:194.47,196.44 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:196.44,198.4 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:200.3,200.27 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:200.27,202.45 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:202.45,204.5 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:207.4,213.47 5 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:227.95,229.17 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:229.17,231.3 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:232.2,232.28 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:243.98,245.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:254.91,256.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:265.94,267.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:276.94,278.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:288.95,290.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:299.73,301.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:307.44,309.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:319.95,321.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:330.95,332.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:342.100,344.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:353.100,355.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:364.116,366.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:375.75,377.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:386.47,388.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:398.51,400.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:406.39,407.47 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:407.47,408.27 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:408.27,411.4 2 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:423.87,425.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:434.87,436.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:446.92,448.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:457.92,459.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:468.115,470.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:479.85,480.54 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:480.54,481.48 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:481.48,482.28 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:482.28,487.12 3 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:488.30,489.22 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:490.23,491.47 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:505.59,511.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:520.66,522.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:531.83,533.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:543.97,545.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:554.64,556.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:566.62,568.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:577.78,579.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:589.80,591.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:600.76,602.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:612.136,614.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:623.91,625.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/reader.go:634.71,636.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/resource.go:58.151,63.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/semigroup.go:39.41,43.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/sync.go:46.78,54.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:31.89,39.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:48.103,56.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:65.71,67.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:75.112,83.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:92.124,100.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:108.94,110.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:120.95,128.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:137.92,145.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:148.106,156.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:165.74,167.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:170.118,178.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:181.115,189.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:192.127,200.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:203.97,205.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:215.95,223.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:232.92,240.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:243.106,251.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:260.74,262.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:265.115,273.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:276.127,284.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:287.118,295.2 1 0
github.com/IBM/fp-go/v2/context/readerioeither/traverse.go:304.97,306.2 1 0

15
v2/context/readerioeither/http/builder/coverage.out
View File

@@ -1,15 +0,0 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:117.52,119.103 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:119.103,120.80 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:120.80,121.41 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:121.41,123.19 2 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:123.19,126.6 2 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:127.5,127.20 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:132.2,132.93 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:132.93,133.80 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:133.80,134.41 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:134.41,136.19 2 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:136.19,138.6 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:139.5,139.20 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:144.2,150.50 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/builder/builder.go:150.50,153.4 2 1

11
v2/context/readerioeither/http/coverage.out
View File

@@ -1,11 +0,0 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:111.76,116.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:134.49,136.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:161.90,162.65 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:162.65,166.76 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:166.76,176.5 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:198.73,203.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:222.74,227.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:234.76,236.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:245.74,254.2 1 1
github.com/IBM/fp-go/v2/context/readerioeither/http/request.go:281.76,286.2 1 1

6
v2/context/readerioeither/BENCHMARKS.md → v2/context/readerioresult/BENCHMARKS.md
View File

@@ -1,4 +1,4 @@
# ReaderIOEither Benchmarks
# ReaderIOResult Benchmarks
This document describes the benchmark suite for the `context/readerioeither` package and how to interpret the results to identify performance bottlenecks.
@@ -35,8 +35,8 @@ go test -bench=. -benchmem -benchtime=100000x
- Construction is very fast, suitable for hot paths
### 2. Conversion Operations
- `BenchmarkFromEither_Right/Left` - Converting Either to ReaderIOEither (~70ns, 2 allocs)
- `BenchmarkFromIO` - Converting IO to ReaderIOEither (~78ns, 3 allocs)
- `BenchmarkFromEither_Right/Left` - Converting Either to ReaderIOResult (~70ns, 2 allocs)
- `BenchmarkFromIO` - Converting IO to ReaderIOResult (~78ns, 3 allocs)
- `BenchmarkFromIOEither_Right/Left` - Converting IOEither (~23ns, 1 alloc)
**Key Insights:**

63
v2/context/readerioeither/bind.go → v2/context/readerioresult/bind.go
View File

@@ -13,13 +13,14 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
L "github.com/IBM/fp-go/v2/optics/lens"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
)
// Do creates an empty context of type [S] to be used with the [Bind] operation.
@@ -36,8 +37,8 @@ import (
//go:inline
func Do[S any](
empty S,
) ReaderIOEither[S] {
return Of(empty)
) ReaderIOResult[S] {
return RIOR.Of[context.Context](empty)
}
// Bind attaches the result of a computation to a context [S1] to produce a context [S2].
@@ -60,7 +61,7 @@ func Do[S any](
// func(user User) func(State) State {
// return func(s State) State { s.User = user; return s }
// },
// func(s State) readerioeither.ReaderIOEither[User] {
// func(s State) readerioeither.ReaderIOResult[User] {
// return func(ctx context.Context) ioeither.IOEither[error, User] {
// return ioeither.TryCatch(func() (User, error) {
// return fetchUser(ctx)
@@ -72,7 +73,7 @@ func Do[S any](
// func(cfg Config) func(State) State {
// return func(s State) State { s.Config = cfg; return s }
// },
// func(s State) readerioeither.ReaderIOEither[Config] {
// func(s State) readerioeither.ReaderIOResult[Config] {
// // This can access s.User from the previous step
// return func(ctx context.Context) ioeither.IOEither[error, Config] {
// return ioeither.TryCatch(func() (Config, error) {
@@ -88,12 +89,7 @@ func Bind[S1, S2, T any](
setter func(T) func(S1) S2,
f Kleisli[S1, T],
) Operator[S1, S2] {
return chain.Bind(
Chain[S1, S2],
Map[T, S2],
setter,
f,
)
return RIOR.Bind[context.Context](setter, f)
}
// Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -103,11 +99,7 @@ func Let[S1, S2, T any](
setter func(T) func(S1) S2,
f func(S1) T,
) Operator[S1, S2] {
return functor.Let(
Map[S1, S2],
setter,
f,
)
return RIOR.Let[context.Context](setter, f)
}
// LetTo attaches the a value to a context [S1] to produce a context [S2]
@@ -117,11 +109,7 @@ func LetTo[S1, S2, T any](
setter func(T) func(S1) S2,
b T,
) Operator[S1, S2] {
return functor.LetTo(
Map[S1, S2],
setter,
b,
)
return RIOR.LetTo[context.Context](setter, b)
}
// BindTo initializes a new state [S1] from a value [T]
@@ -130,10 +118,7 @@ func LetTo[S1, S2, T any](
func BindTo[S1, T any](
setter func(T) S1,
) Operator[T, S1] {
return chain.BindTo(
Map[T, S1],
setter,
)
return RIOR.BindTo[context.Context](setter)
}
// ApS attaches a value to a context [S1] to produce a context [S2] by considering
@@ -181,11 +166,11 @@ func BindTo[S1, T any](
//go:inline
func ApS[S1, S2, T any](
setter func(T) func(S1) S2,
fa ReaderIOEither[T],
fa ReaderIOResult[T],
) Operator[S1, S2] {
return apply.ApS(
Ap[S2, T],
Map[S1, func(T) S2],
Ap,
Map,
setter,
fa,
)
@@ -223,7 +208,7 @@ func ApS[S1, S2, T any](
//go:inline
func ApSL[S, T any](
lens L.Lens[S, T],
fa ReaderIOEither[T],
fa ReaderIOResult[T],
) Operator[S, S] {
return ApS(lens.Set, fa)
}
@@ -234,7 +219,7 @@ func ApSL[S, T any](
//
// The lens parameter provides both a getter and setter for a field of type T within
// the context S. The function f receives the current value of the focused field and
// returns a ReaderIOEither computation that produces an updated value.
// returns a ReaderIOResult computation that produces an updated value.
//
// Example:
//
@@ -250,7 +235,7 @@ func ApSL[S, T any](
//
// result := F.Pipe2(
// readerioeither.Do(State{}),
// readerioeither.BindL(userLens, func(user User) readerioeither.ReaderIOEither[User] {
// readerioeither.BindL(userLens, func(user User) readerioeither.ReaderIOResult[User] {
// return func(ctx context.Context) ioeither.IOEither[error, User] {
// return ioeither.TryCatch(func() (User, error) {
// return fetchUser(ctx)
@@ -264,9 +249,7 @@ func BindL[S, T any](
lens L.Lens[S, T],
f Kleisli[T, T],
) Operator[S, S] {
return Bind[S, S, T](lens.Set, func(s S) ReaderIOEither[T] {
return f(lens.Get(s))
})
return RIOR.BindL[context.Context](lens, f)
}
// LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -275,7 +258,7 @@ func BindL[S, T any](
//
// The lens parameter provides both a getter and setter for a field of type T within
// the context S. The function f receives the current value of the focused field and
// returns a new value (without wrapping in a ReaderIOEither).
// returns a new value (without wrapping in a ReaderIOResult).
//
// Example:
//
@@ -302,9 +285,7 @@ func LetL[S, T any](
lens L.Lens[S, T],
f func(T) T,
) Operator[S, S] {
return Let[S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return RIOR.LetL[context.Context](lens, f)
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context.
@@ -337,5 +318,5 @@ func LetToL[S, T any](
lens L.Lens[S, T],
b T,
) Operator[S, S] {
return LetTo[S, S, T](lens.Set, b)
return RIOR.LetToL[context.Context](lens, b)
}

8
v2/context/readerioeither/bind_test.go → v2/context/readerioresult/bind_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -26,11 +26,11 @@ import (
"github.com/stretchr/testify/assert"
)
func getLastName(s utils.Initial) ReaderIOEither[string] {
func getLastName(s utils.Initial) ReaderIOResult[string] {
return Of("Doe")
}
func getGivenName(s utils.WithLastName) ReaderIOEither[string] {
func getGivenName(s utils.WithLastName) ReaderIOResult[string] {
return Of("John")
}
@@ -229,7 +229,7 @@ func TestApS_ChainedWithBind(t *testing.T) {
}
}
getDependentValue := func(s State) ReaderIOEither[string] {
getDependentValue := func(s State) ReaderIOResult[string] {
// This depends on the Independent field
return Of(s.Independent + "-dependent")
}

24
v2/context/readerioeither/bracket.go → v2/context/readerioresult/bracket.go
View File

@@ -13,13 +13,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
"github.com/IBM/fp-go/v2/internal/bracket"
"github.com/IBM/fp-go/v2/readerio"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
)
// Bracket makes sure that a resource is cleaned up in the event of an error. The release action is called regardless of
@@ -27,18 +24,9 @@ import (
func Bracket[
A, B, ANY any](
acquire ReaderIOEither[A],
acquire ReaderIOResult[A],
use Kleisli[A, B],
release func(A, Either[B]) ReaderIOEither[ANY],
) ReaderIOEither[B] {
return bracket.Bracket[ReaderIOEither[A], ReaderIOEither[B], ReaderIOEither[ANY], Either[B], A, B](
readerio.Of[context.Context, Either[B]],
MonadChain[A, B],
readerio.MonadChain[context.Context, Either[B], Either[B]],
MonadChain[ANY, B],
acquire,
use,
release,
)
release func(A, Either[B]) ReaderIOResult[ANY],
) ReaderIOResult[B] {
return RIOR.Bracket(acquire, use, release)
}

12
v2/context/readerioeither/cancel.go → v2/context/readerioresult/cancel.go
View File

@@ -13,26 +13,26 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
CIOE "github.com/IBM/fp-go/v2/context/ioeither"
CIOE "github.com/IBM/fp-go/v2/context/ioresult"
"github.com/IBM/fp-go/v2/ioeither"
)
// WithContext wraps an existing [ReaderIOEither] and performs a context check for cancellation before delegating.
// WithContext wraps an existing [ReaderIOResult] and performs a context check for cancellation before delegating.
// This ensures that if the context is already canceled, the computation short-circuits immediately
// without executing the wrapped computation.
//
// This is useful for adding cancellation awareness to computations that might not check the context themselves.
//
// Parameters:
// - ma: The ReaderIOEither to wrap with context checking
// - ma: The ReaderIOResult to wrap with context checking
//
// Returns a ReaderIOEither that checks for cancellation before executing.
func WithContext[A any](ma ReaderIOEither[A]) ReaderIOEither[A] {
// Returns a ReaderIOResult that checks for cancellation before executing.
func WithContext[A any](ma ReaderIOResult[A]) ReaderIOResult[A] {
return func(ctx context.Context) IOEither[A] {
if err := context.Cause(ctx); err != nil {
return ioeither.Left[A](err)

251
v2/context/readerioresult/coverage.out Normal file
View File

@@ -0,0 +1,251 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:27.21,29.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:35.47,42.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:48.47,54.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:60.47,66.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:71.46,76.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/bind.go:82.47,89.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/bracket.go:33.21,44.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/cancel.go:35.65,36.47 1 1
github.com/IBM/fp-go/v2/context/readerioresult/cancel.go:36.47,37.44 1 1
github.com/IBM/fp-go/v2/context/readerioresult/cancel.go:37.44,39.4 1 1
github.com/IBM/fp-go/v2/context/readerioresult/cancel.go:40.3,40.40 1 1
github.com/IBM/fp-go/v2/context/readerioresult/eq.go:42.84,44.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:18.91,20.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:24.93,26.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:30.101,32.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:36.103,38.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:43.36,48.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:53.36,58.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:63.36,68.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:71.98,76.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:79.101,84.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:87.101,92.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:95.129,96.68 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:96.68,102.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:106.132,107.68 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:107.68,113.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:117.132,118.68 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:118.68,124.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:129.113,131.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:135.115,137.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:143.40,150.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:156.40,163.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:169.40,176.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:179.126,185.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:188.129,194.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:197.129,203.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:206.185,207.76 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:207.76,215.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:219.188,220.76 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:220.76,228.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:232.188,233.76 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:233.76,241.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:246.125,248.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:252.127,254.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:261.44,270.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:277.44,286.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:293.44,302.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:305.154,312.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:315.157,322.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:325.157,332.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:335.241,336.84 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:336.84,346.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:350.244,351.84 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:351.84,361.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:365.244,366.84 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:366.84,376.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:381.137,383.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:387.139,389.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:397.48,408.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:416.48,427.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:435.48,446.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:449.182,457.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:460.185,468.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:471.185,479.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:482.297,483.92 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:483.92,495.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:499.300,500.92 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:500.92,512.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:516.300,517.92 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:517.92,529.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:534.149,536.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:540.151,542.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:551.52,564.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:573.52,586.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:595.52,608.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:611.210,620.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:623.213,632.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:635.213,644.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:647.353,648.100 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:648.100,662.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:666.356,667.100 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:667.100,681.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:685.356,686.100 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:686.100,700.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:705.161,707.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:711.163,713.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:723.56,738.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:748.56,763.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:773.56,788.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:791.238,801.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:804.241,814.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:817.241,827.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:830.409,831.108 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:831.108,847.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:851.412,852.108 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:852.108,868.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:872.412,873.108 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:873.108,889.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:894.173,896.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:900.175,902.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:913.60,930.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:941.60,958.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:969.60,986.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:989.266,1000.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1003.269,1014.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1017.269,1028.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1031.465,1032.116 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1032.116,1050.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1054.468,1055.116 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1055.116,1073.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1077.468,1078.116 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1078.116,1096.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1101.185,1103.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1107.187,1109.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1121.64,1140.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1152.64,1171.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1183.64,1202.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1205.294,1217.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1220.297,1232.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1235.297,1247.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1250.521,1251.124 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1251.124,1271.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1275.524,1276.124 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1276.124,1296.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1300.524,1301.124 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1301.124,1321.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1326.197,1328.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1332.199,1334.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1347.68,1368.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1381.68,1402.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1415.68,1436.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1439.322,1452.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1455.325,1468.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1471.325,1484.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1487.577,1488.132 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1488.132,1510.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1514.580,1515.132 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1515.132,1537.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1541.580,1542.132 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1542.132,1564.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1569.210,1571.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1575.212,1577.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1591.74,1614.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1628.74,1651.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1665.74,1688.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1691.356,1705.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1708.359,1722.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1725.359,1739.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1742.645,1743.144 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1743.144,1767.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1771.648,1772.144 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1772.144,1796.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1800.648,1801.144 1 0
github.com/IBM/fp-go/v2/context/readerioresult/gen.go:1801.144,1825.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/monoid.go:36.61,43.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/monoid.go:52.64,59.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/monoid.go:68.64,75.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/monoid.go:85.61,93.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/monoid.go:103.63,108.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:42.55,44.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:52.45,54.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:62.42,64.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:74.78,76.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:85.75,87.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:97.72,99.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:108.69,110.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:120.96,122.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:131.93,133.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:143.101,145.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:154.71,156.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:165.39,167.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:169.93,173.56 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:173.56,174.32 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:174.32,174.47 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:189.98,194.47 3 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:194.47,196.44 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:196.44,198.4 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:200.3,200.27 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:200.27,202.45 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:202.45,204.5 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:207.4,213.47 5 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:227.95,229.17 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:229.17,231.3 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:232.2,232.28 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:243.98,245.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:254.91,256.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:265.94,267.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:276.94,278.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:288.95,290.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:299.73,301.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:307.44,309.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:319.95,321.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:330.95,332.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:342.100,344.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:353.100,355.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:364.116,366.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:375.75,377.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:386.47,388.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:398.51,400.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:406.39,407.47 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:407.47,408.27 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:408.27,411.4 2 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:423.87,425.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:434.87,436.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:446.92,448.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:457.92,459.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:468.115,470.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:479.85,480.54 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:480.54,481.48 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:481.48,482.28 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:482.28,487.12 3 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:488.30,489.22 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:490.23,491.47 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:505.59,511.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:520.66,522.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:531.83,533.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:543.97,545.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:554.64,556.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:566.62,568.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:577.78,579.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:589.80,591.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:600.76,602.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:612.136,614.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:623.91,625.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/reader.go:634.71,636.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/resource.go:58.151,63.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/semigroup.go:39.41,43.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/sync.go:46.78,54.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:31.89,39.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:48.103,56.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:65.71,67.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:75.112,83.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:92.124,100.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:108.94,110.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:120.95,128.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:137.92,145.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:148.106,156.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:165.74,167.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:170.118,178.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:181.115,189.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:192.127,200.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:203.97,205.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:215.95,223.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:232.92,240.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:243.106,251.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:260.74,262.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:265.115,273.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:276.127,284.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:287.118,295.2 1 0
github.com/IBM/fp-go/v2/context/readerioresult/traverse.go:304.97,306.2 1 0

0
v2/context/readerioeither/data/file.txt → v2/context/readerioresult/data/file.txt
View File

20
v2/context/readerioeither/doc.go → v2/context/readerioresult/doc.go
View File

@@ -13,13 +13,13 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// Package readerioeither provides a specialized version of [readerioeither.ReaderIOEither] that uses
// package readerioresult provides a specialized version of [readerioeither.ReaderIOResult] that uses
// [context.Context] as the context type and [error] as the left (error) type. This package is designed
// for typical Go applications where context-aware, effectful computations with error handling are needed.
//
// # Core Concept
//
// ReaderIOEither[A] represents a computation that:
// ReaderIOResult[A] represents a computation that:
// - Depends on a [context.Context] (Reader aspect)
// - Performs side effects (IO aspect)
// - Can fail with an [error] (Either aspect)
@@ -27,7 +27,7 @@
//
// The type is defined as:
//
// ReaderIOEither[A] = func(context.Context) func() Either[error, A]
// ReaderIOResult[A] = func(context.Context) func() Either[error, A]
//
// This combines three powerful functional programming concepts:
// - Reader: Dependency injection via context
@@ -50,7 +50,7 @@
// - [Left]: Create failed computations
// - [FromEither], [FromIO], [FromIOEither]: Convert from other types
// - [TryCatch]: Wrap error-returning functions
// - [Eitherize0-10]: Convert standard Go functions to ReaderIOEither
// - [Eitherize0-10]: Convert standard Go functions to ReaderIOResult
//
// Transformation:
// - [Map]: Transform success values
@@ -90,15 +90,15 @@
// import (
// "context"
// "fmt"
// RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
// RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
// F "github.com/IBM/fp-go/v2/function"
// )
//
// // Define a computation that reads from context and may fail
// func fetchUser(id string) RIOE.ReaderIOEither[User] {
// func fetchUser(id string) RIOE.ReaderIOResult[User] {
// return F.Pipe2(
// RIOE.Ask(),
// RIOE.Chain(func(ctx context.Context) RIOE.ReaderIOEither[User] {
// RIOE.Chain(func(ctx context.Context) RIOE.ReaderIOResult[User] {
// return RIOE.TryCatch(func(ctx context.Context) func() (User, error) {
// return func() (User, error) {
// return userService.Get(ctx, id)
@@ -138,8 +138,8 @@
// openFile("data.txt"),
// closeFile,
// ),
// func(use func(func(*os.File) RIOE.ReaderIOEither[string]) RIOE.ReaderIOEither[string]) RIOE.ReaderIOEither[string] {
// return use(func(file *os.File) RIOE.ReaderIOEither[string] {
// func(use func(func(*os.File) RIOE.ReaderIOResult[string]) RIOE.ReaderIOResult[string]) RIOE.ReaderIOResult[string] {
// return use(func(file *os.File) RIOE.ReaderIOResult[string] {
// return readContent(file)
// })
// },
@@ -166,4 +166,4 @@
// result := computation(ctx)() // Returns Left with cancellation error
//
//go:generate go run ../.. contextreaderioeither --count 10 --filename gen.go
package readerioeither
package readerioresult

10
v2/context/readerioeither/eq.go → v2/context/readerioresult/eq.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -22,14 +22,14 @@ import (
RIOE "github.com/IBM/fp-go/v2/readerioeither"
)
// Eq implements the equals predicate for values contained in the [ReaderIOEither] monad.
// It creates an equality checker that can compare two ReaderIOEither values by executing them
// Eq implements the equals predicate for values contained in the [ReaderIOResult] monad.
// It creates an equality checker that can compare two ReaderIOResult values by executing them
// with a given context and comparing their results using the provided Either equality checker.
//
// Parameters:
// - eq: Equality checker for Either[A] values
//
// Returns a function that takes a context and returns an equality checker for ReaderIOEither[A].
// Returns a function that takes a context and returns an equality checker for ReaderIOResult[A].
//
// Example:
//
@@ -41,6 +41,6 @@ import (
// equal := eqRIE(ctx).Equals(Right[int](42), Right[int](42)) // true
//
//go:inline
func Eq[A any](eq eq.Eq[Either[A]]) func(context.Context) eq.Eq[ReaderIOEither[A]] {
func Eq[A any](eq eq.Eq[Either[A]]) func(context.Context) eq.Eq[ReaderIOResult[A]] {
return RIOE.Eq[context.Context](eq)
}

4
v2/context/readerioeither/exec/exec.go → v2/context/readerioresult/exec/exec.go
View File

@@ -18,7 +18,7 @@ package exec
import (
"context"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
"github.com/IBM/fp-go/v2/exec"
F "github.com/IBM/fp-go/v2/function"
GE "github.com/IBM/fp-go/v2/internal/exec"
@@ -30,7 +30,7 @@ var (
Command = F.Curry3(command)
)
func command(name string, args []string, in []byte) RIOE.ReaderIOEither[exec.CommandOutput] {
func command(name string, args []string, in []byte) RIOE.ReaderIOResult[exec.CommandOutput] {
return func(ctx context.Context) IOE.IOEither[error, exec.CommandOutput] {
return IOE.TryCatchError(func() (exec.CommandOutput, error) {
return GE.Exec(ctx, name, args, in)

0
v2/context/readerioeither/file/data/file.json → v2/context/readerioresult/file/data/file.json
View File

8
v2/context/readerioeither/file/file.go → v2/context/readerioresult/file/file.go
View File

@@ -20,7 +20,7 @@ import (
"io"
"os"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
ET "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/file"
@@ -44,7 +44,7 @@ var (
)
// Close closes an object
func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
func Close[C io.Closer](c C) RIOE.ReaderIOResult[any] {
return F.Pipe2(
c,
IOEF.Close[C],
@@ -53,8 +53,8 @@ func Close[C io.Closer](c C) RIOE.ReaderIOEither[any] {
}
// ReadFile reads a file in the scope of a context
func ReadFile(path string) RIOE.ReaderIOEither[[]byte] {
return RIOE.WithResource[[]byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOEither[[]byte] {
func ReadFile(path string) RIOE.ReaderIOResult[[]byte] {
return RIOE.WithResource[[]byte](Open(path), Close[*os.File])(func(r *os.File) RIOE.ReaderIOResult[[]byte] {
return func(ctx context.Context) IOE.IOEither[error, []byte] {
return func() ET.Either[error, []byte] {
return file.ReadAll(ctx, r)

2
v2/context/readerioeither/file/file_test.go → v2/context/readerioresult/file/file_test.go
View File

@@ -19,7 +19,7 @@ import (
"context"
"fmt"
R "github.com/IBM/fp-go/v2/context/readerioeither"
R "github.com/IBM/fp-go/v2/context/readerioresult"
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/io"
J "github.com/IBM/fp-go/v2/json"

6
v2/context/readerioeither/file/tempfile.go → v2/context/readerioresult/file/tempfile.go
View File

@@ -18,7 +18,7 @@ package file
import (
"os"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
F "github.com/IBM/fp-go/v2/function"
IO "github.com/IBM/fp-go/v2/io"
IOF "github.com/IBM/fp-go/v2/io/file"
@@ -38,7 +38,7 @@ var (
)
// CreateTemp created a temp file with proper parametrization
func CreateTemp(dir, pattern string) RIOE.ReaderIOEither[*os.File] {
func CreateTemp(dir, pattern string) RIOE.ReaderIOResult[*os.File] {
return F.Pipe2(
IOEF.CreateTemp(dir, pattern),
RIOE.FromIOEither[*os.File],
@@ -47,6 +47,6 @@ func CreateTemp(dir, pattern string) RIOE.ReaderIOEither[*os.File] {
}
// WithTempFile creates a temporary file, then invokes a callback to create a resource based on the file, then close and remove the temp file
func WithTempFile[A any](f func(*os.File) RIOE.ReaderIOEither[A]) RIOE.ReaderIOEither[A] {
func WithTempFile[A any](f func(*os.File) RIOE.ReaderIOResult[A]) RIOE.ReaderIOResult[A] {
return RIOE.WithResource[A](onCreateTempFile, onReleaseTempFile)(f)
}

4
v2/context/readerioeither/file/tempfile_test.go → v2/context/readerioresult/file/tempfile_test.go
View File

@@ -20,7 +20,7 @@ import (
"os"
"testing"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
"github.com/stretchr/testify/assert"
@@ -35,7 +35,7 @@ func TestWithTempFile(t *testing.T) {
func TestWithTempFileOnClosedFile(t *testing.T) {
res := WithTempFile(func(f *os.File) RIOE.ReaderIOEither[[]byte] {
res := WithTempFile(func(f *os.File) RIOE.ReaderIOResult[[]byte] {
return F.Pipe2(
f,
onWriteAll[*os.File]([]byte("Carsten")),

12
v2/context/readerioeither/file/write.go → v2/context/readerioresult/file/write.go
View File

@@ -19,12 +19,12 @@ import (
"context"
"io"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
F "github.com/IBM/fp-go/v2/function"
)
func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte] {
return func(w W) RIOE.ReaderIOEither[[]byte] {
func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOResult[[]byte] {
return func(w W) RIOE.ReaderIOResult[[]byte] {
return F.Pipe1(
RIOE.TryCatch(func(_ context.Context) func() ([]byte, error) {
return func() ([]byte, error) {
@@ -38,9 +38,9 @@ func onWriteAll[W io.Writer](data []byte) func(w W) RIOE.ReaderIOEither[[]byte]
}
// WriteAll uses a generator function to create a stream, writes data to it and closes it
func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOResult[W]) RIOE.ReaderIOResult[[]byte] {
onWrite := onWriteAll[W](data)
return func(onCreate RIOE.ReaderIOEither[W]) RIOE.ReaderIOEither[[]byte] {
return func(onCreate RIOE.ReaderIOResult[W]) RIOE.ReaderIOResult[[]byte] {
return RIOE.WithResource[[]byte](
onCreate,
Close[W])(
@@ -50,7 +50,7 @@ func WriteAll[W io.WriteCloser](data []byte) func(acquire RIOE.ReaderIOEither[W]
}
// Write uses a generator function to create a stream, writes data to it and closes it
func Write[R any, W io.WriteCloser](acquire RIOE.ReaderIOEither[W]) func(use func(W) RIOE.ReaderIOEither[R]) RIOE.ReaderIOEither[R] {
func Write[R any, W io.WriteCloser](acquire RIOE.ReaderIOResult[W]) func(use func(W) RIOE.ReaderIOResult[R]) RIOE.ReaderIOResult[R] {
return RIOE.WithResource[R](
acquire,
Close[W])

884
v2/context/readerioeither/gen.go → v2/context/readerioresult/gen.go
View File

File diff suppressed because it is too large Load Diff

0
v2/context/readerioeither/generic/gen.go → v2/context/readerioresult/generic/gen.go
View File

24
v2/context/readerioeither/http/builder/builder.go → v2/context/readerioresult/http/builder/builder.go
View File

@@ -14,12 +14,12 @@
// limitations under the License.
// Package builder provides utilities for building HTTP requests in a functional way
// using the ReaderIOEither monad. It integrates with the http/builder package to
// using the ReaderIOResult monad. It integrates with the http/builder package to
// create composable, type-safe HTTP request builders with proper error handling
// and context support.
//
// The main function, Requester, converts a Builder from the http/builder package
// into a ReaderIOEither that produces HTTP requests. This allows for:
// into a ReaderIOResult that produces HTTP requests. This allows for:
// - Immutable request building with method chaining
// - Automatic header management including Content-Length
// - Support for requests with and without bodies
@@ -31,7 +31,7 @@
// import (
// "context"
// B "github.com/IBM/fp-go/v2/http/builder"
// RB "github.com/IBM/fp-go/v2/context/readerioeither/http/builder"
// RB "github.com/IBM/fp-go/v2/context/readerioresult/http/builder"
// )
//
// builder := F.Pipe3(
@@ -51,8 +51,8 @@ import (
"net/http"
"strconv"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOEH "github.com/IBM/fp-go/v2/context/readerioeither/http"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
RIOEH "github.com/IBM/fp-go/v2/context/readerioresult/http"
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
R "github.com/IBM/fp-go/v2/http/builder"
@@ -61,7 +61,7 @@ import (
O "github.com/IBM/fp-go/v2/option"
)
// Requester converts an http/builder.Builder into a ReaderIOEither that produces HTTP requests.
// Requester converts an http/builder.Builder into a ReaderIOResult that produces HTTP requests.
// It handles both requests with and without bodies, automatically managing headers including
// Content-Length for requests with bodies.
//
@@ -86,14 +86,14 @@ import (
// - builder: A pointer to an http/builder.Builder containing request configuration
//
// Returns:
// - A Requester (ReaderIOEither[*http.Request]) that, when executed with a context,
// - A Requester (ReaderIOResult[*http.Request]) that, when executed with a context,
// produces either an error or a configured *http.Request
//
// Example with body:
//
// import (
// B "github.com/IBM/fp-go/v2/http/builder"
// RB "github.com/IBM/fp-go/v2/context/readerioeither/http/builder"
// RB "github.com/IBM/fp-go/v2/context/readerioresult/http/builder"
// )
//
// builder := F.Pipe3(
@@ -116,7 +116,7 @@ import (
// result := requester(context.Background())()
func Requester(builder *R.Builder) RIOEH.Requester {
withBody := F.Curry3(func(data []byte, url string, method string) RIOE.ReaderIOEither[*http.Request] {
withBody := F.Curry3(func(data []byte, url string, method string) RIOE.ReaderIOResult[*http.Request] {
return RIOE.TryCatch(func(ctx context.Context) func() (*http.Request, error) {
return func() (*http.Request, error) {
req, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(data))
@@ -129,7 +129,7 @@ func Requester(builder *R.Builder) RIOEH.Requester {
})
})
withoutBody := F.Curry2(func(url string, method string) RIOE.ReaderIOEither[*http.Request] {
withoutBody := F.Curry2(func(url string, method string) RIOE.ReaderIOResult[*http.Request] {
return RIOE.TryCatch(func(ctx context.Context) func() (*http.Request, error) {
return func() (*http.Request, error) {
req, err := http.NewRequestWithContext(ctx, method, url, nil)
@@ -144,8 +144,8 @@ func Requester(builder *R.Builder) RIOEH.Requester {
return F.Pipe5(
builder.GetBody(),
O.Fold(LZ.Of(E.Of[error](withoutBody)), E.Map[error](withBody)),
E.Ap[func(string) RIOE.ReaderIOEither[*http.Request]](builder.GetTargetURL()),
E.Flap[error, RIOE.ReaderIOEither[*http.Request]](builder.GetMethod()),
E.Ap[func(string) RIOE.ReaderIOResult[*http.Request]](builder.GetTargetURL()),
E.Flap[error, RIOE.ReaderIOResult[*http.Request]](builder.GetMethod()),
E.GetOrElse(RIOE.Left[*http.Request]),
RIOE.Map(func(req *http.Request) *http.Request {
req.Header = H.Monoid.Concat(req.Header, builder.GetHeaders())

2
v2/context/readerioeither/http/builder/builder_test.go → v2/context/readerioresult/http/builder/builder_test.go
View File

@@ -21,7 +21,7 @@ import (
"net/url"
"testing"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
R "github.com/IBM/fp-go/v2/http/builder"

15
v2/context/readerioresult/http/builder/coverage.out Normal file
View File

@@ -0,0 +1,15 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:117.52,119.103 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:119.103,120.80 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:120.80,121.41 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:121.41,123.19 2 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:123.19,126.6 2 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:127.5,127.20 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:132.2,132.93 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:132.93,133.80 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:133.80,134.41 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:134.41,136.19 2 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:136.19,138.6 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:139.5,139.20 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:144.2,150.50 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/builder/builder.go:150.50,153.4 2 1

11
v2/context/readerioresult/http/coverage.out Normal file
View File

@@ -0,0 +1,11 @@
mode: set
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:111.76,116.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:134.49,136.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:161.90,162.65 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:162.65,166.76 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:166.76,176.5 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:198.73,203.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:222.74,227.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:234.76,236.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:245.74,254.2 1 1
github.com/IBM/fp-go/v2/context/readerioresult/http/request.go:281.76,286.2 1 1

40
v2/context/readerioeither/http/request.go → v2/context/readerioresult/http/request.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// Package http provides functional HTTP client utilities built on top of ReaderIOEither monad.
// Package http provides functional HTTP client utilities built on top of ReaderIOResult monad.
// It offers a composable way to make HTTP requests with context support, error handling,
// and response parsing capabilities. The package follows functional programming principles
// to ensure type-safe, testable, and maintainable HTTP operations.
@@ -36,7 +36,7 @@ import (
"net/http"
B "github.com/IBM/fp-go/v2/bytes"
RIOE "github.com/IBM/fp-go/v2/context/readerioeither"
RIOE "github.com/IBM/fp-go/v2/context/readerioresult"
F "github.com/IBM/fp-go/v2/function"
H "github.com/IBM/fp-go/v2/http"
IOE "github.com/IBM/fp-go/v2/ioeither"
@@ -50,13 +50,13 @@ type (
// It represents a computation that, given a context, produces either an error
// or an HTTP request. This allows for composable request building with proper
// error handling and context propagation.
Requester = RIOE.ReaderIOEither[*http.Request]
Requester = RIOE.ReaderIOResult[*http.Request]
// Client is an interface for executing HTTP requests in a functional way.
// It wraps the standard http.Client and provides a Do method that works
// with the ReaderIOEither monad for composable, type-safe HTTP operations.
// with the ReaderIOResult monad for composable, type-safe HTTP operations.
Client interface {
// Do executes an HTTP request and returns the response wrapped in a ReaderIOEither.
// Do executes an HTTP request and returns the response wrapped in a ReaderIOResult.
// It takes a Requester (which builds the request) and returns a computation that,
// when executed with a context, performs the HTTP request and returns either
// an error or the HTTP response.
@@ -65,8 +65,8 @@ type (
// - req: A Requester that builds the HTTP request
//
// Returns:
// - A ReaderIOEither that produces either an error or an *http.Response
Do(Requester) RIOE.ReaderIOEither[*http.Response]
// - A ReaderIOResult that produces either an error or an *http.Response
Do(Requester) RIOE.ReaderIOResult[*http.Response]
}
// client is the internal implementation of the Client interface.
@@ -108,7 +108,7 @@ var (
MakeGetRequest = makeRequest("GET", nil)
)
func (client client) Do(req Requester) RIOE.ReaderIOEither[*http.Response] {
func (client client) Do(req Requester) RIOE.ReaderIOResult[*http.Response] {
return F.Pipe1(
req,
RIOE.ChainIOEitherK(client.doIOE),
@@ -117,7 +117,7 @@ func (client client) Do(req Requester) RIOE.ReaderIOEither[*http.Response] {
// MakeClient creates a functional HTTP client wrapper around a standard http.Client.
// The returned Client provides methods for executing HTTP requests in a functional,
// composable way using the ReaderIOEither monad.
// composable way using the ReaderIOResult monad.
//
// Parameters:
// - httpClient: A standard *http.Client to wrap (e.g., http.DefaultClient)
@@ -149,7 +149,7 @@ func MakeClient(httpClient *http.Client) Client {
// - client: The HTTP client to use for executing the request
//
// Returns:
// - A function that takes a Requester and returns a ReaderIOEither[FullResponse]
// - A function that takes a Requester and returns a ReaderIOResult[FullResponse]
// where FullResponse is a tuple of (*http.Response, []byte)
//
// Example:
@@ -158,8 +158,8 @@ func MakeClient(httpClient *http.Client) Client {
// request := MakeGetRequest("https://api.example.com/data")
// fullResp := ReadFullResponse(client)(request)
// result := fullResp(context.Background())()
func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOEither[H.FullResponse] {
return func(req Requester) RIOE.ReaderIOEither[H.FullResponse] {
func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOResult[H.FullResponse] {
return func(req Requester) RIOE.ReaderIOResult[H.FullResponse] {
return F.Flow3(
client.Do(req),
IOE.ChainEitherK(H.ValidateResponse),
@@ -186,7 +186,7 @@ func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOEither[H.FullR
// - client: The HTTP client to use for executing the request
//
// Returns:
// - A function that takes a Requester and returns a ReaderIOEither[[]byte]
// - A function that takes a Requester and returns a ReaderIOResult[[]byte]
// containing the response body as bytes
//
// Example:
@@ -195,7 +195,7 @@ func ReadFullResponse(client Client) func(Requester) RIOE.ReaderIOEither[H.FullR
// request := MakeGetRequest("https://api.example.com/data")
// readBytes := ReadAll(client)
// result := readBytes(request)(context.Background())()
func ReadAll(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
func ReadAll(client Client) func(Requester) RIOE.ReaderIOResult[[]byte] {
return F.Flow2(
ReadFullResponse(client),
RIOE.Map(H.Body),
@@ -210,7 +210,7 @@ func ReadAll(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
// - client: The HTTP client to use for executing the request
//
// Returns:
// - A function that takes a Requester and returns a ReaderIOEither[string]
// - A function that takes a Requester and returns a ReaderIOResult[string]
// containing the response body as a string
//
// Example:
@@ -219,7 +219,7 @@ func ReadAll(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
// request := MakeGetRequest("https://api.example.com/text")
// readText := ReadText(client)
// result := readText(request)(context.Background())()
func ReadText(client Client) func(Requester) RIOE.ReaderIOEither[string] {
func ReadText(client Client) func(Requester) RIOE.ReaderIOResult[string] {
return F.Flow2(
ReadAll(client),
RIOE.Map(B.ToString),
@@ -231,7 +231,7 @@ func ReadText(client Client) func(Requester) RIOE.ReaderIOEither[string] {
// Deprecated: Use [ReadJSON] instead. This function is kept for backward compatibility
// but will be removed in a future version. The capitalized version follows Go naming
// conventions for acronyms.
func ReadJson[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
func ReadJson[A any](client Client) func(Requester) RIOE.ReaderIOResult[A] {
return ReadJSON[A](client)
}
@@ -242,7 +242,7 @@ func ReadJson[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
// 3. Reads the response body as bytes
//
// This function is used internally by ReadJSON to ensure proper JSON response handling.
func readJSON(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
func readJSON(client Client) func(Requester) RIOE.ReaderIOResult[[]byte] {
return F.Flow3(
ReadFullResponse(client),
RIOE.ChainFirstEitherK(F.Flow2(
@@ -264,7 +264,7 @@ func readJSON(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
// - client: The HTTP client to use for executing the request
//
// Returns:
// - A function that takes a Requester and returns a ReaderIOEither[A]
// - A function that takes a Requester and returns a ReaderIOResult[A]
// containing the parsed JSON data
//
// Example:
@@ -278,7 +278,7 @@ func readJSON(client Client) func(Requester) RIOE.ReaderIOEither[[]byte] {
// request := MakeGetRequest("https://api.example.com/user/1")
// readUser := ReadJSON[User](client)
// result := readUser(request)(context.Background())()
func ReadJSON[A any](client Client) func(Requester) RIOE.ReaderIOEither[A] {
func ReadJSON[A any](client Client) func(Requester) RIOE.ReaderIOResult[A] {
return F.Flow2(
readJSON(client),
RIOE.ChainEitherK(J.Unmarshal[A]),

4
v2/context/readerioeither/http/request_test.go → v2/context/readerioresult/http/request_test.go
View File

@@ -22,7 +22,7 @@ import (
H "net/http"
R "github.com/IBM/fp-go/v2/context/readerioeither"
R "github.com/IBM/fp-go/v2/context/readerioresult"
E "github.com/IBM/fp-go/v2/either"
"github.com/IBM/fp-go/v2/errors"
F "github.com/IBM/fp-go/v2/function"
@@ -66,7 +66,7 @@ func (b simpleRequestBuilder) WithHeader(key, value string) simpleRequestBuilder
return b
}
func (b simpleRequestBuilder) Build() R.ReaderIOEither[*H.Request] {
func (b simpleRequestBuilder) Build() R.ReaderIOResult[*H.Request] {
return func(ctx context.Context) IOE.IOEither[error, *H.Request] {
return IOE.TryCatchError(func() (*H.Request, error) {
req, err := H.NewRequestWithContext(ctx, b.method, b.url, nil)

67
v2/context/readerioeither/monoid.go → v2/context/readerioresult/monoid.go
View File

@@ -13,96 +13,75 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
"github.com/IBM/fp-go/v2/monoid"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
)
type (
Monoid[A any] = monoid.Monoid[ReaderIOEither[A]]
Monoid[A any] = monoid.Monoid[ReaderIOResult[A]]
)
// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative.
// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This uses the default applicative behavior (parallel or sequential based on useParallel flag).
//
// The monoid combines two ReaderIOEither values by applying the underlying monoid's combine operation
// The monoid combines two ReaderIOResult values by applying the underlying monoid's combine operation
// to their success values using applicative application.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOEither[A].
// Returns a Monoid for ReaderIOResult[A].
func ApplicativeMonoid[A any](m monoid.Monoid[A]) Monoid[A] {
return monoid.ApplicativeMonoid(
Of[A],
MonadMap[A, func(A) A],
MonadAp[A, A],
m,
)
return RIOR.ApplicativeMonoid[context.Context](m)
}
// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative.
// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses sequential execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOEither[A] with sequential execution.
// Returns a Monoid for ReaderIOResult[A] with sequential execution.
func ApplicativeMonoidSeq[A any](m monoid.Monoid[A]) Monoid[A] {
return monoid.ApplicativeMonoid(
Of[A],
MonadMap[A, func(A) A],
MonadApSeq[A, A],
m,
)
return RIOR.ApplicativeMonoidSeq[context.Context](m)
}
// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOEither] instances via their applicative.
// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses parallel execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOEither[A] with parallel execution.
// Returns a Monoid for ReaderIOResult[A] with parallel execution.
func ApplicativeMonoidPar[A any](m monoid.Monoid[A]) Monoid[A] {
return monoid.ApplicativeMonoid(
Of[A],
MonadMap[A, func(A) A],
MonadApPar[A, A],
m,
)
return RIOR.ApplicativeMonoidPar[context.Context](m)
}
// AlternativeMonoid is the alternative [Monoid] for [ReaderIOEither].
// This combines ReaderIOEither values using the alternative semantics,
// AlternativeMonoid is the alternative [Monoid] for [ReaderIOResult].
// This combines ReaderIOResult values using the alternative semantics,
// where the second value is only evaluated if the first fails.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOEither[A] with alternative semantics.
// Returns a Monoid for ReaderIOResult[A] with alternative semantics.
func AlternativeMonoid[A any](m monoid.Monoid[A]) Monoid[A] {
return monoid.AlternativeMonoid(
Of[A],
MonadMap[A, func(A) A],
MonadAp[A, A],
MonadAlt[A],
m,
)
return RIOR.AlternativeMonoid[context.Context](m)
}
// AltMonoid is the alternative [Monoid] for a [ReaderIOEither].
// AltMonoid is the alternative [Monoid] for a [ReaderIOResult].
// This creates a monoid where the empty value is provided lazily,
// and combination uses the Alt operation (try first, fallback to second on failure).
//
// Parameters:
// - zero: Lazy computation that provides the empty/identity value
//
// Returns a Monoid for ReaderIOEither[A] with Alt-based combination.
func AltMonoid[A any](zero Lazy[ReaderIOEither[A]]) Monoid[A] {
return monoid.AltMonoid(
zero,
MonadAlt[A],
)
// Returns a Monoid for ReaderIOResult[A] with Alt-based combination.
func AltMonoid[A any](zero Lazy[ReaderIOResult[A]]) Monoid[A] {
return RIOR.AltMonoid[context.Context](zero)
}

424
v2/context/readerioeither/reader.go → v2/context/readerioresult/reader.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -24,7 +24,8 @@ import (
"github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/io"
"github.com/IBM/fp-go/v2/ioeither"
"github.com/IBM/fp-go/v2/readerioeither"
"github.com/IBM/fp-go/v2/ioresult"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
)
const (
@@ -32,194 +33,207 @@ const (
useParallel = true
)
// FromEither converts an [Either] into a [ReaderIOEither].
// FromEither converts an [Either] into a [ReaderIOResult].
// The resulting computation ignores the context and immediately returns the Either value.
//
// Parameters:
// - e: The Either value to lift into ReaderIOEither
// - e: The Either value to lift into ReaderIOResult
//
// Returns a ReaderIOEither that produces the given Either value.
// Returns a ReaderIOResult that produces the given Either value.
//
//go:inline
func FromEither[A any](e Either[A]) ReaderIOEither[A] {
return readerioeither.FromEither[context.Context](e)
func FromEither[A any](e Either[A]) ReaderIOResult[A] {
return RIOR.FromEither[context.Context](e)
}
// Left creates a [ReaderIOEither] that represents a failed computation with the given error.
// FromEither converts an [Either] into a [ReaderIOResult].
// The resulting computation ignores the context and immediately returns the Either value.
//
// Parameters:
// - e: The Either value to lift into ReaderIOResult
//
// Returns a ReaderIOResult that produces the given Either value.
//
//go:inline
func FromResult[A any](e Result[A]) ReaderIOResult[A] {
return RIOR.FromEither[context.Context](e)
}
// Left creates a [ReaderIOResult] that represents a failed computation with the given error.
//
// Parameters:
// - l: The error value
//
// Returns a ReaderIOEither that always fails with the given error.
func Left[A any](l error) ReaderIOEither[A] {
return readerioeither.Left[context.Context, A](l)
// Returns a ReaderIOResult that always fails with the given error.
func Left[A any](l error) ReaderIOResult[A] {
return RIOR.Left[context.Context, A](l)
}
// Right creates a [ReaderIOEither] that represents a successful computation with the given value.
// Right creates a [ReaderIOResult] that represents a successful computation with the given value.
//
// Parameters:
// - r: The success value
//
// Returns a ReaderIOEither that always succeeds with the given value.
// Returns a ReaderIOResult that always succeeds with the given value.
//
//go:inline
func Right[A any](r A) ReaderIOEither[A] {
return readerioeither.Right[context.Context, error](r)
func Right[A any](r A) ReaderIOResult[A] {
return RIOR.Right[context.Context, A](r)
}
// MonadMap transforms the success value of a [ReaderIOEither] using the provided function.
// MonadMap transforms the success value of a [ReaderIOResult] using the provided function.
// If the computation fails, the error is propagated unchanged.
//
// Parameters:
// - fa: The ReaderIOEither to transform
// - fa: The ReaderIOResult to transform
// - f: The transformation function
//
// Returns a new ReaderIOEither with the transformed value.
// Returns a new ReaderIOResult with the transformed value.
//
//go:inline
func MonadMap[A, B any](fa ReaderIOEither[A], f func(A) B) ReaderIOEither[B] {
return readerioeither.MonadMap(fa, f)
func MonadMap[A, B any](fa ReaderIOResult[A], f func(A) B) ReaderIOResult[B] {
return RIOR.MonadMap(fa, f)
}
// Map transforms the success value of a [ReaderIOEither] using the provided function.
// Map transforms the success value of a [ReaderIOResult] using the provided function.
// This is the curried version of [MonadMap], useful for composition.
//
// Parameters:
// - f: The transformation function
//
// Returns a function that transforms a ReaderIOEither.
// Returns a function that transforms a ReaderIOResult.
//
//go:inline
func Map[A, B any](f func(A) B) Operator[A, B] {
return readerioeither.Map[context.Context, error](f)
return RIOR.Map[context.Context](f)
}
// MonadMapTo replaces the success value of a [ReaderIOEither] with a constant value.
// MonadMapTo replaces the success value of a [ReaderIOResult] with a constant value.
// If the computation fails, the error is propagated unchanged.
//
// Parameters:
// - fa: The ReaderIOEither to transform
// - fa: The ReaderIOResult to transform
// - b: The constant value to use
//
// Returns a new ReaderIOEither with the constant value.
// Returns a new ReaderIOResult with the constant value.
//
//go:inline
func MonadMapTo[A, B any](fa ReaderIOEither[A], b B) ReaderIOEither[B] {
return readerioeither.MonadMapTo(fa, b)
func MonadMapTo[A, B any](fa ReaderIOResult[A], b B) ReaderIOResult[B] {
return RIOR.MonadMapTo(fa, b)
}
// MapTo replaces the success value of a [ReaderIOEither] with a constant value.
// MapTo replaces the success value of a [ReaderIOResult] with a constant value.
// This is the curried version of [MonadMapTo].
//
// Parameters:
// - b: The constant value to use
//
// Returns a function that transforms a ReaderIOEither.
// Returns a function that transforms a ReaderIOResult.
//
//go:inline
func MapTo[A, B any](b B) Operator[A, B] {
return readerioeither.MapTo[context.Context, error, A](b)
return RIOR.MapTo[context.Context, A](b)
}
// MonadChain sequences two [ReaderIOEither] computations, where the second depends on the result of the first.
// MonadChain sequences two [ReaderIOResult] computations, where the second depends on the result of the first.
// If the first computation fails, the second is not executed.
//
// Parameters:
// - ma: The first ReaderIOEither
// - f: Function that produces the second ReaderIOEither based on the first's result
// - ma: The first ReaderIOResult
// - f: Function that produces the second ReaderIOResult based on the first's result
//
// Returns a new ReaderIOEither representing the sequenced computation.
// Returns a new ReaderIOResult representing the sequenced computation.
//
//go:inline
func MonadChain[A, B any](ma ReaderIOEither[A], f Kleisli[A, B]) ReaderIOEither[B] {
return readerioeither.MonadChain(ma, f)
func MonadChain[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[B] {
return RIOR.MonadChain(ma, f)
}
// Chain sequences two [ReaderIOEither] computations, where the second depends on the result of the first.
// Chain sequences two [ReaderIOResult] computations, where the second depends on the result of the first.
// This is the curried version of [MonadChain], useful for composition.
//
// Parameters:
// - f: Function that produces the second ReaderIOEither based on the first's result
// - f: Function that produces the second ReaderIOResult based on the first's result
//
// Returns a function that sequences ReaderIOEither computations.
// Returns a function that sequences ReaderIOResult computations.
//
//go:inline
func Chain[A, B any](f Kleisli[A, B]) Operator[A, B] {
return readerioeither.Chain(f)
return RIOR.Chain(f)
}
// MonadChainFirst sequences two [ReaderIOEither] computations but returns the result of the first.
// MonadChainFirst sequences two [ReaderIOResult] computations but returns the result of the first.
// The second computation is executed for its side effects only.
//
// Parameters:
// - ma: The first ReaderIOEither
// - f: Function that produces the second ReaderIOEither
// - ma: The first ReaderIOResult
// - f: Function that produces the second ReaderIOResult
//
// Returns a ReaderIOEither with the result of the first computation.
// Returns a ReaderIOResult with the result of the first computation.
//
//go:inline
func MonadChainFirst[A, B any](ma ReaderIOEither[A], f Kleisli[A, B]) ReaderIOEither[A] {
return readerioeither.MonadChainFirst(ma, f)
func MonadChainFirst[A, B any](ma ReaderIOResult[A], f Kleisli[A, B]) ReaderIOResult[A] {
return RIOR.MonadChainFirst(ma, f)
}
// ChainFirst sequences two [ReaderIOEither] computations but returns the result of the first.
// ChainFirst sequences two [ReaderIOResult] computations but returns the result of the first.
// This is the curried version of [MonadChainFirst].
//
// Parameters:
// - f: Function that produces the second ReaderIOEither
// - f: Function that produces the second ReaderIOResult
//
// Returns a function that sequences ReaderIOEither computations.
// Returns a function that sequences ReaderIOResult computations.
//
//go:inline
func ChainFirst[A, B any](f Kleisli[A, B]) Operator[A, A] {
return readerioeither.ChainFirst(f)
return RIOR.ChainFirst(f)
}
// Of creates a [ReaderIOEither] that always succeeds with the given value.
// Of creates a [ReaderIOResult] that always succeeds with the given value.
// This is the same as [Right] and represents the monadic return operation.
//
// Parameters:
// - a: The value to wrap
//
// Returns a ReaderIOEither that always succeeds with the given value.
// Returns a ReaderIOResult that always succeeds with the given value.
//
//go:inline
func Of[A any](a A) ReaderIOEither[A] {
return readerioeither.Of[context.Context, error](a)
func Of[A any](a A) ReaderIOResult[A] {
return RIOR.Of[context.Context](a)
}
func withCancelCauseFunc[A any](cancel context.CancelCauseFunc, ma IOEither[A]) IOEither[A] {
func withCancelCauseFunc[A any](cancel context.CancelCauseFunc, ma IOResult[A]) IOResult[A] {
return function.Pipe3(
ma,
ioeither.Swap[error, A],
ioresult.Swap[A],
ioeither.ChainFirstIOK[A](func(err error) func() any {
return io.FromImpure(func() { cancel(err) })
}),
ioeither.Swap[A, error],
ioeither.Swap[A],
)
}
// MonadApPar implements parallel applicative application for [ReaderIOEither].
// MonadApPar implements parallel applicative application for [ReaderIOResult].
// It executes both computations in parallel and creates a sub-context that will be canceled
// if either operation fails. This provides automatic cancellation propagation.
//
// Parameters:
// - fab: ReaderIOEither containing a function
// - fa: ReaderIOEither containing a value
// - fab: ReaderIOResult containing a function
// - fa: ReaderIOResult containing a value
//
// Returns a ReaderIOEither with the function applied to the value.
func MonadApPar[B, A any](fab ReaderIOEither[func(A) B], fa ReaderIOEither[A]) ReaderIOEither[B] {
// Returns a ReaderIOResult with the function applied to the value.
func MonadApPar[B, A any](fab ReaderIOResult[func(A) B], fa ReaderIOResult[A]) ReaderIOResult[B] {
// context sensitive input
cfab := WithContext(fab)
cfa := WithContext(fa)
return func(ctx context.Context) IOEither[B] {
return func(ctx context.Context) IOResult[B] {
// quick check for cancellation
if err := context.Cause(ctx); err != nil {
return ioeither.Left[B](err)
}
return func() Either[B] {
return func() Result[B] {
// quick check for cancellation
if err := context.Cause(ctx); err != nil {
return either.Left[B](err)
@@ -232,21 +246,21 @@ func MonadApPar[B, A any](fab ReaderIOEither[func(A) B], fa ReaderIOEither[A]) R
fabIOE := withCancelCauseFunc(cancelSub, cfab(ctxSub))
faIOE := withCancelCauseFunc(cancelSub, cfa(ctxSub))
return ioeither.MonadApPar(fabIOE, faIOE)()
return ioresult.MonadApPar(fabIOE, faIOE)()
}
}
}
// MonadAp implements applicative application for [ReaderIOEither].
// MonadAp implements applicative application for [ReaderIOResult].
// By default, it uses parallel execution ([MonadApPar]) but can be configured to use
// sequential execution ([MonadApSeq]) via the useParallel constant.
//
// Parameters:
// - fab: ReaderIOEither containing a function
// - fa: ReaderIOEither containing a value
// - fab: ReaderIOResult containing a function
// - fa: ReaderIOResult containing a value
//
// Returns a ReaderIOEither with the function applied to the value.
func MonadAp[B, A any](fab ReaderIOEither[func(A) B], fa ReaderIOEither[A]) ReaderIOEither[B] {
// Returns a ReaderIOResult with the function applied to the value.
func MonadAp[B, A any](fab ReaderIOResult[func(A) B], fa ReaderIOResult[A]) ReaderIOResult[B] {
// dispatch to the configured version
if useParallel {
return MonadApPar(fab, fa)
@@ -254,111 +268,111 @@ func MonadAp[B, A any](fab ReaderIOEither[func(A) B], fa ReaderIOEither[A]) Read
return MonadApSeq(fab, fa)
}
// MonadApSeq implements sequential applicative application for [ReaderIOEither].
// MonadApSeq implements sequential applicative application for [ReaderIOResult].
// It executes the function computation first, then the value computation.
//
// Parameters:
// - fab: ReaderIOEither containing a function
// - fa: ReaderIOEither containing a value
// - fab: ReaderIOResult containing a function
// - fa: ReaderIOResult containing a value
//
// Returns a ReaderIOEither with the function applied to the value.
// Returns a ReaderIOResult with the function applied to the value.
//
//go:inline
func MonadApSeq[B, A any](fab ReaderIOEither[func(A) B], fa ReaderIOEither[A]) ReaderIOEither[B] {
return readerioeither.MonadApSeq(fab, fa)
func MonadApSeq[B, A any](fab ReaderIOResult[func(A) B], fa ReaderIOResult[A]) ReaderIOResult[B] {
return RIOR.MonadApSeq(fab, fa)
}
// Ap applies a function wrapped in a [ReaderIOEither] to a value wrapped in a ReaderIOEither.
// Ap applies a function wrapped in a [ReaderIOResult] to a value wrapped in a ReaderIOResult.
// This is the curried version of [MonadAp], using the default execution mode.
//
// Parameters:
// - fa: ReaderIOEither containing a value
// - fa: ReaderIOResult containing a value
//
// Returns a function that applies a ReaderIOEither function to the value.
// Returns a function that applies a ReaderIOResult function to the value.
//
//go:inline
func Ap[B, A any](fa ReaderIOEither[A]) Operator[func(A) B, B] {
func Ap[B, A any](fa ReaderIOResult[A]) Operator[func(A) B, B] {
return function.Bind2nd(MonadAp[B, A], fa)
}
// ApSeq applies a function wrapped in a [ReaderIOEither] to a value sequentially.
// ApSeq applies a function wrapped in a [ReaderIOResult] to a value sequentially.
// This is the curried version of [MonadApSeq].
//
// Parameters:
// - fa: ReaderIOEither containing a value
// - fa: ReaderIOResult containing a value
//
// Returns a function that applies a ReaderIOEither function to the value sequentially.
// Returns a function that applies a ReaderIOResult function to the value sequentially.
//
//go:inline
func ApSeq[B, A any](fa ReaderIOEither[A]) Operator[func(A) B, B] {
func ApSeq[B, A any](fa ReaderIOResult[A]) Operator[func(A) B, B] {
return function.Bind2nd(MonadApSeq[B, A], fa)
}
// ApPar applies a function wrapped in a [ReaderIOEither] to a value in parallel.
// ApPar applies a function wrapped in a [ReaderIOResult] to a value in parallel.
// This is the curried version of [MonadApPar].
//
// Parameters:
// - fa: ReaderIOEither containing a value
// - fa: ReaderIOResult containing a value
//
// Returns a function that applies a ReaderIOEither function to the value in parallel.
// Returns a function that applies a ReaderIOResult function to the value in parallel.
//
//go:inline
func ApPar[B, A any](fa ReaderIOEither[A]) Operator[func(A) B, B] {
func ApPar[B, A any](fa ReaderIOResult[A]) Operator[func(A) B, B] {
return function.Bind2nd(MonadApPar[B, A], fa)
}
// FromPredicate creates a [ReaderIOEither] from a predicate function.
// FromPredicate creates a [ReaderIOResult] from a predicate function.
// If the predicate returns true, the value is wrapped in Right; otherwise, Left with the error from onFalse.
//
// Parameters:
// - pred: Predicate function to test the value
// - onFalse: Function to generate an error when predicate fails
//
// Returns a function that converts a value to ReaderIOEither based on the predicate.
// Returns a function that converts a value to ReaderIOResult based on the predicate.
//
//go:inline
func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) Kleisli[A, A] {
return readerioeither.FromPredicate[context.Context](pred, onFalse)
return RIOR.FromPredicate[context.Context](pred, onFalse)
}
// OrElse provides an alternative [ReaderIOEither] computation if the first one fails.
// OrElse provides an alternative [ReaderIOResult] computation if the first one fails.
// The alternative is only executed if the first computation results in a Left (error).
//
// Parameters:
// - onLeft: Function that produces an alternative ReaderIOEither from the error
// - onLeft: Function that produces an alternative ReaderIOResult from the error
//
// Returns a function that provides fallback behavior for failed computations.
//
//go:inline
func OrElse[A any](onLeft Kleisli[error, A]) Operator[A, A] {
return readerioeither.OrElse[context.Context](onLeft)
return RIOR.OrElse(onLeft)
}
// Ask returns a [ReaderIOEither] that provides access to the context.
// Ask returns a [ReaderIOResult] that provides access to the context.
// This is useful for accessing the [context.Context] within a computation.
//
// Returns a ReaderIOEither that produces the context.
// Returns a ReaderIOResult that produces the context.
//
//go:inline
func Ask() ReaderIOEither[context.Context] {
return readerioeither.Ask[context.Context, error]()
func Ask() ReaderIOResult[context.Context] {
return RIOR.Ask[context.Context]()
}
// MonadChainEitherK chains a function that returns an [Either] into a [ReaderIOEither] computation.
// This is useful for integrating pure Either-returning functions into ReaderIOEither workflows.
// MonadChainEitherK chains a function that returns an [Either] into a [ReaderIOResult] computation.
// This is useful for integrating pure Either-returning functions into ReaderIOResult workflows.
//
// Parameters:
// - ma: The ReaderIOEither to chain from
// - ma: The ReaderIOResult to chain from
// - f: Function that produces an Either
//
// Returns a new ReaderIOEither with the chained computation.
// Returns a new ReaderIOResult with the chained computation.
//
//go:inline
func MonadChainEitherK[A, B any](ma ReaderIOEither[A], f func(A) Either[B]) ReaderIOEither[B] {
return readerioeither.MonadChainEitherK[context.Context](ma, f)
func MonadChainEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) ReaderIOResult[B] {
return RIOR.MonadChainEitherK(ma, f)
}
// ChainEitherK chains a function that returns an [Either] into a [ReaderIOEither] computation.
// ChainEitherK chains a function that returns an [Either] into a [ReaderIOResult] computation.
// This is the curried version of [MonadChainEitherK].
//
// Parameters:
@@ -368,21 +382,21 @@ func MonadChainEitherK[A, B any](ma ReaderIOEither[A], f func(A) Either[B]) Read
//
//go:inline
func ChainEitherK[A, B any](f func(A) Either[B]) Operator[A, B] {
return readerioeither.ChainEitherK[context.Context](f)
return RIOR.ChainEitherK[context.Context](f)
}
// MonadChainFirstEitherK chains a function that returns an [Either] but keeps the original value.
// The Either-returning function is executed for its validation/side effects only.
//
// Parameters:
// - ma: The ReaderIOEither to chain from
// - ma: The ReaderIOResult to chain from
// - f: Function that produces an Either
//
// Returns a ReaderIOEither with the original value if both computations succeed.
// Returns a ReaderIOResult with the original value if both computations succeed.
//
//go:inline
func MonadChainFirstEitherK[A, B any](ma ReaderIOEither[A], f func(A) Either[B]) ReaderIOEither[A] {
return readerioeither.MonadChainFirstEitherK[context.Context](ma, f)
func MonadChainFirstEitherK[A, B any](ma ReaderIOResult[A], f func(A) Either[B]) ReaderIOResult[A] {
return RIOR.MonadChainFirstEitherK(ma, f)
}
// ChainFirstEitherK chains a function that returns an [Either] but keeps the original value.
@@ -395,68 +409,68 @@ func MonadChainFirstEitherK[A, B any](ma ReaderIOEither[A], f func(A) Either[B])
//
//go:inline
func ChainFirstEitherK[A, B any](f func(A) Either[B]) Operator[A, A] {
return readerioeither.ChainFirstEitherK[context.Context](f)
return RIOR.ChainFirstEitherK[context.Context](f)
}
// ChainOptionK chains a function that returns an [Option] into a [ReaderIOEither] computation.
// ChainOptionK chains a function that returns an [Option] into a [ReaderIOResult] computation.
// If the Option is None, the provided error function is called.
//
// Parameters:
// - onNone: Function to generate an error when Option is None
//
// Returns a function that chains Option-returning functions into ReaderIOEither.
// Returns a function that chains Option-returning functions into ReaderIOResult.
//
//go:inline
func ChainOptionK[A, B any](onNone func() error) func(func(A) Option[B]) Operator[A, B] {
return readerioeither.ChainOptionK[context.Context, A, B](onNone)
return RIOR.ChainOptionK[context.Context, A, B](onNone)
}
// FromIOEither converts an [IOEither] into a [ReaderIOEither].
// FromIOEither converts an [IOResult] into a [ReaderIOResult].
// The resulting computation ignores the context.
//
// Parameters:
// - t: The IOEither to convert
// - t: The IOResult to convert
//
// Returns a ReaderIOEither that executes the IOEither.
// Returns a ReaderIOResult that executes the IOResult.
//
//go:inline
func FromIOEither[A any](t ioeither.IOEither[error, A]) ReaderIOEither[A] {
return readerioeither.FromIOEither[context.Context](t)
func FromIOEither[A any](t IOResult[A]) ReaderIOResult[A] {
return RIOR.FromIOEither[context.Context](t)
}
// FromIO converts an [IO] into a [ReaderIOEither].
// FromIO converts an [IO] into a [ReaderIOResult].
// The IO computation always succeeds, so it's wrapped in Right.
//
// Parameters:
// - t: The IO to convert
//
// Returns a ReaderIOEither that executes the IO and wraps the result in Right.
// Returns a ReaderIOResult that executes the IO and wraps the result in Right.
//
//go:inline
func FromIO[A any](t IO[A]) ReaderIOEither[A] {
return readerioeither.FromIO[context.Context, error](t)
func FromIO[A any](t IO[A]) ReaderIOResult[A] {
return RIOR.FromIO[context.Context](t)
}
// FromLazy converts a [Lazy] computation into a [ReaderIOEither].
// FromLazy converts a [Lazy] computation into a [ReaderIOResult].
// The Lazy computation always succeeds, so it's wrapped in Right.
// This is an alias for [FromIO] since Lazy and IO have the same structure.
//
// Parameters:
// - t: The Lazy computation to convert
//
// Returns a ReaderIOEither that executes the Lazy computation and wraps the result in Right.
// Returns a ReaderIOResult that executes the Lazy computation and wraps the result in Right.
//
//go:inline
func FromLazy[A any](t Lazy[A]) ReaderIOEither[A] {
return readerioeither.FromIO[context.Context, error](t)
func FromLazy[A any](t Lazy[A]) ReaderIOResult[A] {
return RIOR.FromIO[context.Context](t)
}
// Never returns a [ReaderIOEither] that blocks indefinitely until the context is canceled.
// Never returns a [ReaderIOResult] that blocks indefinitely until the context is canceled.
// This is useful for creating computations that wait for external cancellation signals.
//
// Returns a ReaderIOEither that waits for context cancellation and returns the cancellation error.
func Never[A any]() ReaderIOEither[A] {
return func(ctx context.Context) IOEither[A] {
// Returns a ReaderIOResult that waits for context cancellation and returns the cancellation error.
func Never[A any]() ReaderIOResult[A] {
return func(ctx context.Context) IOResult[A] {
return func() Either[A] {
<-ctx.Done()
return either.Left[A](context.Cause(ctx))
@@ -464,21 +478,21 @@ func Never[A any]() ReaderIOEither[A] {
}
}
// MonadChainIOK chains a function that returns an [IO] into a [ReaderIOEither] computation.
// MonadChainIOK chains a function that returns an [IO] into a [ReaderIOResult] computation.
// The IO computation always succeeds, so it's wrapped in Right.
//
// Parameters:
// - ma: The ReaderIOEither to chain from
// - ma: The ReaderIOResult to chain from
// - f: Function that produces an IO
//
// Returns a new ReaderIOEither with the chained IO computation.
// Returns a new ReaderIOResult with the chained IO computation.
//
//go:inline
func MonadChainIOK[A, B any](ma ReaderIOEither[A], f func(A) IO[B]) ReaderIOEither[B] {
return readerioeither.MonadChainIOK(ma, f)
func MonadChainIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult[B] {
return RIOR.MonadChainIOK(ma, f)
}
// ChainIOK chains a function that returns an [IO] into a [ReaderIOEither] computation.
// ChainIOK chains a function that returns an [IO] into a [ReaderIOResult] computation.
// This is the curried version of [MonadChainIOK].
//
// Parameters:
@@ -488,21 +502,21 @@ func MonadChainIOK[A, B any](ma ReaderIOEither[A], f func(A) IO[B]) ReaderIOEith
//
//go:inline
func ChainIOK[A, B any](f func(A) IO[B]) Operator[A, B] {
return readerioeither.ChainIOK[context.Context, error](f)
return RIOR.ChainIOK[context.Context](f)
}
// MonadChainFirstIOK chains a function that returns an [IO] but keeps the original value.
// The IO computation is executed for its side effects only.
//
// Parameters:
// - ma: The ReaderIOEither to chain from
// - ma: The ReaderIOResult to chain from
// - f: Function that produces an IO
//
// Returns a ReaderIOEither with the original value after executing the IO.
// Returns a ReaderIOResult with the original value after executing the IO.
//
//go:inline
func MonadChainFirstIOK[A, B any](ma ReaderIOEither[A], f func(A) IO[B]) ReaderIOEither[A] {
return readerioeither.MonadChainFirstIOK(ma, f)
func MonadChainFirstIOK[A, B any](ma ReaderIOResult[A], f func(A) IO[B]) ReaderIOResult[A] {
return RIOR.MonadChainFirstIOK(ma, f)
}
// ChainFirstIOK chains a function that returns an [IO] but keeps the original value.
@@ -515,20 +529,20 @@ func MonadChainFirstIOK[A, B any](ma ReaderIOEither[A], f func(A) IO[B]) ReaderI
//
//go:inline
func ChainFirstIOK[A, B any](f func(A) IO[B]) Operator[A, A] {
return readerioeither.ChainFirstIOK[context.Context, error](f)
return RIOR.ChainFirstIOK[context.Context](f)
}
// ChainIOEitherK chains a function that returns an [IOEither] into a [ReaderIOEither] computation.
// This is useful for integrating IOEither-returning functions into ReaderIOEither workflows.
// ChainIOEitherK chains a function that returns an [IOResult] into a [ReaderIOResult] computation.
// This is useful for integrating IOResult-returning functions into ReaderIOResult workflows.
//
// Parameters:
// - f: Function that produces an IOEither
// - f: Function that produces an IOResult
//
// Returns a function that chains the IOEither-returning function.
// Returns a function that chains the IOResult-returning function.
//
//go:inline
func ChainIOEitherK[A, B any](f func(A) ioeither.IOEither[error, B]) Operator[A, B] {
return readerioeither.ChainIOEitherK[context.Context](f)
func ChainIOEitherK[A, B any](f func(A) IOResult[B]) Operator[A, B] {
return RIOR.ChainIOEitherK[context.Context](f)
}
// Delay creates an operation that delays execution by the specified duration.
@@ -537,10 +551,10 @@ func ChainIOEitherK[A, B any](f func(A) ioeither.IOEither[error, B]) Operator[A,
// Parameters:
// - delay: The duration to wait before executing the computation
//
// Returns a function that delays a ReaderIOEither computation.
// Returns a function that delays a ReaderIOResult computation.
func Delay[A any](delay time.Duration) Operator[A, A] {
return func(ma ReaderIOEither[A]) ReaderIOEither[A] {
return func(ctx context.Context) IOEither[A] {
return func(ma ReaderIOResult[A]) ReaderIOResult[A] {
return func(ctx context.Context) IOResult[A] {
return func() Either[A] {
// manage the timeout
timeoutCtx, cancelTimeout := context.WithTimeout(ctx, delay)
@@ -563,8 +577,8 @@ func Delay[A any](delay time.Duration) Operator[A, A] {
// Parameters:
// - delay: The duration to wait before returning the time
//
// Returns a ReaderIOEither that produces the current time after the delay.
func Timer(delay time.Duration) ReaderIOEither[time.Time] {
// Returns a ReaderIOResult that produces the current time after the delay.
func Timer(delay time.Duration) ReaderIOResult[time.Time] {
return function.Pipe2(
io.Now,
FromIO[time.Time],
@@ -572,149 +586,149 @@ func Timer(delay time.Duration) ReaderIOEither[time.Time] {
)
}
// Defer creates a [ReaderIOEither] by lazily generating a new computation each time it's executed.
// Defer creates a [ReaderIOResult] by lazily generating a new computation each time it's executed.
// This is useful for creating computations that should be re-evaluated on each execution.
//
// Parameters:
// - gen: Lazy generator function that produces a ReaderIOEither
// - gen: Lazy generator function that produces a ReaderIOResult
//
// Returns a ReaderIOEither that generates a fresh computation on each execution.
// Returns a ReaderIOResult that generates a fresh computation on each execution.
//
//go:inline
func Defer[A any](gen Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
return readerioeither.Defer(gen)
func Defer[A any](gen Lazy[ReaderIOResult[A]]) ReaderIOResult[A] {
return RIOR.Defer(gen)
}
// TryCatch wraps a function that returns a tuple (value, error) into a [ReaderIOEither].
// This is the standard way to convert Go error-returning functions into ReaderIOEither.
// TryCatch wraps a function that returns a tuple (value) into a [ReaderIOResult].
// This is the standard way to convert Go error-returning functions into ReaderIOResult.
//
// Parameters:
// - f: Function that takes a context and returns a function producing (value, error)
// - f: Function that takes a context and returns a function producing (value)
//
// Returns a ReaderIOEither that wraps the error-returning function.
// Returns a ReaderIOResult that wraps the error-returning function.
//
//go:inline
func TryCatch[A any](f func(context.Context) func() (A, error)) ReaderIOEither[A] {
return readerioeither.TryCatch(f, errors.IdentityError)
func TryCatch[A any](f func(context.Context) func() (A, error)) ReaderIOResult[A] {
return RIOR.TryCatch(f, errors.IdentityError)
}
// MonadAlt provides an alternative [ReaderIOEither] if the first one fails.
// MonadAlt provides an alternative [ReaderIOResult] if the first one fails.
// The alternative is lazily evaluated only if needed.
//
// Parameters:
// - first: The primary ReaderIOEither to try
// - second: Lazy alternative ReaderIOEither to use if first fails
// - first: The primary ReaderIOResult to try
// - second: Lazy alternative ReaderIOResult to use if first fails
//
// Returns a ReaderIOEither that tries the first, then the second if first fails.
// Returns a ReaderIOResult that tries the first, then the second if first fails.
//
//go:inline
func MonadAlt[A any](first ReaderIOEither[A], second Lazy[ReaderIOEither[A]]) ReaderIOEither[A] {
return readerioeither.MonadAlt(first, second)
func MonadAlt[A any](first ReaderIOResult[A], second Lazy[ReaderIOResult[A]]) ReaderIOResult[A] {
return RIOR.MonadAlt(first, second)
}
// Alt provides an alternative [ReaderIOEither] if the first one fails.
// Alt provides an alternative [ReaderIOResult] if the first one fails.
// This is the curried version of [MonadAlt].
//
// Parameters:
// - second: Lazy alternative ReaderIOEither to use if first fails
// - second: Lazy alternative ReaderIOResult to use if first fails
//
// Returns a function that provides fallback behavior.
//
//go:inline
func Alt[A any](second Lazy[ReaderIOEither[A]]) Operator[A, A] {
return readerioeither.Alt(second)
func Alt[A any](second Lazy[ReaderIOResult[A]]) Operator[A, A] {
return RIOR.Alt(second)
}
// Memoize computes the value of the provided [ReaderIOEither] monad lazily but exactly once.
// Memoize computes the value of the provided [ReaderIOResult] monad lazily but exactly once.
// The context used to compute the value is the context of the first call, so do not use this
// method if the value has a functional dependency on the content of the context.
//
// Parameters:
// - rdr: The ReaderIOEither to memoize
// - rdr: The ReaderIOResult to memoize
//
// Returns a ReaderIOEither that caches its result after the first execution.
// Returns a ReaderIOResult that caches its result after the first execution.
//
//go:inline
func Memoize[A any](rdr ReaderIOEither[A]) ReaderIOEither[A] {
return readerioeither.Memoize(rdr)
func Memoize[A any](rdr ReaderIOResult[A]) ReaderIOResult[A] {
return RIOR.Memoize(rdr)
}
// Flatten converts a nested [ReaderIOEither] into a flat [ReaderIOEither].
// Flatten converts a nested [ReaderIOResult] into a flat [ReaderIOResult].
// This is equivalent to [MonadChain] with the identity function.
//
// Parameters:
// - rdr: The nested ReaderIOEither to flatten
// - rdr: The nested ReaderIOResult to flatten
//
// Returns a flattened ReaderIOEither.
// Returns a flattened ReaderIOResult.
//
//go:inline
func Flatten[A any](rdr ReaderIOEither[ReaderIOEither[A]]) ReaderIOEither[A] {
return readerioeither.Flatten(rdr)
func Flatten[A any](rdr ReaderIOResult[ReaderIOResult[A]]) ReaderIOResult[A] {
return RIOR.Flatten(rdr)
}
// MonadFlap applies a value to a function wrapped in a [ReaderIOEither].
// MonadFlap applies a value to a function wrapped in a [ReaderIOResult].
// This is the reverse of [MonadAp], useful in certain composition scenarios.
//
// Parameters:
// - fab: ReaderIOEither containing a function
// - fab: ReaderIOResult containing a function
// - a: The value to apply to the function
//
// Returns a ReaderIOEither with the function applied to the value.
// Returns a ReaderIOResult with the function applied to the value.
//
//go:inline
func MonadFlap[B, A any](fab ReaderIOEither[func(A) B], a A) ReaderIOEither[B] {
return readerioeither.MonadFlap(fab, a)
func MonadFlap[B, A any](fab ReaderIOResult[func(A) B], a A) ReaderIOResult[B] {
return RIOR.MonadFlap(fab, a)
}
// Flap applies a value to a function wrapped in a [ReaderIOEither].
// Flap applies a value to a function wrapped in a [ReaderIOResult].
// This is the curried version of [MonadFlap].
//
// Parameters:
// - a: The value to apply to the function
//
// Returns a function that applies the value to a ReaderIOEither function.
// Returns a function that applies the value to a ReaderIOResult function.
//
//go:inline
func Flap[B, A any](a A) Operator[func(A) B, B] {
return readerioeither.Flap[context.Context, error, B](a)
return RIOR.Flap[context.Context, B](a)
}
// Fold handles both success and error cases of a [ReaderIOEither] by providing handlers for each.
// Both handlers return ReaderIOEither, allowing for further composition.
// Fold handles both success and error cases of a [ReaderIOResult] by providing handlers for each.
// Both handlers return ReaderIOResult, allowing for further composition.
//
// Parameters:
// - onLeft: Handler for error case
// - onRight: Handler for success case
//
// Returns a function that folds a ReaderIOEither into a new ReaderIOEither.
// Returns a function that folds a ReaderIOResult into a new ReaderIOResult.
//
//go:inline
func Fold[A, B any](onLeft Kleisli[error, B], onRight Kleisli[A, B]) Operator[A, B] {
return readerioeither.Fold(onLeft, onRight)
return RIOR.Fold(onLeft, onRight)
}
// GetOrElse extracts the value from a [ReaderIOEither], providing a default via a function if it fails.
// GetOrElse extracts the value from a [ReaderIOResult], providing a default via a function if it fails.
// The result is a [ReaderIO] that always succeeds.
//
// Parameters:
// - onLeft: Function to provide a default value from the error
//
// Returns a function that converts a ReaderIOEither to a ReaderIO.
// Returns a function that converts a ReaderIOResult to a ReaderIO.
//
//go:inline
func GetOrElse[A any](onLeft func(error) ReaderIO[A]) func(ReaderIOEither[A]) ReaderIO[A] {
return readerioeither.GetOrElse(onLeft)
func GetOrElse[A any](onLeft func(error) ReaderIO[A]) func(ReaderIOResult[A]) ReaderIO[A] {
return RIOR.GetOrElse(onLeft)
}
// OrLeft transforms the error of a [ReaderIOEither] using the provided function.
// OrLeft transforms the error of a [ReaderIOResult] using the provided function.
// The success value is left unchanged.
//
// Parameters:
// - onLeft: Function to transform the error
//
// Returns a function that transforms the error of a ReaderIOEither.
// Returns a function that transforms the error of a ReaderIOResult.
//
//go:inline
func OrLeft[A any](onLeft func(error) ReaderIO[error]) Operator[A, A] {
return readerioeither.OrLeft[A](onLeft)
return RIOR.OrLeft[A](onLeft)
}

238
v2/context/readerioeither/reader_bench_test.go → v2/context/readerioresult/reader_bench_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -30,7 +30,7 @@ var (
benchErr = errors.New("benchmark error")
benchCtx = context.Background()
benchResult Either[int]
benchRIOE ReaderIOEither[int]
benchRIOE ReaderIOResult[int]
benchInt int
)
@@ -45,14 +45,14 @@ func BenchmarkLeft(b *testing.B) {
func BenchmarkRight(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = Right[int](42)
benchRIOE = Right(42)
}
}
func BenchmarkOf(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = Of[int](42)
benchRIOE = Of(42)
}
}
@@ -78,7 +78,7 @@ func BenchmarkFromIO(b *testing.B) {
io := func() int { return 42 }
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = FromIO[int](io)
benchRIOE = FromIO(io)
}
}
@@ -100,7 +100,7 @@ func BenchmarkFromIOEither_Left(b *testing.B) {
// Benchmark execution
func BenchmarkExecute_Right(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -118,7 +118,7 @@ func BenchmarkExecute_Left(b *testing.B) {
}
func BenchmarkExecute_WithContext(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
ctx, cancel := context.WithCancel(benchCtx)
defer cancel()
b.ResetTimer()
@@ -130,7 +130,7 @@ func BenchmarkExecute_WithContext(b *testing.B) {
// Benchmark functor operations
func BenchmarkMonadMap_Right(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
mapper := func(a int) int { return a * 2 }
b.ResetTimer()
b.ReportAllocs()
@@ -150,8 +150,8 @@ func BenchmarkMonadMap_Left(b *testing.B) {
}
func BenchmarkMap_Right(b *testing.B) {
rioe := Right[int](42)
mapper := Map[int](func(a int) int { return a * 2 })
rioe := Right(42)
mapper := Map(func(a int) int { return a * 2 })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -161,7 +161,7 @@ func BenchmarkMap_Right(b *testing.B) {
func BenchmarkMap_Left(b *testing.B) {
rioe := Left[int](benchErr)
mapper := Map[int](func(a int) int { return a * 2 })
mapper := Map(func(a int) int { return a * 2 })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -170,7 +170,7 @@ func BenchmarkMap_Left(b *testing.B) {
}
func BenchmarkMapTo_Right(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
mapper := MapTo[int](99)
b.ResetTimer()
b.ReportAllocs()
@@ -181,8 +181,8 @@ func BenchmarkMapTo_Right(b *testing.B) {
// Benchmark monad operations
func BenchmarkMonadChain_Right(b *testing.B) {
rioe := Right[int](42)
chainer := func(a int) ReaderIOEither[int] { return Right[int](a * 2) }
rioe := Right(42)
chainer := func(a int) ReaderIOResult[int] { return Right(a * 2) }
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -192,7 +192,7 @@ func BenchmarkMonadChain_Right(b *testing.B) {
func BenchmarkMonadChain_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := func(a int) ReaderIOEither[int] { return Right[int](a * 2) }
chainer := func(a int) ReaderIOResult[int] { return Right(a * 2) }
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -201,8 +201,8 @@ func BenchmarkMonadChain_Left(b *testing.B) {
}
func BenchmarkChain_Right(b *testing.B) {
rioe := Right[int](42)
chainer := Chain[int](func(a int) ReaderIOEither[int] { return Right[int](a * 2) })
rioe := Right(42)
chainer := Chain(func(a int) ReaderIOResult[int] { return Right(a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -212,7 +212,7 @@ func BenchmarkChain_Right(b *testing.B) {
func BenchmarkChain_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := Chain[int](func(a int) ReaderIOEither[int] { return Right[int](a * 2) })
chainer := Chain(func(a int) ReaderIOResult[int] { return Right(a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -221,8 +221,8 @@ func BenchmarkChain_Left(b *testing.B) {
}
func BenchmarkChainFirst_Right(b *testing.B) {
rioe := Right[int](42)
chainer := ChainFirst[int](func(a int) ReaderIOEither[string] { return Right[string]("logged") })
rioe := Right(42)
chainer := ChainFirst(func(a int) ReaderIOResult[string] { return Right("logged") })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -232,7 +232,7 @@ func BenchmarkChainFirst_Right(b *testing.B) {
func BenchmarkChainFirst_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := ChainFirst[int](func(a int) ReaderIOEither[string] { return Right[string]("logged") })
chainer := ChainFirst(func(a int) ReaderIOResult[string] { return Right("logged") })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -241,7 +241,7 @@ func BenchmarkChainFirst_Left(b *testing.B) {
}
func BenchmarkFlatten_Right(b *testing.B) {
nested := Right[ReaderIOEither[int]](Right[int](42))
nested := Right(Right(42))
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -250,7 +250,7 @@ func BenchmarkFlatten_Right(b *testing.B) {
}
func BenchmarkFlatten_Left(b *testing.B) {
nested := Left[ReaderIOEither[int]](benchErr)
nested := Left[ReaderIOResult[int]](benchErr)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -260,8 +260,8 @@ func BenchmarkFlatten_Left(b *testing.B) {
// Benchmark applicative operations
func BenchmarkMonadApSeq_RightRight(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fa := Right[int](42)
fab := Right(func(a int) int { return a * 2 })
fa := Right(42)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -270,7 +270,7 @@ func BenchmarkMonadApSeq_RightRight(b *testing.B) {
}
func BenchmarkMonadApSeq_RightLeft(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fab := Right(func(a int) int { return a * 2 })
fa := Left[int](benchErr)
b.ResetTimer()
b.ReportAllocs()
@@ -281,7 +281,7 @@ func BenchmarkMonadApSeq_RightLeft(b *testing.B) {
func BenchmarkMonadApSeq_LeftRight(b *testing.B) {
fab := Left[func(int) int](benchErr)
fa := Right[int](42)
fa := Right(42)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -290,8 +290,8 @@ func BenchmarkMonadApSeq_LeftRight(b *testing.B) {
}
func BenchmarkMonadApPar_RightRight(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fa := Right[int](42)
fab := Right(func(a int) int { return a * 2 })
fa := Right(42)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -300,7 +300,7 @@ func BenchmarkMonadApPar_RightRight(b *testing.B) {
}
func BenchmarkMonadApPar_RightLeft(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fab := Right(func(a int) int { return a * 2 })
fa := Left[int](benchErr)
b.ResetTimer()
b.ReportAllocs()
@@ -311,7 +311,7 @@ func BenchmarkMonadApPar_RightLeft(b *testing.B) {
func BenchmarkMonadApPar_LeftRight(b *testing.B) {
fab := Left[func(int) int](benchErr)
fa := Right[int](42)
fa := Right(42)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -321,8 +321,8 @@ func BenchmarkMonadApPar_LeftRight(b *testing.B) {
// Benchmark execution of applicative operations
func BenchmarkExecuteApSeq_RightRight(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fa := Right[int](42)
fab := Right(func(a int) int { return a * 2 })
fa := Right(42)
rioe := MonadApSeq(fab, fa)
b.ResetTimer()
b.ReportAllocs()
@@ -332,8 +332,8 @@ func BenchmarkExecuteApSeq_RightRight(b *testing.B) {
}
func BenchmarkExecuteApPar_RightRight(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fa := Right[int](42)
fab := Right(func(a int) int { return a * 2 })
fa := Right(42)
rioe := MonadApPar(fab, fa)
b.ResetTimer()
b.ReportAllocs()
@@ -344,8 +344,8 @@ func BenchmarkExecuteApPar_RightRight(b *testing.B) {
// Benchmark alternative operations
func BenchmarkAlt_RightRight(b *testing.B) {
rioe := Right[int](42)
alternative := Alt[int](func() ReaderIOEither[int] { return Right[int](99) })
rioe := Right(42)
alternative := Alt(func() ReaderIOResult[int] { return Right(99) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -355,7 +355,7 @@ func BenchmarkAlt_RightRight(b *testing.B) {
func BenchmarkAlt_LeftRight(b *testing.B) {
rioe := Left[int](benchErr)
alternative := Alt[int](func() ReaderIOEither[int] { return Right[int](99) })
alternative := Alt(func() ReaderIOResult[int] { return Right(99) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -364,8 +364,8 @@ func BenchmarkAlt_LeftRight(b *testing.B) {
}
func BenchmarkOrElse_Right(b *testing.B) {
rioe := Right[int](42)
recover := OrElse[int](func(e error) ReaderIOEither[int] { return Right[int](0) })
rioe := Right(42)
recover := OrElse(func(e error) ReaderIOResult[int] { return Right(0) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -375,7 +375,7 @@ func BenchmarkOrElse_Right(b *testing.B) {
func BenchmarkOrElse_Left(b *testing.B) {
rioe := Left[int](benchErr)
recover := OrElse[int](func(e error) ReaderIOEither[int] { return Right[int](0) })
recover := OrElse(func(e error) ReaderIOResult[int] { return Right(0) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -385,8 +385,8 @@ func BenchmarkOrElse_Left(b *testing.B) {
// Benchmark chain operations with different types
func BenchmarkChainEitherK_Right(b *testing.B) {
rioe := Right[int](42)
chainer := ChainEitherK[int](func(a int) Either[int] { return E.Right[error](a * 2) })
rioe := Right(42)
chainer := ChainEitherK(func(a int) Either[int] { return E.Right[error](a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -396,7 +396,7 @@ func BenchmarkChainEitherK_Right(b *testing.B) {
func BenchmarkChainEitherK_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := ChainEitherK[int](func(a int) Either[int] { return E.Right[error](a * 2) })
chainer := ChainEitherK(func(a int) Either[int] { return E.Right[error](a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -405,8 +405,8 @@ func BenchmarkChainEitherK_Left(b *testing.B) {
}
func BenchmarkChainIOK_Right(b *testing.B) {
rioe := Right[int](42)
chainer := ChainIOK[int](func(a int) func() int { return func() int { return a * 2 } })
rioe := Right(42)
chainer := ChainIOK(func(a int) func() int { return func() int { return a * 2 } })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -416,7 +416,7 @@ func BenchmarkChainIOK_Right(b *testing.B) {
func BenchmarkChainIOK_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := ChainIOK[int](func(a int) func() int { return func() int { return a * 2 } })
chainer := ChainIOK(func(a int) func() int { return func() int { return a * 2 } })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -425,8 +425,8 @@ func BenchmarkChainIOK_Left(b *testing.B) {
}
func BenchmarkChainIOEitherK_Right(b *testing.B) {
rioe := Right[int](42)
chainer := ChainIOEitherK[int](func(a int) IOEither[int] { return IOE.Of[error](a * 2) })
rioe := Right(42)
chainer := ChainIOEitherK(func(a int) IOEither[int] { return IOE.Of[error](a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -436,7 +436,7 @@ func BenchmarkChainIOEitherK_Right(b *testing.B) {
func BenchmarkChainIOEitherK_Left(b *testing.B) {
rioe := Left[int](benchErr)
chainer := ChainIOEitherK[int](func(a int) IOEither[int] { return IOE.Of[error](a * 2) })
chainer := ChainIOEitherK(func(a int) IOEither[int] { return IOE.Of[error](a * 2) })
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -453,7 +453,7 @@ func BenchmarkAsk(b *testing.B) {
}
func BenchmarkDefer(b *testing.B) {
gen := func() ReaderIOEither[int] { return Right[int](42) }
gen := func() ReaderIOResult[int] { return Right(42) }
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = Defer(gen)
@@ -461,7 +461,7 @@ func BenchmarkDefer(b *testing.B) {
}
func BenchmarkMemoize(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = Memoize(rioe)
@@ -470,7 +470,7 @@ func BenchmarkMemoize(b *testing.B) {
// Benchmark delay operations
func BenchmarkDelay_Construction(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = Delay[int](time.Millisecond)(rioe)
@@ -531,13 +531,13 @@ func BenchmarkExecuteTryCatch_Error(b *testing.B) {
// Benchmark pipeline operations
func BenchmarkPipeline_Map_Right(b *testing.B) {
rioe := Right[int](21)
rioe := Right(21)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe1(
rioe,
Map[int](func(x int) int { return x * 2 }),
Map(func(x int) int { return x * 2 }),
)
}
}
@@ -549,19 +549,19 @@ func BenchmarkPipeline_Map_Left(b *testing.B) {
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe1(
rioe,
Map[int](func(x int) int { return x * 2 }),
Map(func(x int) int { return x * 2 }),
)
}
}
func BenchmarkPipeline_Chain_Right(b *testing.B) {
rioe := Right[int](21)
rioe := Right(21)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe1(
rioe,
Chain[int](func(x int) ReaderIOEither[int] { return Right[int](x * 2) }),
Chain(func(x int) ReaderIOResult[int] { return Right[int](x * 2) }),
)
}
}
@@ -573,21 +573,21 @@ func BenchmarkPipeline_Chain_Left(b *testing.B) {
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe1(
rioe,
Chain[int](func(x int) ReaderIOEither[int] { return Right[int](x * 2) }),
Chain(func(x int) ReaderIOResult[int] { return Right[int](x * 2) }),
)
}
}
func BenchmarkPipeline_Complex_Right(b *testing.B) {
rioe := Right[int](10)
rioe := Right(10)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe3(
rioe,
Map[int](func(x int) int { return x * 2 }),
Chain[int](func(x int) ReaderIOEither[int] { return Right[int](x + 1) }),
Map[int](func(x int) int { return x * 2 }),
Map(func(x int) int { return x * 2 }),
Chain(func(x int) ReaderIOResult[int] { return Right[int](x + 1) }),
Map(func(x int) int { return x * 2 }),
)
}
}
@@ -599,19 +599,19 @@ func BenchmarkPipeline_Complex_Left(b *testing.B) {
for i := 0; i < b.N; i++ {
benchRIOE = F.Pipe3(
rioe,
Map[int](func(x int) int { return x * 2 }),
Chain[int](func(x int) ReaderIOEither[int] { return Right[int](x + 1) }),
Map[int](func(x int) int { return x * 2 }),
Map(func(x int) int { return x * 2 }),
Chain(func(x int) ReaderIOResult[int] { return Right[int](x + 1) }),
Map(func(x int) int { return x * 2 }),
)
}
}
func BenchmarkExecutePipeline_Complex_Right(b *testing.B) {
rioe := F.Pipe3(
Right[int](10),
Map[int](func(x int) int { return x * 2 }),
Chain[int](func(x int) ReaderIOEither[int] { return Right[int](x + 1) }),
Map[int](func(x int) int { return x * 2 }),
Right(10),
Map(func(x int) int { return x * 2 }),
Chain(func(x int) ReaderIOResult[int] { return Right[int](x + 1) }),
Map(func(x int) int { return x * 2 }),
)
b.ResetTimer()
b.ReportAllocs()
@@ -632,12 +632,12 @@ func BenchmarkDo(b *testing.B) {
func BenchmarkBind_Right(b *testing.B) {
type State struct{ value int }
initial := Do(State{})
binder := Bind[State, State](
binder := Bind(
func(v int) func(State) State {
return func(s State) State { return State{value: v} }
},
func(s State) ReaderIOEither[int] {
return Right[int](42)
func(s State) ReaderIOResult[int] {
return Right(42)
},
)
b.ResetTimer()
@@ -649,8 +649,8 @@ func BenchmarkBind_Right(b *testing.B) {
func BenchmarkLet_Right(b *testing.B) {
type State struct{ value int }
initial := Right[State](State{value: 10})
letter := Let[State, State](
initial := Right(State{value: 10})
letter := Let(
func(v int) func(State) State {
return func(s State) State { return State{value: s.value + v} }
},
@@ -665,12 +665,12 @@ func BenchmarkLet_Right(b *testing.B) {
func BenchmarkApS_Right(b *testing.B) {
type State struct{ value int }
initial := Right[State](State{value: 10})
aps := ApS[State, State](
initial := Right(State{value: 10})
aps := ApS(
func(v int) func(State) State {
return func(s State) State { return State{value: v} }
},
Right[int](42),
Right(42),
)
b.ResetTimer()
b.ReportAllocs()
@@ -682,8 +682,8 @@ func BenchmarkApS_Right(b *testing.B) {
// Benchmark traverse operations
func BenchmarkTraverseArray_Empty(b *testing.B) {
arr := []int{}
traverser := TraverseArray[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseArray(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -694,8 +694,8 @@ func BenchmarkTraverseArray_Empty(b *testing.B) {
func BenchmarkTraverseArray_Small(b *testing.B) {
arr := []int{1, 2, 3}
traverser := TraverseArray[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseArray(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -709,8 +709,8 @@ func BenchmarkTraverseArray_Medium(b *testing.B) {
for i := range arr {
arr[i] = i
}
traverser := TraverseArray[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseArray(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -721,8 +721,8 @@ func BenchmarkTraverseArray_Medium(b *testing.B) {
func BenchmarkTraverseArraySeq_Small(b *testing.B) {
arr := []int{1, 2, 3}
traverser := TraverseArraySeq[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseArraySeq(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -733,8 +733,8 @@ func BenchmarkTraverseArraySeq_Small(b *testing.B) {
func BenchmarkTraverseArrayPar_Small(b *testing.B) {
arr := []int{1, 2, 3}
traverser := TraverseArrayPar[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseArrayPar(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -744,10 +744,10 @@ func BenchmarkTraverseArrayPar_Small(b *testing.B) {
}
func BenchmarkSequenceArray_Small(b *testing.B) {
arr := []ReaderIOEither[int]{
Right[int](1),
Right[int](2),
Right[int](3),
arr := []ReaderIOResult[int]{
Right(1),
Right(2),
Right(3),
}
b.ResetTimer()
b.ReportAllocs()
@@ -758,8 +758,8 @@ func BenchmarkSequenceArray_Small(b *testing.B) {
func BenchmarkExecuteTraverseArray_Small(b *testing.B) {
arr := []int{1, 2, 3}
rioe := TraverseArray[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
rioe := TraverseArray(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(arr)
b.ResetTimer()
b.ReportAllocs()
@@ -770,8 +770,8 @@ func BenchmarkExecuteTraverseArray_Small(b *testing.B) {
func BenchmarkExecuteTraverseArraySeq_Small(b *testing.B) {
arr := []int{1, 2, 3}
rioe := TraverseArraySeq[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
rioe := TraverseArraySeq(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(arr)
b.ResetTimer()
b.ReportAllocs()
@@ -782,8 +782,8 @@ func BenchmarkExecuteTraverseArraySeq_Small(b *testing.B) {
func BenchmarkExecuteTraverseArrayPar_Small(b *testing.B) {
arr := []int{1, 2, 3}
rioe := TraverseArrayPar[int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
rioe := TraverseArrayPar(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(arr)
b.ResetTimer()
b.ReportAllocs()
@@ -795,8 +795,8 @@ func BenchmarkExecuteTraverseArrayPar_Small(b *testing.B) {
// Benchmark record operations
func BenchmarkTraverseRecord_Small(b *testing.B) {
rec := map[string]int{"a": 1, "b": 2, "c": 3}
traverser := TraverseRecord[string, int](func(x int) ReaderIOEither[int] {
return Right[int](x * 2)
traverser := TraverseRecord[string](func(x int) ReaderIOResult[int] {
return Right(x * 2)
})
b.ResetTimer()
b.ReportAllocs()
@@ -806,10 +806,10 @@ func BenchmarkTraverseRecord_Small(b *testing.B) {
}
func BenchmarkSequenceRecord_Small(b *testing.B) {
rec := map[string]ReaderIOEither[int]{
"a": Right[int](1),
"b": Right[int](2),
"c": Right[int](3),
rec := map[string]ReaderIOResult[int]{
"a": Right(1),
"b": Right(2),
"c": Right(3),
}
b.ResetTimer()
b.ReportAllocs()
@@ -820,22 +820,22 @@ func BenchmarkSequenceRecord_Small(b *testing.B) {
// Benchmark resource management
func BenchmarkWithResource_Success(b *testing.B) {
acquire := Right[int](42)
release := func(int) ReaderIOEither[int] { return Right[int](0) }
body := func(x int) ReaderIOEither[int] { return Right[int](x * 2) }
acquire := Right(42)
release := func(int) ReaderIOResult[int] { return Right(0) }
body := func(x int) ReaderIOResult[int] { return Right(x * 2) }
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
_ = WithResource[int, int, int](acquire, release)(body)
_ = WithResource[int](acquire, release)(body)
}
}
func BenchmarkExecuteWithResource_Success(b *testing.B) {
acquire := Right[int](42)
release := func(int) ReaderIOEither[int] { return Right[int](0) }
body := func(x int) ReaderIOEither[int] { return Right[int](x * 2) }
rioe := WithResource[int, int, int](acquire, release)(body)
acquire := Right(42)
release := func(int) ReaderIOResult[int] { return Right(0) }
body := func(x int) ReaderIOResult[int] { return Right(x * 2) }
rioe := WithResource[int](acquire, release)(body)
b.ResetTimer()
b.ReportAllocs()
@@ -845,10 +845,10 @@ func BenchmarkExecuteWithResource_Success(b *testing.B) {
}
func BenchmarkExecuteWithResource_ErrorInBody(b *testing.B) {
acquire := Right[int](42)
release := func(int) ReaderIOEither[int] { return Right[int](0) }
body := func(x int) ReaderIOEither[int] { return Left[int](benchErr) }
rioe := WithResource[int, int, int](acquire, release)(body)
acquire := Right(42)
release := func(int) ReaderIOResult[int] { return Right(0) }
body := func(x int) ReaderIOResult[int] { return Left[int](benchErr) }
rioe := WithResource[int](acquire, release)(body)
b.ResetTimer()
b.ReportAllocs()
@@ -859,7 +859,7 @@ func BenchmarkExecuteWithResource_ErrorInBody(b *testing.B) {
// Benchmark context cancellation
func BenchmarkExecute_CanceledContext(b *testing.B) {
rioe := Right[int](42)
rioe := Right(42)
ctx, cancel := context.WithCancel(benchCtx)
cancel() // Cancel immediately
@@ -871,8 +871,8 @@ func BenchmarkExecute_CanceledContext(b *testing.B) {
}
func BenchmarkExecuteApPar_CanceledContext(b *testing.B) {
fab := Right[func(int) int](func(a int) int { return a * 2 })
fa := Right[int](42)
fab := Right(func(a int) int { return a * 2 })
fa := Right(42)
rioe := MonadApPar(fab, fa)
ctx, cancel := context.WithCancel(benchCtx)
cancel() // Cancel immediately

30
v2/context/readerioeither/reader_extended_test.go → v2/context/readerioresult/reader_extended_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -93,20 +93,20 @@ func TestMonadChain(t *testing.T) {
ctx := t.Context()
// Test with Right
result := MonadChain(Right(42), func(x int) ReaderIOEither[int] {
result := MonadChain(Right(42), func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(ctx)()
assert.Equal(t, E.Right[error](84), result)
// Test with Left
err := errors.New("test error")
result = MonadChain(Left[int](err), func(x int) ReaderIOEither[int] {
result = MonadChain(Left[int](err), func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(ctx)()
assert.Equal(t, E.Left[int](err), result)
// Test where function returns Left
result = MonadChain(Right(42), func(x int) ReaderIOEither[int] {
result = MonadChain(Right(42), func(x int) ReaderIOResult[int] {
return Left[int](errors.New("chain error"))
})(ctx)()
assert.True(t, E.IsLeft(result))
@@ -116,20 +116,20 @@ func TestMonadChainFirst(t *testing.T) {
ctx := t.Context()
// Test with Right
result := MonadChainFirst(Right(42), func(x int) ReaderIOEither[string] {
result := MonadChainFirst(Right(42), func(x int) ReaderIOResult[string] {
return Right("ignored")
})(ctx)()
assert.Equal(t, E.Right[error](42), result)
// Test with Left in first
err := errors.New("test error")
result = MonadChainFirst(Left[int](err), func(x int) ReaderIOEither[string] {
result = MonadChainFirst(Left[int](err), func(x int) ReaderIOResult[string] {
return Right("ignored")
})(ctx)()
assert.Equal(t, E.Left[int](err), result)
// Test with Left in second
result = MonadChainFirst(Right(42), func(x int) ReaderIOEither[string] {
result = MonadChainFirst(Right(42), func(x int) ReaderIOResult[string] {
return Left[string](errors.New("chain error"))
})(ctx)()
assert.True(t, E.IsLeft(result))
@@ -331,7 +331,7 @@ func TestDefer(t *testing.T) {
ctx := t.Context()
count := 0
gen := func() ReaderIOEither[int] {
gen := func() ReaderIOResult[int] {
count++
return Right(count)
}
@@ -372,14 +372,14 @@ func TestMonadAlt(t *testing.T) {
ctx := t.Context()
// Test with Right (alternative not called)
result := MonadAlt(Right(42), func() ReaderIOEither[int] {
result := MonadAlt(Right(42), func() ReaderIOResult[int] {
return Right(99)
})(ctx)()
assert.Equal(t, E.Right[error](42), result)
// Test with Left (alternative called)
err := errors.New("test error")
result = MonadAlt(Left[int](err), func() ReaderIOEither[int] {
result = MonadAlt(Left[int](err), func() ReaderIOResult[int] {
return Right(99)
})(ctx)()
assert.Equal(t, E.Right[error](99), result)
@@ -446,7 +446,7 @@ func TestSequenceArray(t *testing.T) {
ctx := t.Context()
// Test with all Right
arr := []ReaderIOEither[int]{Right(1), Right(2), Right(3)}
arr := []ReaderIOResult[int]{Right(1), Right(2), Right(3)}
result := SequenceArray(arr)(ctx)()
assert.True(t, E.IsRight(result))
vals, _ := E.Unwrap(result)
@@ -454,7 +454,7 @@ func TestSequenceArray(t *testing.T) {
// Test with one Left
err := errors.New("test error")
arr = []ReaderIOEither[int]{Right(1), Left[int](err), Right(3)}
arr = []ReaderIOResult[int]{Right(1), Left[int](err), Right(3)}
result = SequenceArray(arr)(ctx)()
assert.True(t, E.IsLeft(result))
}
@@ -464,7 +464,7 @@ func TestTraverseArray(t *testing.T) {
// Test transformation
arr := []int{1, 2, 3}
result := TraverseArray(func(x int) ReaderIOEither[int] {
result := TraverseArray(func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(arr)(ctx)()
assert.True(t, E.IsRight(result))
@@ -476,7 +476,7 @@ func TestSequenceRecord(t *testing.T) {
ctx := t.Context()
// Test with all Right
rec := map[string]ReaderIOEither[int]{
rec := map[string]ReaderIOResult[int]{
"a": Right(1),
"b": Right(2),
}
@@ -492,7 +492,7 @@ func TestTraverseRecord(t *testing.T) {
// Test transformation
rec := map[string]int{"a": 1, "b": 2}
result := TraverseRecord[string](func(x int) ReaderIOEither[int] {
result := TraverseRecord[string](func(x int) ReaderIOResult[int] {
return Right(x * 2)
})(rec)(ctx)()
assert.True(t, E.IsRight(result))

22
v2/context/readerioeither/reader_test.go → v2/context/readerioresult/reader_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -143,7 +143,7 @@ func TestCanceledApply(t *testing.T) {
applied := F.Pipe1(
fct,
Ap[string, string](errValue),
Ap[string](errValue),
)
res := applied(context.Background())()
@@ -156,7 +156,7 @@ func TestRegularApply(t *testing.T) {
applied := F.Pipe1(
fct,
Ap[string, string](value),
Ap[string](value),
)
res := applied(context.Background())()
@@ -171,14 +171,14 @@ func TestWithResourceNoErrors(t *testing.T) {
return countAcquire
})
release := func(int) ReaderIOEither[int] {
release := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countRelease++
return countRelease
})
}
body := func(int) ReaderIOEither[int] {
body := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countBody++
return countBody
@@ -203,7 +203,7 @@ func TestWithResourceErrorInBody(t *testing.T) {
return countAcquire
})
release := func(int) ReaderIOEither[int] {
release := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countRelease++
return countRelease
@@ -211,7 +211,7 @@ func TestWithResourceErrorInBody(t *testing.T) {
}
err := fmt.Errorf("error in body")
body := func(int) ReaderIOEither[int] {
body := func(int) ReaderIOResult[int] {
return Left[int](err)
}
@@ -231,14 +231,14 @@ func TestWithResourceErrorInAcquire(t *testing.T) {
err := fmt.Errorf("error in acquire")
acquire := Left[int](err)
release := func(int) ReaderIOEither[int] {
release := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countRelease++
return countRelease
})
}
body := func(int) ReaderIOEither[int] {
body := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countBody++
return countBody
@@ -264,11 +264,11 @@ func TestWithResourceErrorInRelease(t *testing.T) {
})
err := fmt.Errorf("error in release")
release := func(int) ReaderIOEither[int] {
release := func(int) ReaderIOResult[int] {
return Left[int](err)
}
body := func(int) ReaderIOEither[int] {
body := func(int) ReaderIOResult[int] {
return FromLazy(func() int {
countBody++
return countBody

22
v2/context/readerioeither/resource.go → v2/context/readerioresult/resource.go
View File

@@ -13,13 +13,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
"github.com/IBM/fp-go/v2/function"
RIE "github.com/IBM/fp-go/v2/readerioeither"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
)
// WithResource constructs a function that creates a resource, then operates on it and then releases the resource.
@@ -32,22 +29,22 @@ import (
// - onRelease: Releases the resource (always called, even on error)
//
// Parameters:
// - onCreate: ReaderIOEither that creates the resource
// - onCreate: ReaderIOResult that creates the resource
// - onRelease: Function to release the resource
//
// Returns a function that takes a resource-using function and returns a ReaderIOEither.
// Returns a function that takes a resource-using function and returns a ReaderIOResult.
//
// Example:
//
// file := WithResource(
// openFile("data.txt"),
// func(f *os.File) ReaderIOEither[any] {
// func(f *os.File) ReaderIOResult[any] {
// return TryCatch(func(ctx context.Context) func() (any, error) {
// return func() (any, error) { return nil, f.Close() }
// })
// },
// )
// result := file(func(f *os.File) ReaderIOEither[string] {
// result := file(func(f *os.File) ReaderIOResult[string] {
// return TryCatch(func(ctx context.Context) func() (string, error) {
// return func() (string, error) {
// data, err := io.ReadAll(f)
@@ -55,9 +52,6 @@ import (
// }
// })
// })
func WithResource[A, R, ANY any](onCreate ReaderIOEither[R], onRelease func(R) ReaderIOEither[ANY]) Kleisli[Kleisli[R, A], A] {
return function.Flow2(
function.Bind2nd(function.Flow2[func(R) ReaderIOEither[A], Operator[A, A], R, ReaderIOEither[A], ReaderIOEither[A]], WithContext[A]),
RIE.WithResource[A, context.Context, error, R](WithContext(onCreate), onRelease),
)
func WithResource[A, R, ANY any](onCreate ReaderIOResult[R], onRelease Kleisli[R, ANY]) Kleisli[Kleisli[R, A], A] {
return RIOR.WithResource[A](onCreate, onRelease)
}

6
v2/context/readerioeither/resource_test.go → v2/context/readerioresult/resource_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -37,7 +37,7 @@ var (
)
)
func closeFile(f *os.File) ReaderIOEither[string] {
func closeFile(f *os.File) ReaderIOResult[string] {
return F.Pipe1(
TryCatch(func(_ context.Context) func() (string, error) {
return func() (string, error) {
@@ -52,7 +52,7 @@ func ExampleWithResource() {
stringReader := WithResource[string](openFile("data/file.txt"), closeFile)
rdr := stringReader(func(f *os.File) ReaderIOEither[string] {
rdr := stringReader(func(f *os.File) ReaderIOResult[string] {
return F.Pipe2(
TryCatch(func(_ context.Context) func() ([]byte, error) {
return func() ([]byte, error) {

8
v2/context/readerioeither/semigroup.go → v2/context/readerioresult/semigroup.go
View File

@@ -13,21 +13,21 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"github.com/IBM/fp-go/v2/semigroup"
)
type (
Semigroup[A any] = semigroup.Semigroup[ReaderIOEither[A]]
Semigroup[A any] = semigroup.Semigroup[ReaderIOResult[A]]
)
// AltSemigroup is a [Semigroup] that tries the first item and then the second one using an alternative.
// This creates a semigroup where combining two ReaderIOEither values means trying the first one,
// This creates a semigroup where combining two ReaderIOResult values means trying the first one,
// and if it fails, trying the second one. This is useful for implementing fallback behavior.
//
// Returns a Semigroup for ReaderIOEither[A] with Alt-based combination.
// Returns a Semigroup for ReaderIOResult[A] with Alt-based combination.
//
// Example:
//

10
v2/context/readerioeither/sync.go → v2/context/readerioresult/sync.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
@@ -29,9 +29,9 @@ import (
// The lock parameter should return a CancelFunc that releases the lock when called.
//
// Parameters:
// - lock: ReaderIOEither that acquires a lock and returns a CancelFunc to release it
// - lock: ReaderIOResult that acquires a lock and returns a CancelFunc to release it
//
// Returns a function that wraps a ReaderIOEither with lock protection.
// Returns a function that wraps a ReaderIOResult with lock protection.
//
// Example:
//
@@ -43,9 +43,9 @@ import (
// }
// })
// protectedOp := WithLock(lock)(myOperation)
func WithLock[A any](lock ReaderIOEither[context.CancelFunc]) Operator[A, A] {
func WithLock[A any](lock ReaderIOResult[context.CancelFunc]) Operator[A, A] {
return function.Flow2(
function.Constant1[context.CancelFunc, ReaderIOEither[A]],
function.Constant1[context.CancelFunc, ReaderIOResult[A]],
WithResource[A](lock, function.Flow2(
io.FromImpure[context.CancelFunc],
FromIO[any],

140
v2/context/readerioeither/traverse.go → v2/context/readerioresult/traverse.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"github.com/IBM/fp-go/v2/function"
@@ -21,13 +21,13 @@ import (
"github.com/IBM/fp-go/v2/internal/record"
)
// TraverseArray transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// TraverseArray transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// This uses the default applicative behavior (parallel or sequential based on useParallel flag).
//
// Parameters:
// - f: Function that transforms each element into a ReaderIOEither
// - f: Function that transforms each element into a ReaderIOResult
//
// Returns a function that transforms an array into a ReaderIOEither of an array.
// Returns a function that transforms an array into a ReaderIOResult of an array.
func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
return array.Traverse[[]A](
Of[[]B],
@@ -38,14 +38,14 @@ func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
)
}
// TraverseArrayWithIndex transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// TraverseArrayWithIndex transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// The transformation function receives both the index and the element.
//
// Parameters:
// - f: Function that transforms each element with its index into a ReaderIOEither
// - f: Function that transforms each element with its index into a ReaderIOResult
//
// Returns a function that transforms an array into a ReaderIOEither of an array.
func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOEither[B]) Kleisli[[]A, []B] {
// Returns a function that transforms an array into a ReaderIOResult of an array.
func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOResult[B]) Kleisli[[]A, []B] {
return array.TraverseWithIndex[[]A](
Of[[]B],
Map[[]B, func(B) []B],
@@ -55,23 +55,23 @@ func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderIOEither[B]) Kleisli[
)
}
// SequenceArray converts a homogeneous sequence of ReaderIOEither into a ReaderIOEither of sequence.
// SequenceArray converts a homogeneous sequence of ReaderIOResult into a ReaderIOResult of sequence.
// This is equivalent to TraverseArray with the identity function.
//
// Parameters:
// - ma: Array of ReaderIOEither values
// - ma: Array of ReaderIOResult values
//
// Returns a ReaderIOEither containing an array of values.
func SequenceArray[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
return TraverseArray(function.Identity[ReaderIOEither[A]])(ma)
// Returns a ReaderIOResult containing an array of values.
func SequenceArray[A any](ma []ReaderIOResult[A]) ReaderIOResult[[]A] {
return TraverseArray(function.Identity[ReaderIOResult[A]])(ma)
}
// TraverseRecord transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]].
// TraverseRecord transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]].
//
// Parameters:
// - f: Function that transforms each value into a ReaderIOEither
// - f: Function that transforms each value into a ReaderIOResult
//
// Returns a function that transforms a map into a ReaderIOEither of a map.
// Returns a function that transforms a map into a ReaderIOResult of a map.
func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B] {
return record.Traverse[map[K]A](
Of[map[K]B],
@@ -82,14 +82,14 @@ func TraverseRecord[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, ma
)
}
// TraverseRecordWithIndex transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]].
// TraverseRecordWithIndex transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]].
// The transformation function receives both the key and the value.
//
// Parameters:
// - f: Function that transforms each key-value pair into a ReaderIOEither
// - f: Function that transforms each key-value pair into a ReaderIOResult
//
// Returns a function that transforms a map into a ReaderIOEither of a map.
func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) Kleisli[map[K]A, map[K]B] {
// Returns a function that transforms a map into a ReaderIOResult of a map.
func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOResult[B]) Kleisli[map[K]A, map[K]B] {
return record.TraverseWithIndex[map[K]A](
Of[map[K]B],
Map[map[K]B, func(B) map[K]B],
@@ -99,25 +99,25 @@ func TraverseRecordWithIndex[K comparable, A, B any](f func(K, A) ReaderIOEither
)
}
// SequenceRecord converts a homogeneous map of ReaderIOEither into a ReaderIOEither of map.
// SequenceRecord converts a homogeneous map of ReaderIOResult into a ReaderIOResult of map.
//
// Parameters:
// - ma: Map of ReaderIOEither values
// - ma: Map of ReaderIOResult values
//
// Returns a ReaderIOEither containing a map of values.
func SequenceRecord[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
return TraverseRecord[K](function.Identity[ReaderIOEither[A]])(ma)
// Returns a ReaderIOResult containing a map of values.
func SequenceRecord[K comparable, A any](ma map[K]ReaderIOResult[A]) ReaderIOResult[map[K]A] {
return TraverseRecord[K](function.Identity[ReaderIOResult[A]])(ma)
}
// MonadTraverseArraySeq transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// MonadTraverseArraySeq transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// This explicitly uses sequential execution.
//
// Parameters:
// - as: The array to traverse
// - f: Function that transforms each element into a ReaderIOEither
// - f: Function that transforms each element into a ReaderIOResult
//
// Returns a ReaderIOEither containing an array of transformed values.
func MonadTraverseArraySeq[A, B any](as []A, f Kleisli[A, B]) ReaderIOEither[[]B] {
// Returns a ReaderIOResult containing an array of transformed values.
func MonadTraverseArraySeq[A, B any](as []A, f Kleisli[A, B]) ReaderIOResult[[]B] {
return array.MonadTraverse[[]A](
Of[[]B],
Map[[]B, func(B) []B],
@@ -127,13 +127,13 @@ func MonadTraverseArraySeq[A, B any](as []A, f Kleisli[A, B]) ReaderIOEither[[]B
)
}
// TraverseArraySeq transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// TraverseArraySeq transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// This is the curried version of [MonadTraverseArraySeq] with sequential execution.
//
// Parameters:
// - f: Function that transforms each element into a ReaderIOEither
// - f: Function that transforms each element into a ReaderIOResult
//
// Returns a function that transforms an array into a ReaderIOEither of an array.
// Returns a function that transforms an array into a ReaderIOResult of an array.
func TraverseArraySeq[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
return array.Traverse[[]A](
Of[[]B],
@@ -144,8 +144,8 @@ func TraverseArraySeq[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
)
}
// TraverseArrayWithIndexSeq uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOEither[B]) Kleisli[[]A, []B] {
// TraverseArrayWithIndexSeq uses transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]]
func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOResult[B]) Kleisli[[]A, []B] {
return array.TraverseWithIndex[[]A](
Of[[]B],
Map[[]B, func(B) []B],
@@ -155,19 +155,19 @@ func TraverseArrayWithIndexSeq[A, B any](f func(int, A) ReaderIOEither[B]) Kleis
)
}
// SequenceArraySeq converts a homogeneous sequence of ReaderIOEither into a ReaderIOEither of sequence.
// SequenceArraySeq converts a homogeneous sequence of ReaderIOResult into a ReaderIOResult of sequence.
// This explicitly uses sequential execution.
//
// Parameters:
// - ma: Array of ReaderIOEither values
// - ma: Array of ReaderIOResult values
//
// Returns a ReaderIOEither containing an array of values.
func SequenceArraySeq[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
return MonadTraverseArraySeq(ma, function.Identity[ReaderIOEither[A]])
// Returns a ReaderIOResult containing an array of values.
func SequenceArraySeq[A any](ma []ReaderIOResult[A]) ReaderIOResult[[]A] {
return MonadTraverseArraySeq(ma, function.Identity[ReaderIOResult[A]])
}
// MonadTraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
func MonadTraverseRecordSeq[K comparable, A, B any](as map[K]A, f Kleisli[A, B]) ReaderIOEither[map[K]B] {
// MonadTraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func MonadTraverseRecordSeq[K comparable, A, B any](as map[K]A, f Kleisli[A, B]) ReaderIOResult[map[K]B] {
return record.MonadTraverse[map[K]A](
Of[map[K]B],
Map[map[K]B, func(B) map[K]B],
@@ -177,7 +177,7 @@ func MonadTraverseRecordSeq[K comparable, A, B any](as map[K]A, f Kleisli[A, B])
)
}
// TraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
// TraverseRecordSeq uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func TraverseRecordSeq[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B] {
return record.Traverse[map[K]A](
Of[map[K]B],
@@ -188,8 +188,8 @@ func TraverseRecordSeq[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A,
)
}
// TraverseRecordWithIndexSeq uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) Kleisli[map[K]A, map[K]B] {
// TraverseRecordWithIndexSeq uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOResult[B]) Kleisli[map[K]A, map[K]B] {
return record.TraverseWithIndex[map[K]A](
Of[map[K]B],
Map[map[K]B, func(B) map[K]B],
@@ -200,19 +200,19 @@ func TraverseRecordWithIndexSeq[K comparable, A, B any](f func(K, A) ReaderIOEit
}
// SequenceRecordSeq converts a homogeneous sequence of either into an either of sequence
func SequenceRecordSeq[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
return MonadTraverseRecordSeq(ma, function.Identity[ReaderIOEither[A]])
func SequenceRecordSeq[K comparable, A any](ma map[K]ReaderIOResult[A]) ReaderIOResult[map[K]A] {
return MonadTraverseRecordSeq(ma, function.Identity[ReaderIOResult[A]])
}
// MonadTraverseArrayPar transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// MonadTraverseArrayPar transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// This explicitly uses parallel execution.
//
// Parameters:
// - as: The array to traverse
// - f: Function that transforms each element into a ReaderIOEither
// - f: Function that transforms each element into a ReaderIOResult
//
// Returns a ReaderIOEither containing an array of transformed values.
func MonadTraverseArrayPar[A, B any](as []A, f Kleisli[A, B]) ReaderIOEither[[]B] {
// Returns a ReaderIOResult containing an array of transformed values.
func MonadTraverseArrayPar[A, B any](as []A, f Kleisli[A, B]) ReaderIOResult[[]B] {
return array.MonadTraverse[[]A](
Of[[]B],
Map[[]B, func(B) []B],
@@ -222,13 +222,13 @@ func MonadTraverseArrayPar[A, B any](as []A, f Kleisli[A, B]) ReaderIOEither[[]B
)
}
// TraverseArrayPar transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]].
// TraverseArrayPar transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]].
// This is the curried version of [MonadTraverseArrayPar] with parallel execution.
//
// Parameters:
// - f: Function that transforms each element into a ReaderIOEither
// - f: Function that transforms each element into a ReaderIOResult
//
// Returns a function that transforms an array into a ReaderIOEither of an array.
// Returns a function that transforms an array into a ReaderIOResult of an array.
func TraverseArrayPar[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
return array.Traverse[[]A](
Of[[]B],
@@ -239,8 +239,8 @@ func TraverseArrayPar[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
)
}
// TraverseArrayWithIndexPar uses transforms an array [[]A] into [[]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[[]B]]
func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOEither[B]) Kleisli[[]A, []B] {
// TraverseArrayWithIndexPar uses transforms an array [[]A] into [[]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[[]B]]
func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOResult[B]) Kleisli[[]A, []B] {
return array.TraverseWithIndex[[]A](
Of[[]B],
Map[[]B, func(B) []B],
@@ -250,18 +250,18 @@ func TraverseArrayWithIndexPar[A, B any](f func(int, A) ReaderIOEither[B]) Kleis
)
}
// SequenceArrayPar converts a homogeneous sequence of ReaderIOEither into a ReaderIOEither of sequence.
// SequenceArrayPar converts a homogeneous sequence of ReaderIOResult into a ReaderIOResult of sequence.
// This explicitly uses parallel execution.
//
// Parameters:
// - ma: Array of ReaderIOEither values
// - ma: Array of ReaderIOResult values
//
// Returns a ReaderIOEither containing an array of values.
func SequenceArrayPar[A any](ma []ReaderIOEither[A]) ReaderIOEither[[]A] {
return MonadTraverseArrayPar(ma, function.Identity[ReaderIOEither[A]])
// Returns a ReaderIOResult containing an array of values.
func SequenceArrayPar[A any](ma []ReaderIOResult[A]) ReaderIOResult[[]A] {
return MonadTraverseArrayPar(ma, function.Identity[ReaderIOResult[A]])
}
// TraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
// TraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func TraverseRecordPar[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A, map[K]B] {
return record.Traverse[map[K]A](
Of[map[K]B],
@@ -272,8 +272,8 @@ func TraverseRecordPar[K comparable, A, B any](f Kleisli[A, B]) Kleisli[map[K]A,
)
}
// TraverseRecordWithIndexPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOEither[B]) Kleisli[map[K]A, map[K]B] {
// TraverseRecordWithIndexPar uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOResult[B]) Kleisli[map[K]A, map[K]B] {
return record.TraverseWithIndex[map[K]A](
Of[map[K]B],
Map[map[K]B, func(B) map[K]B],
@@ -283,8 +283,8 @@ func TraverseRecordWithIndexPar[K comparable, A, B any](f func(K, A) ReaderIOEit
)
}
// MonadTraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOEither[B]] and then resolves that into a [ReaderIOEither[map[K]B]]
func MonadTraverseRecordPar[K comparable, A, B any](as map[K]A, f Kleisli[A, B]) ReaderIOEither[map[K]B] {
// MonadTraverseRecordPar uses transforms a record [map[K]A] into [map[K]ReaderIOResult[B]] and then resolves that into a [ReaderIOResult[map[K]B]]
func MonadTraverseRecordPar[K comparable, A, B any](as map[K]A, f Kleisli[A, B]) ReaderIOResult[map[K]B] {
return record.MonadTraverse[map[K]A](
Of[map[K]B],
Map[map[K]B, func(B) map[K]B],
@@ -294,13 +294,13 @@ func MonadTraverseRecordPar[K comparable, A, B any](as map[K]A, f Kleisli[A, B])
)
}
// SequenceRecordPar converts a homogeneous map of ReaderIOEither into a ReaderIOEither of map.
// SequenceRecordPar converts a homogeneous map of ReaderIOResult into a ReaderIOResult of map.
// This explicitly uses parallel execution.
//
// Parameters:
// - ma: Map of ReaderIOEither values
// - ma: Map of ReaderIOResult values
//
// Returns a ReaderIOEither containing a map of values.
func SequenceRecordPar[K comparable, A any](ma map[K]ReaderIOEither[A]) ReaderIOEither[map[K]A] {
return MonadTraverseRecordPar(ma, function.Identity[ReaderIOEither[A]])
// Returns a ReaderIOResult containing a map of values.
func SequenceRecordPar[K comparable, A any](ma map[K]ReaderIOResult[A]) ReaderIOResult[map[K]A] {
return MonadTraverseRecordPar(ma, function.Identity[ReaderIOResult[A]])
}

28
v2/context/readerioeither/type.go → v2/context/readerioresult/type.go
View File

@@ -13,11 +13,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readerioeither
package readerioresult
import (
"context"
"github.com/IBM/fp-go/v2/context/ioresult"
"github.com/IBM/fp-go/v2/either"
"github.com/IBM/fp-go/v2/io"
"github.com/IBM/fp-go/v2/ioeither"
@@ -25,7 +26,8 @@ import (
"github.com/IBM/fp-go/v2/option"
"github.com/IBM/fp-go/v2/reader"
"github.com/IBM/fp-go/v2/readerio"
"github.com/IBM/fp-go/v2/readerioeither"
RIOR "github.com/IBM/fp-go/v2/readerioresult"
"github.com/IBM/fp-go/v2/result"
)
type (
@@ -40,6 +42,8 @@ type (
// Either[A] is equivalent to Either[error, A] from the either package.
Either[A any] = either.Either[error, A]
Result[A any] = result.Result[A]
// Lazy represents a deferred computation that produces a value of type A when executed.
// The computation is not executed until explicitly invoked.
Lazy[A any] = lazy.Lazy[A]
@@ -56,6 +60,8 @@ type (
// IOEither[A] is equivalent to func() Either[error, A]
IOEither[A any] = ioeither.IOEither[error, A]
IOResult[A any] = ioresult.IOResult[A]
// Reader represents a computation that depends on a context of type R.
// This is used for dependency injection and accessing shared context.
//
@@ -68,21 +74,21 @@ type (
// ReaderIO[A] is equivalent to func(context.Context) func() A
ReaderIO[A any] = readerio.ReaderIO[context.Context, A]
// ReaderIOEither is the main type of this package. It represents a computation that:
// ReaderIOResult is the main type of this package. It represents a computation that:
// - Depends on a [context.Context] (Reader aspect)
// - Performs side effects (IO aspect)
// - Can fail with an [error] (Either aspect)
// - Produces a value of type A on success
//
// This is a specialization of [readerioeither.ReaderIOEither] with:
// This is a specialization of [readerioeither.ReaderIOResult] with:
// - Context type fixed to [context.Context]
// - Error type fixed to [error]
//
// The type is defined as:
// ReaderIOEither[A] = func(context.Context) func() Either[error, A]
// ReaderIOResult[A] = func(context.Context) func() Either[error, A]
//
// Example usage:
// func fetchUser(id string) ReaderIOEither[User] {
// func fetchUser(id string) ReaderIOResult[User] {
// return func(ctx context.Context) func() Either[error, User] {
// return func() Either[error, User] {
// user, err := userService.Get(ctx, id)
@@ -97,14 +103,14 @@ type (
// The computation is executed by providing a context and then invoking the result:
// ctx := context.Background()
// result := fetchUser("123")(ctx)()
ReaderIOEither[A any] = readerioeither.ReaderIOEither[context.Context, error, A]
ReaderIOResult[A any] = RIOR.ReaderIOResult[context.Context, A]
Kleisli[A, B any] = reader.Reader[A, ReaderIOEither[B]]
Kleisli[A, B any] = reader.Reader[A, ReaderIOResult[B]]
// Operator represents a transformation from one ReaderIOEither to another.
// Operator represents a transformation from one ReaderIOResult to another.
// This is useful for point-free style composition and building reusable transformations.
//
// Operator[A, B] is equivalent to Kleisli[ReaderIOEither[A], B]
// Operator[A, B] is equivalent to Kleisli[ReaderIOResult[A], B]
//
// Example usage:
// // Define a reusable transformation
@@ -112,5 +118,5 @@ type (
//
// // Apply the transformation
// result := toUpper(computation)
Operator[A, B any] = Kleisli[ReaderIOEither[A], B]
Operator[A, B any] = Kleisli[ReaderIOResult[A], B]
)

6
v2/context/readereither/array.go → v2/context/readerresult/array.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import "github.com/IBM/fp-go/v2/readereither"
@@ -23,11 +23,11 @@ func TraverseArray[A, B any](f Kleisli[A, B]) Kleisli[[]A, []B] {
}
// TraverseArrayWithIndex transforms an array
func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderEither[B]) Kleisli[[]A, []B] {
func TraverseArrayWithIndex[A, B any](f func(int, A) ReaderResult[B]) Kleisli[[]A, []B] {
return readereither.TraverseArrayWithIndex(f)
}
// SequenceArray converts a homogeneous sequence of either into an either of sequence
func SequenceArray[A any](ma []ReaderEither[A]) ReaderEither[[]A] {
func SequenceArray[A any](ma []ReaderResult[A]) ReaderResult[[]A] {
return readereither.SequenceArray(ma)
}

69
v2/context/readereither/bind.go → v2/context/readerresult/bind.go
View File

@@ -13,11 +13,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
F "github.com/IBM/fp-go/v2/function"
L "github.com/IBM/fp-go/v2/optics/lens"
G "github.com/IBM/fp-go/v2/readereither/generic"
)
@@ -34,8 +33,8 @@ import (
// result := readereither.Do(State{})
func Do[S any](
empty S,
) ReaderEither[S] {
return G.Do[ReaderEither[S], context.Context, error, S](empty)
) ReaderResult[S] {
return G.Do[ReaderResult[S]](empty)
}
// Bind attaches the result of a computation to a context [S1] to produce a context [S2].
@@ -58,7 +57,7 @@ func Do[S any](
// func(uid string) func(State) State {
// return func(s State) State { s.UserID = uid; return s }
// },
// func(s State) readereither.ReaderEither[string] {
// func(s State) readereither.ReaderResult[string] {
// return func(ctx context.Context) either.Either[error, string] {
// if uid, ok := ctx.Value("userID").(string); ok {
// return either.Right[error](uid)
@@ -71,7 +70,7 @@ func Do[S any](
// func(tid string) func(State) State {
// return func(s State) State { s.TenantID = tid; return s }
// },
// func(s State) readereither.ReaderEither[string] {
// func(s State) readereither.ReaderResult[string] {
// // This can access s.UserID from the previous step
// return func(ctx context.Context) either.Either[error, string] {
// return either.Right[error]("tenant-" + s.UserID)
@@ -82,31 +81,31 @@ func Do[S any](
func Bind[S1, S2, T any](
setter func(T) func(S1) S2,
f Kleisli[S1, T],
) Kleisli[ReaderEither[S1], S2] {
return G.Bind[ReaderEither[S1], ReaderEither[S2], ReaderEither[T], context.Context, error, S1, S2, T](setter, f)
) Kleisli[ReaderResult[S1], S2] {
return G.Bind[ReaderResult[S1], ReaderResult[S2]](setter, f)
}
// Let attaches the result of a computation to a context [S1] to produce a context [S2]
func Let[S1, S2, T any](
setter func(T) func(S1) S2,
f func(S1) T,
) Kleisli[ReaderEither[S1], S2] {
return G.Let[ReaderEither[S1], ReaderEither[S2], context.Context, error, S1, S2, T](setter, f)
) Kleisli[ReaderResult[S1], S2] {
return G.Let[ReaderResult[S1], ReaderResult[S2]](setter, f)
}
// LetTo attaches the a value to a context [S1] to produce a context [S2]
func LetTo[S1, S2, T any](
setter func(T) func(S1) S2,
b T,
) Kleisli[ReaderEither[S1], S2] {
return G.LetTo[ReaderEither[S1], ReaderEither[S2], context.Context, error, S1, S2, T](setter, b)
) Kleisli[ReaderResult[S1], S2] {
return G.LetTo[ReaderResult[S1], ReaderResult[S2]](setter, b)
}
// BindTo initializes a new state [S1] from a value [T]
func BindTo[S1, T any](
setter func(T) S1,
) Kleisli[ReaderEither[T], S1] {
return G.BindTo[ReaderEither[S1], ReaderEither[T], context.Context, error, S1, T](setter)
) Kleisli[ReaderResult[T], S1] {
return G.BindTo[ReaderResult[S1], ReaderResult[T]](setter)
}
// ApS attaches a value to a context [S1] to produce a context [S2] by considering
@@ -148,9 +147,9 @@ func BindTo[S1, T any](
// )
func ApS[S1, S2, T any](
setter func(T) func(S1) S2,
fa ReaderEither[T],
) Kleisli[ReaderEither[S1], S2] {
return G.ApS[ReaderEither[S1], ReaderEither[S2], ReaderEither[T], context.Context, error, S1, S2, T](setter, fa)
fa ReaderResult[T],
) Kleisli[ReaderResult[S1], S2] {
return G.ApS[ReaderResult[S1], ReaderResult[S2]](setter, fa)
}
// ApSL is a variant of ApS that uses a lens to focus on a specific field in the state.
@@ -159,10 +158,10 @@ func ApS[S1, S2, T any](
//
// Parameters:
// - lens: A lens that focuses on a field of type T within state S
// - fa: A ReaderEither computation that produces a value of type T
// - fa: A ReaderResult computation that produces a value of type T
//
// Returns:
// - A function that transforms ReaderEither[S] to ReaderEither[S] by setting the focused field
// - A function that transforms ReaderResult[S] to ReaderResult[S] by setting the focused field
//
// Example:
//
@@ -186,8 +185,8 @@ func ApS[S1, S2, T any](
// )
func ApSL[S, T any](
lens L.Lens[S, T],
fa ReaderEither[T],
) Kleisli[ReaderEither[S], S] {
fa ReaderResult[T],
) Kleisli[ReaderResult[S], S] {
return ApS(lens.Set, fa)
}
@@ -199,10 +198,10 @@ func ApSL[S, T any](
//
// Parameters:
// - lens: A lens that focuses on a field of type T within state S
// - f: A function that takes the current field value and returns a ReaderEither computation
// - f: A function that takes the current field value and returns a ReaderResult computation
//
// Returns:
// - A function that transforms ReaderEither[S] to ReaderEither[S]
// - A function that transforms ReaderResult[S] to ReaderResult[S]
//
// Example:
//
@@ -215,7 +214,7 @@ func ApSL[S, T any](
// func(c Counter, v int) Counter { c.Value = v; return c },
// )
//
// increment := func(v int) readereither.ReaderEither[int] {
// increment := func(v int) readereither.ReaderResult[int] {
// return func(ctx context.Context) either.Either[error, int] {
// if v >= 100 {
// return either.Left[int](errors.New("value too large"))
@@ -231,10 +230,8 @@ func ApSL[S, T any](
func BindL[S, T any](
lens L.Lens[S, T],
f Kleisli[T, T],
) Kleisli[ReaderEither[S], S] {
return Bind[S, S, T](lens.Set, func(s S) ReaderEither[T] {
return f(lens.Get(s))
})
) Kleisli[ReaderResult[S], S] {
return Bind(lens.Set, F.Flow2(lens.Get, f))
}
// LetL is a variant of Let that uses a lens to focus on a specific field in the state.
@@ -245,7 +242,7 @@ func BindL[S, T any](
// - f: A pure function that transforms the field value
//
// Returns:
// - A function that transforms ReaderEither[S] to ReaderEither[S]
// - A function that transforms ReaderResult[S] to ReaderResult[S]
//
// Example:
//
@@ -268,10 +265,8 @@ func BindL[S, T any](
func LetL[S, T any](
lens L.Lens[S, T],
f func(T) T,
) Kleisli[ReaderEither[S], S] {
return Let[S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
) Kleisli[ReaderResult[S], S] {
return Let(lens.Set, F.Flow2(lens.Get, f))
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific field in the state.
@@ -282,7 +277,7 @@ func LetL[S, T any](
// - b: The constant value to set
//
// Returns:
// - A function that transforms ReaderEither[S] to ReaderEither[S]
// - A function that transforms ReaderResult[S] to ReaderResult[S]
//
// Example:
//
@@ -304,6 +299,6 @@ func LetL[S, T any](
func LetToL[S, T any](
lens L.Lens[S, T],
b T,
) Kleisli[ReaderEither[S], S] {
return LetTo[S, S, T](lens.Set, b)
) Kleisli[ReaderResult[S], S] {
return LetTo(lens.Set, b)
}

6
v2/context/readereither/bind_test.go → v2/context/readerresult/bind_test.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
@@ -25,11 +25,11 @@ import (
"github.com/stretchr/testify/assert"
)
func getLastName(s utils.Initial) ReaderEither[string] {
func getLastName(s utils.Initial) ReaderResult[string] {
return Of("Doe")
}
func getGivenName(s utils.WithLastName) ReaderEither[string] {
func getGivenName(s utils.WithLastName) ReaderResult[string] {
return Of("John")
}

6
v2/context/readereither/cancel.go → v2/context/readerresult/cancel.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
@@ -21,8 +21,8 @@ import (
E "github.com/IBM/fp-go/v2/either"
)
// withContext wraps an existing ReaderEither and performs a context check for cancellation before deletating
func WithContext[A any](ma ReaderEither[A]) ReaderEither[A] {
// withContext wraps an existing ReaderResult and performs a context check for cancellation before deletating
func WithContext[A any](ma ReaderResult[A]) ReaderResult[A] {
return func(ctx context.Context) E.Either[error, A] {
if err := context.Cause(ctx); err != nil {
return E.Left[A](err)

4
v2/context/readereither/curry.go → v2/context/readerresult/curry.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
@@ -24,7 +24,7 @@ import (
// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
func Curry0[A any](f func(context.Context) (A, error)) ReaderEither[A] {
func Curry0[A any](f func(context.Context) (A, error)) ReaderResult[A] {
return readereither.Curry0(f)
}

9
v2/context/readereither/exec/exec.go → v2/context/readerresult/exec/exec.go
View File

@@ -18,11 +18,10 @@ package exec
import (
"context"
"github.com/IBM/fp-go/v2/context/readereither"
"github.com/IBM/fp-go/v2/either"
"github.com/IBM/fp-go/v2/exec"
"github.com/IBM/fp-go/v2/function"
INTE "github.com/IBM/fp-go/v2/internal/exec"
"github.com/IBM/fp-go/v2/result"
)
var (
@@ -32,8 +31,8 @@ var (
Command = function.Curry3(command)
)
func command(name string, args []string, in []byte) readereither.ReaderEither[exec.CommandOutput] {
return func(ctx context.Context) either.Either[error, exec.CommandOutput] {
return either.TryCatchError(INTE.Exec(ctx, name, args, in))
func command(name string, args []string, in []byte) ReaderResult[exec.CommandOutput] {
return func(ctx context.Context) Result[exec.CommandOutput] {
return result.TryCatchError(INTE.Exec(ctx, name, args, in))
}
}

22
v2/context/ioeither/generic/ioeither.go → v2/context/readerresult/exec/type.go
View File

@@ -13,21 +13,15 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package generic
// package readerresult implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
package exec
import (
"context"
E "github.com/IBM/fp-go/v2/either"
IOE "github.com/IBM/fp-go/v2/ioeither/generic"
"github.com/IBM/fp-go/v2/context/readerresult"
"github.com/IBM/fp-go/v2/result"
)
// WithContext wraps an existing IOEither and performs a context check for cancellation before delegating
func WithContext[GIO ~func() E.Either[error, A], A any](ctx context.Context, ma GIO) GIO {
return IOE.MakeIO[GIO](func() E.Either[error, A] {
if err := context.Cause(ctx); err != nil {
return E.Left[A](err)
}
return ma()
})
}
type (
Result[T any] = result.Result[T]
ReaderResult[T any] = readerresult.ReaderResult[T]
)

8
v2/context/readereither/from.go → v2/context/readerresult/from.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
@@ -24,7 +24,7 @@ import (
// these functions curry a golang function with the context as the firsr parameter into a either reader with the context as the last parameter
// this goes back to the advice in https://pkg.go.dev/context to put the context as a first parameter as a convention
func From0[A any](f func(context.Context) (A, error)) func() ReaderEither[A] {
func From0[A any](f func(context.Context) (A, error)) func() ReaderResult[A] {
return readereither.From0(f)
}
@@ -32,10 +32,10 @@ func From1[T1, A any](f func(context.Context, T1) (A, error)) Kleisli[T1, A] {
return readereither.From1(f)
}
func From2[T1, T2, A any](f func(context.Context, T1, T2) (A, error)) func(T1, T2) ReaderEither[A] {
func From2[T1, T2, A any](f func(context.Context, T1, T2) (A, error)) func(T1, T2) ReaderResult[A] {
return readereither.From2(f)
}
func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) (A, error)) func(T1, T2, T3) ReaderEither[A] {
func From3[T1, T2, T3, A any](f func(context.Context, T1, T2, T3) (A, error)) func(T1, T2, T3) ReaderResult[A] {
return readereither.From3(f)
}

28
v2/context/readereither/reader.go → v2/context/readerresult/reader.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"context"
@@ -21,19 +21,19 @@ import (
"github.com/IBM/fp-go/v2/readereither"
)
func FromEither[A any](e Either[A]) ReaderEither[A] {
func FromEither[A any](e Either[A]) ReaderResult[A] {
return readereither.FromEither[context.Context](e)
}
func Left[A any](l error) ReaderEither[A] {
func Left[A any](l error) ReaderResult[A] {
return readereither.Left[context.Context, A](l)
}
func Right[A any](r A) ReaderEither[A] {
func Right[A any](r A) ReaderResult[A] {
return readereither.Right[context.Context, error](r)
}
func MonadMap[A, B any](fa ReaderEither[A], f func(A) B) ReaderEither[B] {
func MonadMap[A, B any](fa ReaderResult[A], f func(A) B) ReaderResult[B] {
return readereither.MonadMap(fa, f)
}
@@ -41,7 +41,7 @@ func Map[A, B any](f func(A) B) Operator[A, B] {
return readereither.Map[context.Context, error](f)
}
func MonadChain[A, B any](ma ReaderEither[A], f Kleisli[A, B]) ReaderEither[B] {
func MonadChain[A, B any](ma ReaderResult[A], f Kleisli[A, B]) ReaderResult[B] {
return readereither.MonadChain(ma, f)
}
@@ -49,15 +49,15 @@ func Chain[A, B any](f Kleisli[A, B]) Operator[A, B] {
return readereither.Chain(f)
}
func Of[A any](a A) ReaderEither[A] {
func Of[A any](a A) ReaderResult[A] {
return readereither.Of[context.Context, error](a)
}
func MonadAp[A, B any](fab ReaderEither[func(A) B], fa ReaderEither[A]) ReaderEither[B] {
func MonadAp[A, B any](fab ReaderResult[func(A) B], fa ReaderResult[A]) ReaderResult[B] {
return readereither.MonadAp(fab, fa)
}
func Ap[A, B any](fa ReaderEither[A]) func(ReaderEither[func(A) B]) ReaderEither[B] {
func Ap[A, B any](fa ReaderResult[A]) func(ReaderResult[func(A) B]) ReaderResult[B] {
return readereither.Ap[B](fa)
}
@@ -65,19 +65,19 @@ func FromPredicate[A any](pred func(A) bool, onFalse func(A) error) Kleisli[A, A
return readereither.FromPredicate[context.Context](pred, onFalse)
}
func OrElse[A any](onLeft Kleisli[error, A]) Kleisli[ReaderEither[A], A] {
func OrElse[A any](onLeft Kleisli[error, A]) Kleisli[ReaderResult[A], A] {
return readereither.OrElse(onLeft)
}
func Ask() ReaderEither[context.Context] {
func Ask() ReaderResult[context.Context] {
return readereither.Ask[context.Context, error]()
}
func MonadChainEitherK[A, B any](ma ReaderEither[A], f func(A) Either[B]) ReaderEither[B] {
func MonadChainEitherK[A, B any](ma ReaderResult[A], f func(A) Either[B]) ReaderResult[B] {
return readereither.MonadChainEitherK(ma, f)
}
func ChainEitherK[A, B any](f func(A) Either[B]) func(ma ReaderEither[A]) ReaderEither[B] {
func ChainEitherK[A, B any](f func(A) Either[B]) func(ma ReaderResult[A]) ReaderResult[B] {
return readereither.ChainEitherK[context.Context](f)
}
@@ -85,7 +85,7 @@ func ChainOptionK[A, B any](onNone func() error) func(func(A) Option[B]) Operato
return readereither.ChainOptionK[context.Context, A, B](onNone)
}
func MonadFlap[B, A any](fab ReaderEither[func(A) B], a A) ReaderEither[B] {
func MonadFlap[B, A any](fab ReaderResult[func(A) B], a A) ReaderResult[B] {
return readereither.MonadFlap(fab, a)
}

10
v2/context/readereither/sequence.go → v2/context/readerresult/sequence.go
View File

@@ -13,7 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package readereither
package readerresult
import (
"github.com/IBM/fp-go/v2/readereither"
@@ -22,18 +22,18 @@ import (
// SequenceT converts n inputs of higher kinded types into a higher kinded types of n strongly typed values, represented as a tuple
func SequenceT1[A any](a ReaderEither[A]) ReaderEither[tuple.Tuple1[A]] {
func SequenceT1[A any](a ReaderResult[A]) ReaderResult[tuple.Tuple1[A]] {
return readereither.SequenceT1(a)
}
func SequenceT2[A, B any](a ReaderEither[A], b ReaderEither[B]) ReaderEither[tuple.Tuple2[A, B]] {
func SequenceT2[A, B any](a ReaderResult[A], b ReaderResult[B]) ReaderResult[tuple.Tuple2[A, B]] {
return readereither.SequenceT2(a, b)
}
func SequenceT3[A, B, C any](a ReaderEither[A], b ReaderEither[B], c ReaderEither[C]) ReaderEither[tuple.Tuple3[A, B, C]] {
func SequenceT3[A, B, C any](a ReaderResult[A], b ReaderResult[B], c ReaderResult[C]) ReaderResult[tuple.Tuple3[A, B, C]] {
return readereither.SequenceT3(a, b, c)
}
func SequenceT4[A, B, C, D any](a ReaderEither[A], b ReaderEither[B], c ReaderEither[C], d ReaderEither[D]) ReaderEither[tuple.Tuple4[A, B, C, D]] {
func SequenceT4[A, B, C, D any](a ReaderResult[A], b ReaderResult[B], c ReaderResult[C], d ReaderResult[D]) ReaderResult[tuple.Tuple4[A, B, C, D]] {
return readereither.SequenceT4(a, b, c, d)
}

12
v2/context/readereither/type.go → v2/context/readerresult/type.go
View File

@@ -13,8 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// Package readereither implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
package readereither
// package readerresult implements a specialization of the Reader monad assuming a golang context as the context of the monad and a standard golang error
package readerresult
import (
"context"
@@ -28,9 +28,9 @@ import (
type (
Option[A any] = option.Option[A]
Either[A any] = either.Either[error, A]
// ReaderEither is a specialization of the Reader monad for the typical golang scenario
ReaderEither[A any] = readereither.ReaderEither[context.Context, error, A]
// ReaderResult is a specialization of the Reader monad for the typical golang scenario
ReaderResult[A any] = readereither.ReaderEither[context.Context, error, A]
Kleisli[A, B any] = reader.Reader[A, ReaderEither[B]]
Operator[A, B any] = Kleisli[ReaderEither[A], B]
Kleisli[A, B any] = reader.Reader[A, ReaderResult[B]]
Operator[A, B any] = Kleisli[ReaderResult[A], B]
)

4
v2/either/either.go
View File

@@ -96,7 +96,7 @@ func MonadMap[E, A, B any](fa Either[E, A], f func(a A) B) Either[E, B] {
//
// result := either.MonadBiMap(
// either.Left[int](errors.New("error")),
// func(e error) string { return e.Error() },
// error.Error,
// func(n int) string { return fmt.Sprint(n) },
// ) // Left("error")
func MonadBiMap[E1, E2, A, B any](fa Either[E1, A], f func(E1) E2, g func(a A) B) Either[E2, B] {
@@ -131,7 +131,7 @@ func MapTo[E, A, B any](b B) Operator[E, A, B] {
//
// result := either.MonadMapLeft(
// either.Left[int](errors.New("error")),
// func(e error) string { return e.Error() },
// error.Error,
// ) // Left("error")
func MonadMapLeft[E1, A, E2 any](fa Either[E1, A], f func(E1) E2) Either[E2, A] {
return MonadFold(fa, F.Flow2(f, Left[A, E2]), Right[E2, A])

8
v2/either/either_bench_test.go
View File

@@ -200,7 +200,7 @@ func BenchmarkMap_Left(b *testing.B) {
func BenchmarkMapLeft_Right(b *testing.B) {
right := Right[error](42)
mapper := MapLeft[int](func(e error) string { return e.Error() })
mapper := MapLeft[int](error.Error)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -210,7 +210,7 @@ func BenchmarkMapLeft_Right(b *testing.B) {
func BenchmarkMapLeft_Left(b *testing.B) {
left := Left[int](errBench)
mapper := MapLeft[int](func(e error) string { return e.Error() })
mapper := MapLeft[int](error.Error)
b.ResetTimer()
b.ReportAllocs()
for i := 0; i < b.N; i++ {
@@ -221,7 +221,7 @@ func BenchmarkMapLeft_Left(b *testing.B) {
func BenchmarkBiMap_Right(b *testing.B) {
right := Right[error](42)
mapper := BiMap(
func(e error) string { return e.Error() },
error.Error,
func(a int) string { return "value" },
)
b.ResetTimer()
@@ -234,7 +234,7 @@ func BenchmarkBiMap_Right(b *testing.B) {
func BenchmarkBiMap_Left(b *testing.B) {
left := Left[int](errBench)
mapper := BiMap(
func(e error) string { return e.Error() },
error.Error,
func(a int) string { return "value" },
)
b.ResetTimer()

12
v2/either/either_coverage_test.go
View File

@@ -29,8 +29,8 @@ import (
// Test BiMap
func TestBiMap(t *testing.T) {
errToStr := func(e error) string { return e.Error() }
intToStr := func(i int) string { return strconv.Itoa(i) }
errToStr := error.Error
intToStr := strconv.Itoa
// Test Right case
result := BiMap(errToStr, intToStr)(Right[error](42))
@@ -43,8 +43,8 @@ func TestBiMap(t *testing.T) {
// Test MonadBiMap
func TestMonadBiMap(t *testing.T) {
errToStr := func(e error) string { return e.Error() }
intToStr := func(i int) string { return strconv.Itoa(i) }
errToStr := error.Error
intToStr := strconv.Itoa
result := MonadBiMap(Right[error](42), errToStr, intToStr)
assert.Equal(t, Right[string]("42"), result)
@@ -55,7 +55,7 @@ func TestMonadBiMap(t *testing.T) {
// Test MapLeft
func TestMapLeft(t *testing.T) {
errToStr := func(e error) string { return e.Error() }
errToStr := error.Error
result := MapLeft[int](errToStr)(Left[int](errors.New("error")))
assert.Equal(t, Left[int]("error"), result)
@@ -66,7 +66,7 @@ func TestMapLeft(t *testing.T) {
// Test MonadMapLeft
func TestMonadMapLeft(t *testing.T) {
errToStr := func(e error) string { return e.Error() }
errToStr := error.Error
result := MonadMapLeft(Left[int](errors.New("error")), errToStr)
assert.Equal(t, Left[int]("error"), result)

4
v2/either/resource.go
View File

@@ -43,7 +43,7 @@ import (
// // Use file here
// return either.Right[error]("data")
// })
func WithResource[E, R, A any](onCreate func() Either[E, R], onRelease func(R) Either[E, any]) func(func(R) Either[E, A]) Either[E, A] {
func WithResource[E, R, A, ANY any](onCreate func() Either[E, R], onRelease Kleisli[E, R, ANY]) func(func(R) Either[E, A]) Either[E, A] {
return func(f func(R) Either[E, A]) Either[E, A] {
return MonadChain(
@@ -58,7 +58,7 @@ func WithResource[E, R, A any](onCreate func() Either[E, R], onRelease func(R) E
func(a A) Either[E, A] {
return F.Pipe1(
released,
MapTo[E, any](a),
MapTo[E, ANY](a),
)
})
},

4
v2/erasure/erasure.go
View File

@@ -34,7 +34,7 @@
// // result is Either[error, int]
//
// // Function erasure
// typedFunc := func(x int) string { return fmt.Sprintf("%d", x) }
// typedFunc := strconv.Itoa
// erasedFunc := erasure.Erase1(typedFunc)
// result := erasedFunc(erasure.Erase(42)) // returns erased "42"
package erasure
@@ -112,7 +112,7 @@ func Erase0[T1 any](f func() T1) func() any {
//
// Example:
//
// typedFunc := func(x int) string { return fmt.Sprintf("%d", x) }
// typedFunc := strconv.Itoa
// erasedFunc := Erase1(typedFunc)
// result := erasedFunc(Erase(42)) // returns erased "42"
func Erase1[T1, T2 any](f func(T1) T2) func(any) any {

3
v2/erasure/erasure_test.go
View File

@@ -17,6 +17,7 @@ package erasure
import (
"fmt"
"strconv"
"strings"
"testing"
@@ -166,7 +167,7 @@ func TestErase0(t *testing.T) {
func TestErase1(t *testing.T) {
t.Run("erases unary function int to string", func(t *testing.T) {
typedFunc := func(x int) string { return fmt.Sprintf("%d", x) }
typedFunc := strconv.Itoa
erasedFunc := Erase1(typedFunc)
result := erasedFunc(Erase(42))
assert.NotNil(t, result)

9
v2/io/bind.go
View File

@@ -16,6 +16,7 @@
package io
import (
F "github.com/IBM/fp-go/v2/function"
INTA "github.com/IBM/fp-go/v2/internal/apply"
INTC "github.com/IBM/fp-go/v2/internal/chain"
INTF "github.com/IBM/fp-go/v2/internal/functor"
@@ -216,9 +217,7 @@ func BindL[S, T any](
lens L.Lens[S, T],
f Kleisli[T, T],
) Operator[S, S] {
return Bind[S, S, T](lens.Set, func(s S) IO[T] {
return f(lens.Get(s))
})
return Bind[S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL attaches the result of a pure computation to a context using a lens-based setter.
@@ -251,9 +250,7 @@ func LetL[S, T any](
lens L.Lens[S, T],
f func(T) T,
) Operator[S, S] {
return Let[S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL attaches a constant value to a context using a lens-based setter.

9
v2/ioeither/bind.go
View File

@@ -16,6 +16,7 @@
package ioeither
import (
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
@@ -232,9 +233,7 @@ func BindL[E, S, T any](
lens L.Lens[S, T],
f Kleisli[E, T, T],
) Operator[E, S, S] {
return Bind[E, S, S, T](lens.Set, func(s S) IOEither[E, T] {
return f(lens.Get(s))
})
return Bind[E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL attaches the result of a pure computation to a context using a lens-based setter.
@@ -266,9 +265,7 @@ func LetL[E, S, T any](
lens L.Lens[S, T],
f func(T) T,
) Operator[E, S, S] {
return Let[E, S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL attaches a constant value to a context using a lens-based setter.

2
v2/ioeither/ioeither.go
View File

@@ -338,7 +338,7 @@ func MonadFold[E, A, B any](ma IOEither[E, A], onLeft func(E) IO[B], onRight fun
}
// WithResource constructs a function that creates a resource, then operates on it and then releases the resource
func WithResource[A, E, R, ANY any](onCreate IOEither[E, R], onRelease func(R) IOEither[E, ANY]) func(func(R) IOEither[E, A]) IOEither[E, A] {
func WithResource[A, E, R, ANY any](onCreate IOEither[E, R], onRelease Kleisli[E, R, ANY]) Kleisli[E, Kleisli[E, R, A], A] {
return file.WithResource(
MonadChain[E, R, A],
MonadFold[E, A, Either[E, A]],

9
v2/iooption/bind.go
View File

@@ -16,6 +16,7 @@
package iooption
import (
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
@@ -224,9 +225,7 @@ func BindL[S, T any](
lens L.Lens[S, T],
f Kleisli[T, T],
) Kleisli[IOOption[S], S] {
return Bind[S, S, T](lens.Set, func(s S) IOOption[T] {
return f(lens.Get(s))
})
return Bind[S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL attaches the result of a pure computation to a context using a lens-based setter.
@@ -259,9 +258,7 @@ func LetL[S, T any](
lens L.Lens[S, T],
f func(T) T,
) Kleisli[IOOption[S], S] {
return Let[S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL attaches a constant value to a context using a lens-based setter.

9
v2/option/bind.go
View File

@@ -16,6 +16,7 @@
package option
import (
"github.com/IBM/fp-go/v2/function"
A "github.com/IBM/fp-go/v2/internal/apply"
C "github.com/IBM/fp-go/v2/internal/chain"
F "github.com/IBM/fp-go/v2/internal/functor"
@@ -228,9 +229,7 @@ func BindL[S, T any](
lens L.Lens[S, T],
f Kleisli[T, T],
) Kleisli[Option[S], S] {
return Bind[S, S, T](lens.Set, func(s S) Option[T] {
return f(lens.Get(s))
})
return Bind[S, S, T](lens.Set, function.Flow2(lens.Get, f))
}
// LetL attaches the result of a pure computation to a context using a lens-based setter.
@@ -266,9 +265,7 @@ func LetL[S, T any](
lens L.Lens[S, T],
f func(T) T,
) Kleisli[Option[S], S] {
return Let[S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[S, S, T](lens.Set, function.Flow2(lens.Get, f))
}
// LetToL attaches a constant value to a context using a lens-based setter.

2
v2/option/functor.go
View File

@@ -32,7 +32,7 @@ func (o *optionFunctor[A, B]) Map(f func(A) B) Operator[A, B] {
// Example:
//
// f := Functor[int, string]()
// mapper := f.Map(func(x int) string { return fmt.Sprintf("%d", x) })
// mapper := f.Map(strconv.Itoa)
// result := mapper(Some(42)) // Some("42")
func Functor[A, B any]() functor.Functor[A, B, Option[A], Option[B]] {
return &optionFunctor[A, B]{}

5
v2/option/option_extended_test.go
View File

@@ -17,6 +17,7 @@ package option
import (
"fmt"
"strconv"
"testing"
F "github.com/IBM/fp-go/v2/function"
@@ -332,7 +333,7 @@ func TestBindToFunction(t *testing.T) {
// Test Functor
func TestFunctor(t *testing.T) {
f := Functor[int, string]()
mapper := f.Map(func(x int) string { return fmt.Sprintf("%d", x) })
mapper := f.Map(strconv.Itoa)
assert.Equal(t, Some("42"), mapper(Some(42)))
assert.Equal(t, None[string](), mapper(None[int]()))
@@ -346,7 +347,7 @@ func TestMonad(t *testing.T) {
assert.Equal(t, Some(42), m.Of(42))
// Test Map
mapper := m.Map(func(x int) string { return fmt.Sprintf("%d", x) })
mapper := m.Map(strconv.Itoa)
assert.Equal(t, Some("42"), mapper(Some(42)))
// Test Chain

2
v2/option/testing/laws.go
View File

@@ -46,7 +46,7 @@ import (
// eqString := eq.FromStrictEquals[string]()
// eqBool := eq.FromStrictEquals[bool]()
//
// ab := func(x int) string { return fmt.Sprintf("%d", x) }
// ab := strconv.Itoa
// bc := func(s string) bool { return len(s) > 0 }
//
// assert := AssertLaws(t, eqInt, eqString, eqBool, ab, bc)

9
v2/reader/bind.go
View File

@@ -16,6 +16,7 @@
package reader
import (
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
@@ -285,9 +286,7 @@ func BindL[R, S, T any](
lens L.Lens[S, T],
f Kleisli[R, T, T],
) Operator[R, S, S] {
return Bind[R, S, S, T](lens.Set, func(s S) Reader[R, T] {
return f(lens.Get(s))
})
return Bind[R, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -325,9 +324,7 @@ func LetL[R, S, T any](
lens L.Lens[S, T],
f func(T) T,
) Operator[R, S, S] {
return Let[R, S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[R, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context.

2
v2/reader/reader.go
View File

@@ -244,7 +244,7 @@ func Second[A, B, C any](pbc Reader[B, C]) Reader[T.Tuple2[A, B], T.Tuple2[A, C]
// type Env struct { Config Config }
// getPort := func(c Config) int { return c.Port }
// extractConfig := func(e Env) Config { return e.Config }
// toString := func(i int) string { return strconv.Itoa(i) }
// toString := strconv.Itoa
// r := reader.Promap(extractConfig, toString)(getPort)
// result := r(Env{Config: Config{Port: 8080}}) // "8080"
func Promap[E, A, D, B any](f func(D) E, g func(A) B) func(Reader[E, A]) Reader[D, B] {

2
v2/reader/reader_test.go
View File

@@ -152,7 +152,7 @@ func TestPromap(t *testing.T) {
env := Env{Config: Config{Port: 8080}}
getPort := func(c Config) int { return c.Port }
extractConfig := func(e Env) Config { return e.Config }
toString := func(i int) string { return strconv.Itoa(i) }
toString := strconv.Itoa
r := Promap(extractConfig, toString)(getPort)
result := r(env)
assert.Equal(t, "8080", result)

9
v2/readereither/bind.go
View File

@@ -16,6 +16,7 @@
package readereither
import (
F "github.com/IBM/fp-go/v2/function"
L "github.com/IBM/fp-go/v2/optics/lens"
G "github.com/IBM/fp-go/v2/readereither/generic"
)
@@ -233,9 +234,7 @@ func BindL[R, E, S, T any](
lens L.Lens[S, T],
f func(T) ReaderEither[R, E, T],
) func(ReaderEither[R, E, S]) ReaderEither[R, E, S] {
return Bind[R, E, S, S, T](lens.Set, func(s S) ReaderEither[R, E, T] {
return f(lens.Get(s))
})
return Bind[R, E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -269,9 +268,7 @@ func LetL[R, E, S, T any](
lens L.Lens[S, T],
f func(T) T,
) func(ReaderEither[R, E, S]) ReaderEither[R, E, S] {
return Let[R, E, S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[R, E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context.

9
v2/readerio/bind.go
View File

@@ -16,6 +16,7 @@
package readerio
import (
F "github.com/IBM/fp-go/v2/function"
"github.com/IBM/fp-go/v2/internal/apply"
"github.com/IBM/fp-go/v2/internal/chain"
"github.com/IBM/fp-go/v2/internal/functor"
@@ -256,9 +257,7 @@ func BindL[R, S, T any](
lens L.Lens[S, T],
f func(T) ReaderIO[R, T],
) func(ReaderIO[R, S]) ReaderIO[R, S] {
return Bind[R, S, S, T](lens.Set, func(s S) ReaderIO[R, T] {
return f(lens.Get(s))
})
return Bind[R, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -291,9 +290,7 @@ func LetL[R, S, T any](
lens L.Lens[S, T],
f func(T) T,
) func(ReaderIO[R, S]) ReaderIO[R, S] {
return Let[R, S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[R, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context.

2
v2/readerioeither/array_test.go
View File

@@ -32,7 +32,7 @@ func TestTraverseArray(t *testing.T) {
if len(a) > 0 {
return Right[context.Context, string](a + a)
}
return Left[context.Context, string, string]("e")
return Left[context.Context, string]("e")
})
ctx := context.Background()
assert.Equal(t, either.Right[string](A.Empty[string]()), F.Pipe1(A.Empty[string](), f)(ctx)())

13
v2/readerioeither/bind.go
View File

@@ -16,6 +16,7 @@
package readerioeither
import (
F "github.com/IBM/fp-go/v2/function"
IOE "github.com/IBM/fp-go/v2/ioeither"
L "github.com/IBM/fp-go/v2/optics/lens"
G "github.com/IBM/fp-go/v2/readerioeither/generic"
@@ -40,7 +41,7 @@ import (
func Do[R, E, S any](
empty S,
) ReaderIOEither[R, E, S] {
return G.Do[ReaderIOEither[R, E, S], IOE.IOEither[E, S], R, E, S](empty)
return G.Do[ReaderIOEither[R, E, S]](empty)
}
// Bind attaches the result of a computation to a context [S1] to produce a context [S2].
@@ -91,7 +92,7 @@ func Bind[R, E, S1, S2, T any](
setter func(T) func(S1) S2,
f func(S1) ReaderIOEither[R, E, T],
) Operator[R, E, S1, S2] {
return G.Bind[ReaderIOEither[R, E, S1], ReaderIOEither[R, E, S2], ReaderIOEither[R, E, T], IOE.IOEither[E, S1], IOE.IOEither[E, S2], IOE.IOEither[E, T], R, E, S1, S2, T](setter, f)
return G.Bind[ReaderIOEither[R, E, S1], ReaderIOEither[R, E, S2]](setter, f)
}
// Let attaches the result of a computation to a context [S1] to produce a context [S2]
@@ -250,9 +251,7 @@ func BindL[R, E, S, T any](
lens L.Lens[S, T],
f func(T) ReaderIOEither[R, E, T],
) Operator[R, E, S, S] {
return Bind[R, E, S, S, T](lens.Set, func(s S) ReaderIOEither[R, E, T] {
return f(lens.Get(s))
})
return Bind[R, E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetL is a variant of Let that uses a lens to focus on a specific part of the context.
@@ -288,9 +287,7 @@ func LetL[R, E, S, T any](
lens L.Lens[S, T],
f func(T) T,
) Operator[R, E, S, S] {
return Let[R, E, S, S, T](lens.Set, func(s S) T {
return f(lens.Get(s))
})
return Let[R, E, S, S, T](lens.Set, F.Flow2(lens.Get, f))
}
// LetToL is a variant of LetTo that uses a lens to focus on a specific part of the context.

109
v2/readerioeither/monoid.go Normal file
View File

@@ -0,0 +1,109 @@
// 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
import (
"github.com/IBM/fp-go/v2/lazy"
"github.com/IBM/fp-go/v2/monoid"
)
type (
Monoid[R, E, A any] = monoid.Monoid[ReaderIOEither[R, E, A]]
)
// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This uses the default applicative behavior (parallel or sequential based on useParallel flag).
//
// The monoid combines two ReaderIOResult values by applying the underlying monoid's combine operation
// to their success values using applicative application.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A].
func ApplicativeMonoid[R, E, A any](m monoid.Monoid[A]) Monoid[R, E, A] {
return monoid.ApplicativeMonoid(
Of[R, E, A],
MonadMap[R, E, A, func(A) A],
MonadAp[R, E, A, A],
m,
)
}
// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses sequential execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with sequential execution.
func ApplicativeMonoidSeq[R, E, A any](m monoid.Monoid[A]) Monoid[R, E, A] {
return monoid.ApplicativeMonoid(
Of[R, E, A],
MonadMap[R, E, A, func(A) A],
MonadApSeq[R, E, A, A],
m,
)
}
// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses parallel execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with parallel execution.
func ApplicativeMonoidPar[R, E, A any](m monoid.Monoid[A]) Monoid[R, E, A] {
return monoid.ApplicativeMonoid(
Of[R, E, A],
MonadMap[R, E, A, func(A) A],
MonadApPar[R, E, A, A],
m,
)
}
// AlternativeMonoid is the alternative [Monoid] for [ReaderIOResult].
// This combines ReaderIOResult values using the alternative semantics,
// where the second value is only evaluated if the first fails.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with alternative semantics.
func AlternativeMonoid[R, E, A any](m monoid.Monoid[A]) Monoid[R, E, A] {
return monoid.AlternativeMonoid(
Of[R, E, A],
MonadMap[R, E, A, func(A) A],
MonadAp[R, E, A, A],
MonadAlt[R, E, A],
m,
)
}
// AltMonoid is the alternative [Monoid] for a [ReaderIOResult].
// This creates a monoid where the empty value is provided lazily,
// and combination uses the Alt operation (try first, fallback to second on failure).
//
// Parameters:
// - zero: Lazy computation that provides the empty/identity value
//
// Returns a Monoid for ReaderIOResult[A] with Alt-based combination.
func AltMonoid[R, E, A any](zero lazy.Lazy[ReaderIOEither[R, E, A]]) Monoid[R, E, A] {
return monoid.AltMonoid(
zero,
MonadAlt[R, E, A],
)
}

15
v2/readerioeither/reader.go
View File

@@ -26,7 +26,6 @@ import (
"github.com/IBM/fp-go/v2/internal/fromreader"
"github.com/IBM/fp-go/v2/internal/functor"
"github.com/IBM/fp-go/v2/io"
"github.com/IBM/fp-go/v2/ioeither"
IOE "github.com/IBM/fp-go/v2/ioeither"
L "github.com/IBM/fp-go/v2/lazy"
O "github.com/IBM/fp-go/v2/option"
@@ -398,12 +397,12 @@ func FromEither[R, E, A any](t either.Either[E, A]) ReaderIOEither[R, E, A] {
// RightReader lifts a Reader into a ReaderIOEither, placing the result in the Right side.
func RightReader[E, R, A any](ma Reader[R, A]) ReaderIOEither[R, E, A] {
return function.Flow2(ma, ioeither.Right[E, A])
return function.Flow2(ma, IOE.Right[E, A])
}
// LeftReader lifts a Reader into a ReaderIOEither, placing the result in the Left (error) side.
func LeftReader[A, R, E any](ma Reader[R, E]) ReaderIOEither[R, E, A] {
return function.Flow2(ma, ioeither.Left[A, E])
return function.Flow2(ma, IOE.Left[A, E])
}
// FromReader lifts a Reader into a ReaderIOEither context.
@@ -414,12 +413,12 @@ func FromReader[E, R, A any](ma Reader[R, A]) ReaderIOEither[R, E, A] {
// RightIO lifts an IO into a ReaderIOEither, placing the result in the Right side.
func RightIO[R, E, A any](ma io.IO[A]) ReaderIOEither[R, E, A] {
return function.Pipe2(ma, ioeither.RightIO[E, A], FromIOEither[R, E, A])
return function.Pipe2(ma, IOE.RightIO[E, A], FromIOEither[R, E, A])
}
// LeftIO lifts an IO into a ReaderIOEither, placing the result in the Left (error) side.
func LeftIO[R, A, E any](ma io.IO[E]) ReaderIOEither[R, E, A] {
return function.Pipe2(ma, ioeither.LeftIO[A, E], FromIOEither[R, E, A])
return function.Pipe2(ma, IOE.LeftIO[A, E], FromIOEither[R, E, A])
}
// FromIO lifts an IO into a ReaderIOEither context.
@@ -439,7 +438,7 @@ func FromIOEither[R, E, A any](ma IOE.IOEither[E, A]) ReaderIOEither[R, E, A] {
// FromReaderEither lifts a ReaderEither into a ReaderIOEither context.
// The Either result is lifted into an IO effect.
func FromReaderEither[R, E, A any](ma RE.ReaderEither[R, E, A]) ReaderIOEither[R, E, A] {
return function.Flow2(ma, ioeither.FromEither[E, A])
return function.Flow2(ma, IOE.FromEither[E, A])
}
// Ask returns a ReaderIOEither that retrieves the current context.
@@ -535,7 +534,7 @@ func BiMap[R, E1, E2, A, B any](f func(E1) E2, g func(A) B) func(ReaderIOEither[
//
//go:inline
func Swap[R, E, A any](val ReaderIOEither[R, E, A]) ReaderIOEither[R, A, E] {
return reader.MonadMap(val, ioeither.Swap[E, A])
return reader.MonadMap(val, IOE.Swap[E, A])
}
// Defer creates a ReaderIOEither lazily via a generator function.
@@ -550,7 +549,7 @@ func Defer[R, E, A any](gen L.Lazy[ReaderIOEither[R, E, A]]) ReaderIOEither[R, E
// The onThrow function converts the error into the desired error type.
func TryCatch[R, E, A any](f func(R) func() (A, error), onThrow func(error) E) ReaderIOEither[R, E, A] {
return func(r R) IOEither[E, A] {
return ioeither.TryCatch(f(r), onThrow)
return IOE.TryCatch(f(r), onThrow)
}
}

25
v2/readerioeither/readerioeither_test.go
View File

@@ -19,6 +19,7 @@ import (
"context"
"errors"
"fmt"
"strconv"
"testing"
E "github.com/IBM/fp-go/v2/either"
@@ -69,7 +70,7 @@ func TestChainFirst(t *testing.T) {
ctx := testContext{value: 10}
result := F.Pipe1(
Of[testContext, error](5),
ChainFirst[testContext, error](func(x int) ReaderIOEither[testContext, error, string] {
ChainFirst(func(x int) ReaderIOEither[testContext, error, string] {
return Of[testContext, error](fmt.Sprintf("%d", x))
}),
)
@@ -102,7 +103,7 @@ func TestChainFirstEitherK(t *testing.T) {
ctx := testContext{value: 10}
result := F.Pipe1(
Of[testContext, error](5),
ChainFirstEitherK[testContext, error](func(x int) E.Either[error, string] {
ChainFirstEitherK[testContext](func(x int) E.Either[error, string] {
return E.Right[error](fmt.Sprintf("%d", x))
}),
)
@@ -135,7 +136,7 @@ func TestChainIOEitherK(t *testing.T) {
ctx := testContext{value: 10}
result := F.Pipe1(
Of[testContext, error](5),
ChainIOEitherK[testContext, error](func(x int) IOE.IOEither[error, int] {
ChainIOEitherK[testContext](func(x int) IOE.IOEither[error, int] {
return IOE.Right[error](x * 2)
}),
)
@@ -357,7 +358,7 @@ func TestFold(t *testing.T) {
ctx := testContext{value: 10}
// Test Right case
resultRight := Fold[testContext, error, int, string](
resultRight := Fold(
func(e error) RIO.ReaderIO[testContext, string] {
return RIO.Of[testContext]("error: " + e.Error())
},
@@ -417,16 +418,16 @@ func TestMonadBiMap(t *testing.T) {
// Test Right case
resultRight := MonadBiMap(
Of[testContext, error](5),
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
)
assert.Equal(t, E.Right[string]("5"), resultRight(ctx)())
// Test Left case
resultLeft := MonadBiMap(
Left[testContext, int](errors.New("test")),
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
)
assert.Equal(t, E.Left[string]("test"), resultLeft(ctx)())
}
@@ -436,8 +437,8 @@ func TestBiMap(t *testing.T) {
result := F.Pipe1(
Of[testContext, error](5),
BiMap[testContext, error, string](
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
),
)
assert.Equal(t, E.Right[string]("5"), result(ctx)())
@@ -765,7 +766,7 @@ func TestTraverseRecord(t *testing.T) {
func TestTraverseRecordWithIndex(t *testing.T) {
ctx := testContext{value: 10}
result := TraverseRecordWithIndex[string, testContext, error](func(k string, x int) ReaderIOEither[testContext, error, string] {
result := TraverseRecordWithIndex(func(k string, x int) ReaderIOEither[testContext, error, string] {
return Of[testContext, error](fmt.Sprintf("%s:%d", k, x))
})(map[string]int{"a": 1, "b": 2})
@@ -775,7 +776,7 @@ func TestTraverseRecordWithIndex(t *testing.T) {
func TestSequenceRecord(t *testing.T) {
ctx := testContext{value: 10}
result := SequenceRecord[string, testContext, error](map[string]ReaderIOEither[testContext, error, int]{
result := SequenceRecord(map[string]ReaderIOEither[testContext, error, int]{
"a": Of[testContext, error](1),
"b": Of[testContext, error](2),
})

2
v2/readerioeither/resource.go
View File

@@ -51,7 +51,7 @@ import "github.com/IBM/fp-go/v2/ioeither"
// result := withFile(func(f *File) ReaderIOEither[Config, error, string] {
// return readContent(f)
// })
func WithResource[A, L, E, R, ANY any](onCreate ReaderIOEither[L, E, R], onRelease func(R) ReaderIOEither[L, E, ANY]) func(func(R) ReaderIOEither[L, E, A]) ReaderIOEither[L, E, A] {
func WithResource[A, L, E, R, ANY any](onCreate ReaderIOEither[L, E, R], onRelease Kleisli[L, E, R, ANY]) Kleisli[L, E, Kleisli[L, E, R, A], A] {
return func(f func(R) ReaderIOEither[L, E, A]) ReaderIOEither[L, E, A] {
return func(l L) ioeither.IOEither[E, A] {
// dispatch to the generic implementation

86
v2/readerioresult/monoid.go Normal file
View File

@@ -0,0 +1,86 @@
// 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 readerioresult
import (
"github.com/IBM/fp-go/v2/lazy"
"github.com/IBM/fp-go/v2/monoid"
RIOE "github.com/IBM/fp-go/v2/readerioeither"
)
type (
Monoid[R, A any] = monoid.Monoid[ReaderIOResult[R, A]]
)
// ApplicativeMonoid returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This uses the default applicative behavior (parallel or sequential based on useParallel flag).
//
// The monoid combines two ReaderIOResult values by applying the underlying monoid's combine operation
// to their success values using applicative application.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A].
func ApplicativeMonoid[R, A any](m monoid.Monoid[A]) Monoid[R, A] {
return RIOE.AlternativeMonoid[R, error](m)
}
// ApplicativeMonoidSeq returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses sequential execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with sequential execution.
func ApplicativeMonoidSeq[R, A any](m monoid.Monoid[A]) Monoid[R, A] {
return RIOE.ApplicativeMonoidSeq[R, error](m)
}
// ApplicativeMonoidPar returns a [Monoid] that concatenates [ReaderIOResult] instances via their applicative.
// This explicitly uses parallel execution for combining values.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with parallel execution.
func ApplicativeMonoidPar[R, A any](m monoid.Monoid[A]) Monoid[R, A] {
return RIOE.ApplicativeMonoidPar[R, error](m)
}
// AlternativeMonoid is the alternative [Monoid] for [ReaderIOResult].
// This combines ReaderIOResult values using the alternative semantics,
// where the second value is only evaluated if the first fails.
//
// Parameters:
// - m: The underlying monoid for type A
//
// Returns a Monoid for ReaderIOResult[A] with alternative semantics.
func AlternativeMonoid[R, A any](m monoid.Monoid[A]) Monoid[R, A] {
return RIOE.AlternativeMonoid[R, error](m)
}
// AltMonoid is the alternative [Monoid] for a [ReaderIOResult].
// This creates a monoid where the empty value is provided lazily,
// and combination uses the Alt operation (try first, fallback to second on failure).
//
// Parameters:
// - zero: Lazy computation that provides the empty/identity value
//
// Returns a Monoid for ReaderIOResult[A] with Alt-based combination.
func AltMonoid[R, A any](zero lazy.Lazy[ReaderIOResult[R, A]]) Monoid[R, A] {
return RIOE.AltMonoid[R, error](zero)
}

13
v2/readerioresult/readerioeither_test.go
View File

@@ -19,6 +19,7 @@ import (
"context"
"errors"
"fmt"
"strconv"
"testing"
E "github.com/IBM/fp-go/v2/either"
@@ -401,16 +402,16 @@ func TestMonadBiMap(t *testing.T) {
// Test Right case
resultRight := MonadBiMap(
Of[testContext](5),
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
)
assert.Equal(t, E.Of[string]("5"), resultRight(ctx)())
// Test Left case
resultLeft := MonadBiMap(
Left[testContext, int](errors.New("test")),
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
)
assert.Equal(t, E.Left[string]("test"), resultLeft(ctx)())
}
@@ -420,8 +421,8 @@ func TestBiMap(t *testing.T) {
res := F.Pipe1(
Of[testContext](5),
BiMap[testContext](
func(e error) string { return e.Error() },
func(x int) string { return fmt.Sprintf("%d", x) },
error.Error,
strconv.Itoa,
),
)
assert.Equal(t, E.Of[string]("5"), res(ctx)())

2
v2/readerioresult/traverse.go
View File

@@ -169,7 +169,7 @@ func TraverseRecord[K comparable, R, A, B any](f Kleisli[R, A, B]) Kleisli[R, ma
//
//go:inline
func TraverseRecordWithIndex[K comparable, R, A, B any](f func(K, A) ReaderIOResult[R, B]) Kleisli[R, map[K]A, map[K]B] {
return RIOE.TraverseRecordWithIndex[K](f)
return RIOE.TraverseRecordWithIndex(f)
}
// SequenceRecord converts a map of ReaderIOResult into a ReaderIOResult of a map.

4
v2/result/either.go
View File

@@ -96,7 +96,7 @@ func MonadMap[A, B any](fa Result[A], f func(a A) B) Result[B] {
//
// result := either.MonadBiMap(
// either.Left[int](errors.New("error")),
// func(e error) string { return e.Error() },
// error.Error,
// func(n int) string { return fmt.Sprint(n) },
// ) // Left("error")
//
@@ -139,7 +139,7 @@ func MapTo[A, B any](b B) Operator[A, B] {
//
// result := either.MonadMapLeft(
// either.Left[int](errors.New("error")),
// func(e error) string { return e.Error() },
// error.Error,
// ) // Left("error")
//
//go:inline

4
v2/result/resource.go
View File

@@ -43,6 +43,6 @@ import (
// // Use file here
// return either.Right[error]("data")
// })
func WithResource[R, A any](onCreate func() Result[R], onRelease Kleisli[R, any]) Kleisli[Kleisli[R, A], A] {
return either.WithResource[error, R, A](onCreate, onRelease)
func WithResource[R, A, ANY any](onCreate func() Result[R], onRelease Kleisli[R, ANY]) Kleisli[Kleisli[R, A], A] {
return either.WithResource[error, R, A, ANY](onCreate, onRelease)
}

36
v2/runCodeActions.bat Normal file
View File

@@ -0,0 +1,36 @@
@echo off
setlocal enabledelayedexpansion
echo Finding and fixing unnecessary type arguments...
echo.
REM Find all Go files recursively
for /r %%f in (*.go) do (
echo Checking %%f...
REM Run gopls check and capture output
for /f "tokens=1,2,3,4 delims=:" %%a in ('gopls check --severity=hint "%%f" 2^>^&1 ^| findstr /C:"unnecessary type arguments" ^| sort /R') do (
set "drive=%%a"
set "file=%%b"
set "line=%%c"
set "col=%%d"
REM Construct position
set "pos=!drive!:!file!:!line!:!col!"
echo Found issue at !pos!
echo Applying fix...
REM Apply code action
gopls codeaction -w -exec "!pos!"
if !errorlevel! equ 0 (
echo Fixed successfully
) else (
echo Warning: Fix may have failed
)
echo.
)
)
echo Done!

6
v2/samples/http/http_test.go
View File

@@ -23,8 +23,8 @@ import (
HTTP "net/http"
A "github.com/IBM/fp-go/v2/array"
R "github.com/IBM/fp-go/v2/context/readerioeither"
H "github.com/IBM/fp-go/v2/context/readerioeither/http"
R "github.com/IBM/fp-go/v2/context/readerioresult"
H "github.com/IBM/fp-go/v2/context/readerioresult/http"
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
IO "github.com/IBM/fp-go/v2/io"
@@ -74,7 +74,7 @@ func TestMultipleHttpRequests(t *testing.T) {
assert.Equal(t, E.Of[error](count), result())
}
func heterogeneousHTTPRequests() ReaderIOEither[T.Tuple2[PostItem, CatFact]] {
func heterogeneousHTTPRequests() ReaderIOResult[T.Tuple2[PostItem, CatFact]] {
// prepare the http client
client := H.MakeClient(HTTP.DefaultClient)
// readSinglePost sends a GET request and parses the response as [PostItem]

6
v2/samples/http/types.go
View File

@@ -15,10 +15,8 @@
package http
import (
"github.com/IBM/fp-go/v2/context/readerioeither"
)
import "github.com/IBM/fp-go/v2/context/readerioresult"
type (
ReaderIOEither[A any] = readerioeither.ReaderIOEither[A]
ReaderIOResult[A any] = readerioresult.ReaderIOResult[A]
)

4
v2/samples/mostly-adequate/chapter06_exampleapplication_test.go
View File

@@ -27,8 +27,8 @@ import (
J "github.com/IBM/fp-go/v2/json"
S "github.com/IBM/fp-go/v2/string"
R "github.com/IBM/fp-go/v2/context/readerioeither"
H "github.com/IBM/fp-go/v2/context/readerioeither/http"
R "github.com/IBM/fp-go/v2/context/readerioresult"
H "github.com/IBM/fp-go/v2/context/readerioresult/http"
)
type (

4
v2/samples/mostly-adequate/chapter10_applicativefunctor_test.go
View File

@@ -20,8 +20,8 @@ import (
"fmt"
"net/http"
R "github.com/IBM/fp-go/v2/context/readerioeither"
H "github.com/IBM/fp-go/v2/context/readerioeither/http"
R "github.com/IBM/fp-go/v2/context/readerioresult"
H "github.com/IBM/fp-go/v2/context/readerioresult/http"
F "github.com/IBM/fp-go/v2/function"
IOO "github.com/IBM/fp-go/v2/iooption"
N "github.com/IBM/fp-go/v2/number"

6
v2/samples/presentation/benchmarks/http_test.go
View File

@@ -24,8 +24,8 @@ import (
HTTP "net/http"
A "github.com/IBM/fp-go/v2/array"
R "github.com/IBM/fp-go/v2/context/readerioeither"
H "github.com/IBM/fp-go/v2/context/readerioeither/http"
R "github.com/IBM/fp-go/v2/context/readerioresult"
H "github.com/IBM/fp-go/v2/context/readerioresult/http"
F "github.com/IBM/fp-go/v2/function"
T "github.com/IBM/fp-go/v2/tuple"
)
@@ -41,7 +41,7 @@ type CatFact struct {
Fact string `json:"fact"`
}
func heterogeneousHTTPRequests(count int) R.ReaderIOEither[[]T.Tuple2[PostItem, CatFact]] {
func heterogeneousHTTPRequests(count int) R.ReaderIOResult[[]T.Tuple2[PostItem, CatFact]] {
// prepare the http client
client := H.MakeClient(HTTP.DefaultClient)
// readSinglePost sends a GET request and parses the response as [PostItem]

4
v2/samples/readfile/readfile_test.go
View File

@@ -21,8 +21,8 @@ import (
"testing"
A "github.com/IBM/fp-go/v2/array"
R "github.com/IBM/fp-go/v2/context/readerioeither"
"github.com/IBM/fp-go/v2/context/readerioeither/file"
R "github.com/IBM/fp-go/v2/context/readerioresult"
"github.com/IBM/fp-go/v2/context/readerioresult/file"
E "github.com/IBM/fp-go/v2/either"
F "github.com/IBM/fp-go/v2/function"
IO "github.com/IBM/fp-go/v2/io"