mirror of
https://github.com/IBM/fp-go.git
synced 2025-11-25 22:21:49 +02:00
fix: slowly migrate IO
Signed-off-by: Dr. Carsten Leue <carsten.leue@de.ibm.com>
This commit is contained in:
Dr. Carsten Leue
175
v2/io/io.go
175
v2/io/io.go
@@ -18,152 +18,253 @@ package io
|
||||
import (
|
||||
"time"
|
||||
|
||||
G "github.com/IBM/fp-go/v2/io/generic"
|
||||
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"
|
||||
INTL "github.com/IBM/fp-go/v2/internal/lazy"
|
||||
T "github.com/IBM/fp-go/v2/tuple"
|
||||
)
|
||||
|
||||
const (
|
||||
// useParallel is the feature flag to control if we use the parallel or the sequential implementation of ap
|
||||
useParallel = true
|
||||
)
|
||||
|
||||
var (
|
||||
// undefined represents an undefined value
|
||||
undefined = struct{}{}
|
||||
)
|
||||
|
||||
// IO represents a synchronous computation that cannot fail
|
||||
// refer to [https://andywhite.xyz/posts/2021-01-27-rte-foundations/#ioltagt] for more details
|
||||
type IO[A any] func() A
|
||||
|
||||
func MakeIO[A any](f func() A) IO[A] {
|
||||
return G.MakeIO[IO[A]](f)
|
||||
}
|
||||
type IO[A any] = func() A
|
||||
|
||||
func Of[A any](a A) IO[A] {
|
||||
return G.Of[IO[A]](a)
|
||||
return F.Constant(a)
|
||||
}
|
||||
|
||||
func FromIO[A any](a IO[A]) IO[A] {
|
||||
return G.FromIO(a)
|
||||
return a
|
||||
}
|
||||
|
||||
// FromImpure converts a side effect without a return value into a side effect that returns any
|
||||
func FromImpure(f func()) IO[any] {
|
||||
return G.FromImpure[IO[any]](f)
|
||||
return func() any {
|
||||
f()
|
||||
return undefined
|
||||
}
|
||||
}
|
||||
|
||||
func MonadOf[A any](a A) IO[A] {
|
||||
return G.MonadOf[IO[A]](a)
|
||||
return F.Constant(a)
|
||||
}
|
||||
|
||||
func MonadMap[A, B any](fa IO[A], f func(A) B) IO[B] {
|
||||
return G.MonadMap[IO[A], IO[B]](fa, f)
|
||||
return func() B {
|
||||
return f(fa())
|
||||
}
|
||||
}
|
||||
|
||||
func Map[A, B any](f func(A) B) func(fa IO[A]) IO[B] {
|
||||
return G.Map[IO[A], IO[B]](f)
|
||||
return F.Bind2nd(MonadMap[A, B], f)
|
||||
}
|
||||
|
||||
func MonadMapTo[A, B any](fa IO[A], b B) IO[B] {
|
||||
return G.MonadMapTo[IO[A], IO[B]](fa, b)
|
||||
return MonadMap(fa, F.Constant1[A](b))
|
||||
}
|
||||
|
||||
func MapTo[A, B any](b B) func(IO[A]) IO[B] {
|
||||
return G.MapTo[IO[A], IO[B]](b)
|
||||
return Map(F.Constant1[A](b))
|
||||
}
|
||||
|
||||
// MonadChain composes computations in sequence, using the return value of one computation to determine the next computation.
|
||||
func MonadChain[A, B any](fa IO[A], f func(A) IO[B]) IO[B] {
|
||||
return G.MonadChain(fa, f)
|
||||
return func() B {
|
||||
return f(fa())()
|
||||
}
|
||||
}
|
||||
|
||||
// Chain composes computations in sequence, using the return value of one computation to determine the next computation.
|
||||
func Chain[A, B any](f func(A) IO[B]) func(IO[A]) IO[B] {
|
||||
return G.Chain[IO[A]](f)
|
||||
return F.Bind2nd(MonadChain[A, B], f)
|
||||
}
|
||||
|
||||
func MonadAp[B, A any](mab IO[func(A) B], ma IO[A]) IO[B] {
|
||||
return G.MonadAp[IO[A], IO[B]](mab, ma)
|
||||
// MonadApSeq implements the applicative on a single thread by first executing mab and the ma
|
||||
func MonadApSeq[A, B any](mab IO[func(A) B], ma IO[A]) IO[B] {
|
||||
return MonadChain(mab, F.Bind1st(MonadMap[A, B], ma))
|
||||
}
|
||||
|
||||
// MonadApPar implements the applicative on two threads, the main thread executes mab and the actuall
|
||||
// apply operation and the second thread computes ma. Communication between the threads happens via a channel
|
||||
func MonadApPar[A, B any](mab IO[func(A) B], ma IO[A]) IO[B] {
|
||||
return func() B {
|
||||
c := make(chan A)
|
||||
go func() {
|
||||
c <- ma()
|
||||
close(c)
|
||||
}()
|
||||
return mab()(<-c)
|
||||
}
|
||||
}
|
||||
|
||||
// MonadAp implements the `ap` operation. Depending on a feature flag this will be sequential or parallel, the preferred implementation
|
||||
// is parallel
|
||||
func MonadAp[A, B any](mab IO[func(A) B], ma IO[A]) IO[B] {
|
||||
if useParallel {
|
||||
return MonadApPar(mab, ma)
|
||||
}
|
||||
return MonadApSeq(mab, ma)
|
||||
}
|
||||
|
||||
func Ap[B, A any](ma IO[A]) func(IO[func(A) B]) IO[B] {
|
||||
return G.Ap[IO[B], IO[func(A) B], IO[A]](ma)
|
||||
return F.Bind2nd(MonadAp[A, B], ma)
|
||||
}
|
||||
|
||||
func Flatten[A any](mma IO[IO[A]]) IO[A] {
|
||||
return G.Flatten(mma)
|
||||
return MonadChain(mma, F.Identity)
|
||||
}
|
||||
|
||||
// Memoize computes the value of the provided [IO] monad lazily but exactly once
|
||||
func Memoize[A any](ma IO[A]) IO[A] {
|
||||
return G.Memoize(ma)
|
||||
return INTL.Memoize(ma)
|
||||
}
|
||||
|
||||
// MonadChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
|
||||
// keeping only the result of the first.
|
||||
func MonadChainFirst[A, B any](fa IO[A], f func(A) IO[B]) IO[A] {
|
||||
return G.MonadChainFirst(fa, f)
|
||||
return INTC.MonadChainFirst(MonadChain[A, A], MonadMap[B, A], fa, f)
|
||||
}
|
||||
|
||||
// ChainFirst composes computations in sequence, using the return value of one computation to determine the next computation and
|
||||
// keeping only the result of the first.
|
||||
func ChainFirst[A, B any](f func(A) IO[B]) func(IO[A]) IO[A] {
|
||||
return G.ChainFirst[IO[A]](f)
|
||||
return INTC.ChainFirst(
|
||||
Chain[A, A],
|
||||
Map[B, A],
|
||||
f,
|
||||
)
|
||||
}
|
||||
|
||||
// MonadApFirst combines two effectful actions, keeping only the result of the first.
|
||||
func MonadApFirst[A, B any](first IO[A], second IO[B]) IO[A] {
|
||||
return G.MonadApFirst[IO[A], IO[B], IO[func(B) A]](first, second)
|
||||
return INTA.MonadApFirst(
|
||||
MonadAp[B, A],
|
||||
MonadMap[A, func(B) A],
|
||||
|
||||
first,
|
||||
second,
|
||||
)
|
||||
}
|
||||
|
||||
// ApFirst combines two effectful actions, keeping only the result of the first.
|
||||
func ApFirst[A, B any](second IO[B]) func(IO[A]) IO[A] {
|
||||
return G.ApFirst[IO[A], IO[B], IO[func(B) A]](second)
|
||||
return INTA.ApFirst(
|
||||
MonadAp[B, A],
|
||||
MonadMap[A, func(B) A],
|
||||
|
||||
second,
|
||||
)
|
||||
}
|
||||
|
||||
// MonadApSecond combines two effectful actions, keeping only the result of the second.
|
||||
func MonadApSecond[A, B any](first IO[A], second IO[B]) IO[B] {
|
||||
return G.MonadApSecond[IO[A], IO[B], IO[func(B) B]](first, second)
|
||||
return INTA.MonadApSecond(
|
||||
MonadAp[B, B],
|
||||
MonadMap[A, func(B) B],
|
||||
|
||||
first,
|
||||
second,
|
||||
)
|
||||
}
|
||||
|
||||
// ApSecond combines two effectful actions, keeping only the result of the second.
|
||||
func ApSecond[A, B any](second IO[B]) func(IO[A]) IO[B] {
|
||||
return G.ApSecond[IO[A], IO[B], IO[func(B) B]](second)
|
||||
return INTA.ApSecond(
|
||||
MonadAp[B, B],
|
||||
MonadMap[A, func(B) B],
|
||||
|
||||
second,
|
||||
)
|
||||
}
|
||||
|
||||
// MonadChainTo composes computations in sequence, ignoring the return value of the first computation
|
||||
func MonadChainTo[A, B any](fa IO[A], fb IO[B]) IO[B] {
|
||||
return G.MonadChainTo(fa, fb)
|
||||
return MonadChain(fa, F.Constant1[A](fb))
|
||||
}
|
||||
|
||||
// ChainTo composes computations in sequence, ignoring the return value of the first computation
|
||||
func ChainTo[A, B any](fb IO[B]) func(IO[A]) IO[B] {
|
||||
return G.ChainTo[IO[A]](fb)
|
||||
return Chain(F.Constant1[A](fb))
|
||||
}
|
||||
|
||||
// Now returns the current timestamp
|
||||
var Now = G.Now[IO[time.Time]]()
|
||||
var Now IO[time.Time] = time.Now
|
||||
|
||||
// Defer creates an IO by creating a brand new IO via a generator function, each time
|
||||
func Defer[A any](gen func() IO[A]) IO[A] {
|
||||
return G.Defer[IO[A]](gen)
|
||||
return func() A {
|
||||
return gen()()
|
||||
}
|
||||
}
|
||||
|
||||
func MonadFlap[B, A any](fab IO[func(A) B], a A) IO[B] {
|
||||
return G.MonadFlap[func(A) B, IO[func(A) B], IO[B], A, B](fab, a)
|
||||
return INTF.MonadFlap(MonadMap[func(A) B, B], fab, a)
|
||||
}
|
||||
|
||||
func Flap[B, A any](a A) func(IO[func(A) B]) IO[B] {
|
||||
return G.Flap[func(A) B, IO[func(A) B], IO[B], A, B](a)
|
||||
return INTF.Flap(Map[func(A) B, B], a)
|
||||
}
|
||||
|
||||
// Delay creates an operation that passes in the value after some delay
|
||||
func Delay[A any](delay time.Duration) func(IO[A]) IO[A] {
|
||||
return G.Delay[IO[A]](delay)
|
||||
return func(ga IO[A]) IO[A] {
|
||||
return func() A {
|
||||
time.Sleep(delay)
|
||||
return ga()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func after(timestamp time.Time) func() {
|
||||
return func() {
|
||||
// check if we need to wait
|
||||
current := time.Now()
|
||||
if current.Before(timestamp) {
|
||||
time.Sleep(timestamp.Sub(current))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// After creates an operation that passes after the given timestamp
|
||||
func After[A any](timestamp time.Time) func(IO[A]) IO[A] {
|
||||
return G.After[IO[A]](timestamp)
|
||||
aft := after(timestamp)
|
||||
return func(ga IO[A]) IO[A] {
|
||||
return func() A {
|
||||
// wait as long as necessary
|
||||
aft()
|
||||
// execute after wait
|
||||
return ga()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// WithTime returns an operation that measures the start and end [time.Time] of the operation
|
||||
func WithTime[A any](a IO[A]) IO[T.Tuple3[A, time.Time, time.Time]] {
|
||||
return G.WithTime[IO[T.Tuple3[A, time.Time, time.Time]], IO[A]](a)
|
||||
return func() T.Tuple3[A, time.Time, time.Time] {
|
||||
t0 := time.Now()
|
||||
res := a()
|
||||
t1 := time.Now()
|
||||
return T.MakeTuple3(res, t0, t1)
|
||||
}
|
||||
}
|
||||
|
||||
// WithDuration returns an operation that measures the [time.Duration]
|
||||
func WithDuration[A any](a IO[A]) IO[T.Tuple2[A, time.Duration]] {
|
||||
return G.WithDuration[IO[T.Tuple2[A, time.Duration]], IO[A]](a)
|
||||
return func() T.Tuple2[A, time.Duration] {
|
||||
t0 := time.Now()
|
||||
res := a()
|
||||
t1 := time.Now()
|
||||
return T.MakeTuple2(res, t1.Sub(t0))
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user