Working mutation

packages/effect-fc/src/Mutation.ts

@@ -17,7 +17,7 @@ extends Pipeable.Pipeable {
     readonly fiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, E>>>
     readonly result: Subscribable.Subscribable<Result.Result<A, E, P>>
 
-    mutate(key: K): Effect.Effect<Result.Result<A, E, P>>
+    mutate(key: K): Effect.Effect<Result.Final<A, E, P>>
     mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>>
 }
 
@@ -37,13 +37,12 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
         super()
     }
 
-    mutate(key: K): Effect.Effect<Result.Result<A, E, P>> {
+    mutate(key: K): Effect.Effect<Result.Final<A, E, P>> {
         return SubscriptionRef.set(this.latestKey, Option.some(key)).pipe(
             Effect.andThen(Effect.provide(this.start(key), this.context)),
             Effect.andThen(sub => this.watch(sub)),
         )
     }
-
     mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>> {
         return Effect.andThen(
             SubscriptionRef.set(this.latestKey, Option.some(key)),
@@ -57,7 +56,7 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
         Scope.Scope | R
     > {
         return this.result.pipe(
-            Effect.map(previous => (Result.isSuccess(previous) || Result.isFailure(previous))
+            Effect.map(previous => Result.isFinal(previous)
                 ? previous
                 : undefined
             ),
@@ -84,7 +83,7 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
 
     watch(
         sub: Subscribable.Subscribable<Result.Result<A, E, P>>
-    ): Effect.Effect<Result.Result<A, E, P>> {
+    ): Effect.Effect<Result.Final<A, E, P>> {
         return Effect.andThen(
             sub.get,
             initial => Stream.runFoldEffect(
@@ -92,20 +91,20 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
                 initial,
                 (_, result) => Effect.as(SubscriptionRef.set(this.result, result), result),
             ),
-        )
+        ) as Effect.Effect<Result.Final<A, E, P>>
     }
 }
 
 export const isMutation = (u: unknown): u is Mutation<unknown[], unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, MutationTypeId)
 
 export declare namespace make {
-    export interface Options<K extends readonly any[], A, E = never, R = never, P = never> {
-        readonly f: (key: NoInfer<K>) => Effect.Effect<A, E, Result.forkEffect.InputContext<R, NoInfer<P>>>
+    export interface Options<K extends readonly any[] = never, A = void, E = never, R = never, P = never> {
+        readonly f: (key: K) => Effect.Effect<A, E, Result.forkEffect.InputContext<R, NoInfer<P>>>
         readonly initialProgress?: P
     }
 }
 
-export const make = Effect.fnUntraced(function* <K extends readonly any[], A, E = never, R = never, P = never>(
+export const make = Effect.fnUntraced(function* <const K extends readonly any[] = never, A = void, E = never, R = never, P = never>(
     options: make.Options<K, A, E, R, P>
 ): Effect.fn.Return<
     Mutation<K, A, E, Result.forkEffect.OutputContext<A, E, R, P>, P>,