Split Abort and Result

Author: vic

abort/abort.go

@@ -2,35 +2,16 @@ package abort
 
 import fx "github.com/vic/fx.go"
 
-type Result[V, E any] func() (*V, *E)
+type AbortFn[E any] func(E) fx.FxNil
+type AbortAb[E any] = fx.And[AbortFn[E], fx.Nil]
+type AbortFx[E, V any] = fx.Fx[AbortAb[E], V]
 
-func success[V, E any](v V) Result[V, E] { return func() (*V, *E) { return &v, nil } }
-func failure[V, E any](e E) Result[V, E] { return func() (*V, *E) { return nil, &e } }
-
-type AbortFn[V, E any] = func(E) fx.FxPure[V]
-type AbortHn[V, E any] = func(fx.Fx[fx.And[AbortFn[V, E], fx.Nil], V]) fx.FxPure[Result[V, E]]
-type AbortAb[V, E any] = fx.And[AbortFn[V, E], fx.Nil]
-type AbortFx[V, E, U any] = fx.Fx[AbortAb[V, E], U]
-
-func Abort[V, E any](e E) AbortFx[V, E, V] {
-	return fx.Suspend[AbortFn[V, E]](e)
-}
-
-func Succeed[E, V any](v V) AbortFx[V, E, V] {
-	return fx.Map(fx.Ctx[AbortAb[V, E]](), func(_ AbortAb[V, E]) V {
-		return v
+func Abort[V, E any](e E) AbortFx[E, V] {
+	return fx.Map(fx.Handle[AbortFn[E]](e), func(_ fx.Nil) V {
+		panic("BUG: unreachable after aborted effect")
 	})
 }
 
-func Handler[V, E any]() AbortHn[V, E] {
-	return func(eff fx.Fx[fx.And[AbortFn[V, E], fx.Nil], V]) fx.FxPure[Result[V, E]] {
-		var err Result[V, E]
-		handler := fx.Handler(func(e E) fx.FxPure[V] {
-			err = failure[V](e)
-			return fx.Halt[fx.Nil, V]()
-		})
-		succeeded := fx.Map(handler(eff), success[V, E])
-		failed := func() fx.FxPure[Result[V, E]] { return fx.Pure(err) }
-		return fx.Replace(failed)(succeeded)
-	}
+func Succeed[E, V any](v V) AbortFx[E, V] {
+	return fx.Const[AbortAb[E]](v)
 }

abort/abort_test.go

@@ -11,8 +11,7 @@ func TestSuccess(t *testing.T) {
 	type Err = string
 	value := 22
 	e := Succeed[Err](22)
-	h := Handler[Ok, Err]()
-	x := fx.ProvideLeft(fx.Handle[AbortHn[Ok, Err]](e), h)
+	x := fx.ProvideLeft(AbortResult(e), AbortHandler[Ok, Err])
 	var r Result[Ok, Err] = fx.Eval(x)
 	val, err := r()
 	if err != nil {
@@ -29,8 +28,7 @@ func TestFailure(t *testing.T) {
 	e := fx.Map(Abort[Ok]("ahhhh"), func(_ Ok) int {
 		panic("BUG: mapping on aborted eff should be unreachable")
 	})
-	h := Handler[Ok, Err]()
-	x := fx.ProvideLeft(fx.Handle[AbortHn[Ok, Err]](e), h)
+	x := fx.ProvideLeft(AbortResult(e), AbortHandler[Ok, Err])
 	var r Result[Ok, Err] = fx.Eval(x)
 	val, err := r()
 	if *err != "ahhhh" {

abort/result.go

@@ -0,0 +1,27 @@
+package abort
+
+import fx "github.com/vic/fx.go"
+
+type ResultFn[V, E any] func(AbortFx[E, V]) fx.FxPure[Result[V, E]]
+type ResultAb[V, E any] = fx.And[ResultFn[V, E], fx.Nil]
+type ResultFx[V, E any] = fx.Fx[ResultAb[V, E], Result[V, E]]
+
+type Result[V, E any] func() (*V, *E)
+
+func success[V, E any](v V) Result[V, E] { return func() (*V, *E) { return &v, nil } }
+func failure[V, E any](e E) Result[V, E] { return func() (*V, *E) { return nil, &e } }
+
+func AbortResult[V, E any](eff AbortFx[E, V]) ResultFx[V, E] {
+	return fx.Handle[ResultFn[V, E]](eff)
+}
+
+func AbortHandler[V, E any](e AbortFx[E, V]) fx.FxPure[Result[V, E]] {
+	var err Result[V, E]
+	var abortFn AbortFn[E] = func(e E) fx.FxNil {
+		err = failure[V](e)
+		return fx.Halt[fx.Nil, fx.Nil]()
+	}
+	succeeded := fx.Map(fx.ProvideLeft(e, abortFn), success[V, E])
+	failed := func() fx.FxPure[Result[V, E]] { return fx.Pure(err) }
+	return fx.Replace(failed)(succeeded)
+}

fx.go

@@ -236,20 +236,20 @@ 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 FlatMap(Ctx[A](), func(a A) Fx[B, O] { return a(i) })
+func Const[S, V any](v V) Fx[S, V] {
+	return Map(Ctx[S](), func(_ S) V { return v })
 }
 
-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[A ~func(I) Fx[B, O], B, I, O any](i I) Fx[And[A, B], O] {
+	return AndJoin(Apply[A](i))
 }
 
-func Handle[F ~func(Fx[A, U]) Fx[B, V], A, B, U, V any](e Fx[A, U]) Fx[And[F, B], V] {
-	return FlatMap(Ctx[F](), func(f F) Fx[B, V] { return f(e) })
+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 Request[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 Handle[F](Suspend[A](i))
+func Suspend[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 Handle[F](Handle[A](i))
 }
 
 func Eval[V any](e Fx[Nil, V]) V {

fx_test.go

@@ -1,6 +1,7 @@
 package fx
 
 import (
+	"strconv"
 	"testing"
 )
 
@@ -43,28 +44,21 @@ func TestApply(t *testing.T) {
 	}
 }
 
-type printRq = func(string) FxPure[int]
-type printHn = func(Fx[And[printRq, Nil], int]) Fx[Nil, int]
-type printAb = And[printHn, Nil]
-type printFx = Fx[printAb, int]
+type printFn = func(string) FxPure[int]
 
-func PrintLn(line string) printFx {
-	return Request[printHn](line)
+func PrintLn(line string) Fx[And[printFn, Nil], int] {
+	return Handle[printFn](line)
 }
 
-func dontPrintHandler() printHn {
-	return Handler(func(line string) FxPure[int] {
-		r := len(line)
-		return Pure(r)
-	})
+func printLn(line string) FxPure[int] {
+	return Pure(len(line))
 }
 
 func TestHandleSimple(t *testing.T) {
-	e := PrintLn("hello")
-	h := dontPrintHandler()
-	f := ProvideLeft(e, h)
-	v := Eval(f)
-	if v != len("hello") {
+	e := Map(PrintLn("hello"), strconv.Itoa)
+	f := ProvideLeft(e, printLn)
+	var v string = Eval(f)
+	if v != strconv.Itoa(len("hello")) {
 		t.Errorf("unexpected value %v", v)
 	}
 }

rw/read.go

@@ -4,18 +4,14 @@ import fx "github.com/vic/fx.go"
 
 type Reader[T any] func() *T
 
-type ReadFn[T any] = func(fx.Nil) fx.FxPure[*T]
-type ReadHn[T any] = func(fx.Fx[fx.And[ReadFn[T], fx.Nil], *T]) fx.FxPure[*T]
-type ReadAb[T any] = fx.And[ReadHn[T], fx.Nil]
+type ReadFn[T any] func(fx.Nil) fx.FxPure[*T]
+type ReadAb[T any] = fx.And[ReadFn[T], fx.Nil]
 type ReadFx[T, V any] = fx.Fx[ReadAb[T], V]
 
 func Read[T any]() ReadFx[T, *T] {
-	return fx.Request[ReadHn[T]](fx.PNil)
+	return fx.Handle[ReadFn[T]](fx.PNil)
 }
 
-func ReadHandler[T any](r Reader[T]) ReadHn[T] {
-	return fx.Handler(func(_ fx.Nil) fx.FxPure[*T] {
-		v := r()
-		return fx.Pure(v)
-	})
+func ReadService[T any](r Reader[T]) ReadFn[T] {
+	return func(_ fx.Nil) fx.FxPure[*T] { return fx.Pure(r()) }
 }

rw/rw_test.go

@@ -17,8 +17,8 @@ func TestReadWrite(t *testing.T) {
 	})
 
 	st := &S{"hello"}
-	rh := ReadHandler(func() *S { return st })
-	wh := WriteHandler(func(s *S) { st = s })
+	rh := ReadService(func() *S { return st })
+	wh := WriteService(func(s *S) { st = s })
 	x := fx.AndCollapse(fx.ProvideAB(e, rh, wh))
 	fx.Eval(x)
 

rw/write.go

@@ -6,18 +6,17 @@ import (
 
 type Writer[T any] func(*T)
 
-type WriteFn[T any] = func(*T) fx.FxNil
-type WriteHn[T any] = func(fx.Fx[fx.And[WriteFn[T], fx.Nil], fx.Nil]) fx.FxNil
-type WriteAb[T any] = fx.And[WriteHn[T], fx.Nil]
+type WriteFn[T any] func(*T) fx.FxNil
+type WriteAb[T any] = fx.And[WriteFn[T], fx.Nil]
 type WriteFx[T, V any] = fx.Fx[WriteAb[T], V]
 
 func Write[T any](v *T) WriteFx[T, fx.Nil] {
-	return fx.Request[WriteHn[T]](v)
+	return fx.Handle[WriteFn[T]](v)
 }
 
-func WriteHandler[T any](w Writer[T]) WriteHn[T] {
-	return fx.Handler(func(t *T) fx.FxNil {
+func WriteService[T any](w Writer[T]) WriteFn[T] {
+	return func(t *T) fx.FxNil {
 		w(t)
 		return fx.PureNil
-	})
+	}
 }