Move core into package

Author: vic

abort/abort.go

@@ -1,6 +1,6 @@
 package abort
 
-import fx "github.com/vic/fx.go"
+import "github.com/vic/fx.go/fx"
 
 type AbortFn[E any] func(E) fx.FxNil
 type AbortAb[E any] = fx.And[AbortFn[E], fx.Nil]

abort/abort_test.go

@@ -3,7 +3,7 @@ package abort
 import (
 	"testing"
 
-	fx "github.com/vic/fx.go"
+	"github.com/vic/fx.go/fx"
 )
 
 func TestSuccess(t *testing.T) {

abort/result.go

@@ -1,6 +1,6 @@
 package abort
 
-import fx "github.com/vic/fx.go"
+import "github.com/vic/fx.go/fx"
 
 type Result[V, E any] func() (*V, *E)
 

fx.go

@@ -0,0 +1,45 @@
+package fx
+
+type And[A, B any] func() (A, B)
+
+func swap[A, B any](ab And[A, B]) And[B, A] {
+	var ba And[B, A] = func() (B, A) {
+		a, b := ab()
+		return b, a
+	}
+	return ba
+}
+
+func left[A, B any](ab And[A, B]) A {
+	a, _ := ab()
+	return a
+}
+
+func right[A, B any](ab And[A, B]) B {
+	_, b := ab()
+	return b
+}
+
+func AndNil[S, V any](e Fx[S, V]) Fx[And[S, Nil], V] {
+	return Then[And[S, Nil], V](left, Const)(e)
+}
+
+func AndContra[A, B, V any](e Fx[A, V], f func(B) A) Fx[B, V] {
+	return ContraMap[V](f)(e)
+}
+
+func AndSwap[A, B, V any](e Fx[And[A, B], V]) Fx[And[B, A], V] {
+	return Then[And[B, A], V](swap[B, A], Const)(e)
+}
+
+func AndFlat[A, B, V any](e Fx[A, Fx[B, V]]) Fx[And[A, B], V] {
+	return FlatMap(e, identity)
+}
+
+func AndNest[A, B, V any](e Fx[And[A, B], V]) Fx[A, Fx[B, V]] {
+	return Pending(func(a A) Fx[A, Fx[B, V]] { return Const[A](ProvideLeft(e, a)) })
+}
+
+func AndCollapse[A, V any](e Fx[And[A, A], V]) Fx[A, V] {
+	return Pending(func(a A) Fx[A, V] { return ProvideLeft(e, a) })
+}

fx/and.go

@@ -0,0 +1,49 @@
+package fx
+
+type Fx[S, V any] struct {
+	// an immediate value
+	imm func() V
+	// the continuation of a suspended effect
+	sus func(S) Fx[S, V]
+	// the resume function of an stopped effect
+	res func() Fx[S, V]
+}
+
+func Pure[V any](v V) FxPure[V] { return Const[Nil](v) }
+
+func identity[V any](v V) V { return v }
+
+func Const[S, V any](v V) Fx[S, V] { return Fx[S, V]{imm: func() V { return v }} }
+
+func Pending[S, V any](f func(S) Fx[S, V]) Fx[S, V] { return Fx[S, V]{sus: f} }
+
+func Func[S, V any](f func(S) V) Fx[S, V] {
+	return Pending(func(s S) Fx[S, V] { return Const[S](f(s)) })
+}
+
+func Ctx[V any]() Fx[V, V] { return Func(identity[V]) }
+
+// Continue an effect by transforming its immediate value into another effect.
+func Then[T, U, S, V any](cmap func(T) S, fmap func(V) Fx[T, U]) func(Fx[S, V]) Fx[T, U] {
+	return func(e Fx[S, V]) Fx[T, U] {
+		if e.res != nil {
+			return Stop(func() Fx[T, U] { return Then(cmap, fmap)(e.res()) })
+		}
+		if e.imm != nil {
+			return fmap(e.imm())
+		}
+		return Pending(func(t T) Fx[T, U] { return Then(cmap, fmap)(e.sus(cmap(t))) })
+	}
+}
+
+func Eval[V any](e Fx[Nil, V]) V {
+	for {
+		if e.res != nil {
+			panic("tried to evaluate an stopped effect. try using fx.Resume or fx.Replace on it.")
+		}
+		if e.imm != nil {
+			return e.imm()
+		}
+		e = e.sus(PNil)
+	}
+}

fx/fx.go

@@ -0,0 +1,17 @@
+package fx
+
+func Apply[F ~func(I) O, I, O any](i I) Fx[F, O] {
+	return Map(Ctx[F](), func(f F) O { return f(i) })
+}
+
+func Suspend[A ~func(I) Fx[B, O], B, I, O any](i I) Fx[And[A, B], O] {
+	return AndFlat(Apply[A](i))
+}
+
+func Handler[A ~func(I) Fx[B, O], B, I, O any](a A) func(Fx[And[A, B], O]) Fx[B, O] {
+	return func(e Fx[And[A, B], O]) Fx[B, O] { return ProvideLeft(e, a) }
+}
+
+func Handle[F ~func(Fx[And[A, B], O]) Fx[B, O], A ~func(I) Fx[B, O], B, I, O any](i I) Fx[And[F, B], O] {
+	return Suspend[F](Suspend[A](i))
+}