@typed/fx 1.27.3 → 1.28.0

package/src/internal/keyed.ts

@@ -1,6 +1,11 @@
-import type { FiberId } from "effect"
-import { Context, Effect, ExecutionStrategy, Exit, Option, Scope } from "effect"
-import type { Fx, KeyedOptions } from "../Fx.js"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
+import type * as FiberId from "effect/FiberId"
+import * as Option from "effect/Option"
+import * as Scope from "effect/Scope"
+import { type Fx, type KeyedOptions } from "../Fx.js"
 import * as RefSubject from "../RefSubject.js"
 import * as Sink from "../Sink.js"
 import type { Add, Moved, Remove, Update } from "./diff.js"
@@ -64,46 +69,47 @@ function runKeyed<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
       const scheduleNextEmit = forkDebounce(Effect.suspend(() => sink.onSuccess(getReadyIndices(state))))
 
       function diffAndPatch(values: ReadonlyArray<A>) {
-        return Effect.gen(function*(_) {
+        return Effect.gen(function*() {
           const previous = state.previousValues
           state.previousValues = values
 
           let added = false
-          let done = false
           let scheduled = false
+          let done = false
 
           for (const patch of diffIterator(previous, values, options)) {
             if (patch._tag === "Remove") {
-              yield* _(removeValue(state, patch))
+              yield* removeValue(state, patch)
             } else if (patch._tag === "Add") {
               added = true
-              yield* _(
-                addValue(
-                  state,
-                  values,
-                  patch,
-                  id,
-                  parentScope,
-                  options,
-                  sink,
-                  Effect.suspend(() => {
-                    if (done === false) {
-                      scheduled = true
-                      return Effect.unit
-                    }
-                    return scheduleNextEmit
-                  })
-                )
+              yield* addValue(
+                state,
+                values,
+                patch,
+                id,
+                parentScope,
+                options,
+                sink,
+                Effect.suspend(() => {
+                  if (done === false) {
+                    scheduled = true
+                    return Effect.void
+                  }
+                  return scheduleNextEmit
+                })
               )
             } else {
-              yield* _(updateValue(state, values, patch))
+              yield* updateValue(state, values, patch)
             }
           }
 
           done = true
 
           if (scheduled || added === false) {
-            yield* _(scheduleNextEmit)
+            yield* scheduleNextEmit
+          } else {
+            // Allow fibers to begin running if we're adding Fibers
+            yield* Effect.sleep(1)
           }
         })
       }
@@ -117,7 +123,7 @@ function runKeyed<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
         )
       )
     },
-    options.debounce || 0
+    options.debounce || 1
   )
 }
 
@@ -162,16 +168,17 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
   sink: Sink.Sink<ReadonlyArray<C>, E | E2, R2 | R3>,
   scheduleNextEmit: Effect.Effect<D, never, R3>
 ) {
-  return Effect.gen(function*(_) {
+  return Effect.gen(function*() {
     const value = values[patch.index]
-    const childScope = yield* _(Scope.fork(parentScope, ExecutionStrategy.sequential))
-    const ref: RefSubject.RefSubject<A> = yield* _(RefSubject.unsafeMake<never, A>({
+    const childScope = yield* Scope.fork(parentScope, ExecutionStrategy.sequential)
+    const ref: RefSubject.RefSubject<A> = yield* RefSubject.unsafeMake<never, A>({
       initial: Effect.sync(() => entry.value),
       initialValue: value,
       scope: childScope,
       id
-    }))
-    yield* _(Scope.addFinalizer(childScope, ref.interrupt))
+    })
+
+    yield* Scope.addFinalizer(childScope, ref.interrupt)
 
     const entry = new KeyedEntry<A, C>(
       value,
@@ -184,18 +191,16 @@ function addValue<A, B extends PropertyKey, C, R2, E2, E, R3, D>(
     entries.set(patch.key, entry)
     indices.set(patch.index, patch.key)
 
-    yield* _(
-      Effect.forkIn(
-        options.onValue(ref, patch.key).run(Sink.make(
-          (cause) => sink.onFailure(cause),
-          (output) => {
-            entry.output = Option.some(output)
+    yield* Effect.forkIn(
+      options.onValue(ref, patch.key).run(Sink.make(
+        (cause) => sink.onFailure(cause),
+        (output) => {
+          entry.output = Option.some(output)
 
-            return scheduleNextEmit
-          }
-        )),
-        parentScope
-      )
+          return scheduleNextEmit
+        }
+      )),
+      parentScope
     )
   })
 }

package/src/internal/loop-operator.ts

@@ -1,4 +1,4 @@
-import type { Either } from "effect"
+import type * as Either from "effect/Either"
 import * as Option from "effect/Option"
 import * as Sink from "../Sink.js"
 import type { Bounds } from "./bounds.js"

package/src/internal/protos.ts

@@ -1,4 +1,4 @@
-import type { Effect } from "effect"
+import type * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { identity } from "effect/Function"
 import { pipeArguments } from "effect/Pipeable"

package/src/internal/share.ts

@@ -1,13 +1,12 @@
-import { ExecutionStrategy, type Scope } from "effect"
 import * as Effect from "effect/Effect"
 import * as Fiber from "effect/Fiber"
 import { dual } from "effect/Function"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
 import type { Fx } from "../Fx.js"
 import type { Sink } from "../Sink.js"
 import * as Subject from "../Subject.js"
-import { withScopedFork } from "./helpers.js"
 import { FxBase } from "./protos.js"
 
 export function share<A, E, R, R2>(
@@ -41,23 +40,17 @@ export class Share<A, E, R, R2> extends FxBase<A, E, R | R2 | Scope.Scope> {
   }
 
   run<R3>(sink: Sink<A, E, R3>): Effect.Effect<unknown, never, R | R2 | R3 | Scope.Scope> {
-    return withScopedFork(
-      (fork) =>
-        Effect.flatMap(
-          fork(
-            Effect.onExit(this.i1.run(sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
-          ),
-          () => this.initialize()
-        ),
-      ExecutionStrategy.sequential
+    return Effect.zipRight(
+      this.initialize(),
+      Effect.onExit(this.i1.run(sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.void)
     )
   }
 
   private initialize(): Effect.Effect<unknown, never, R | R2> {
-    return Effect.suspend(() => {
+    return Effect.suspend((): Effect.Effect<unknown, never, R | R2> => {
       if (this._RefCount.increment() === 1) {
         return this.i0.run(this.i1).pipe(
-          Effect.onExit(() =>
+          Effect.ensuring(
             Effect.suspend(() => {
               MutableRef.set(this._FxFiber, Option.none())
               return this.i1.interrupt
@@ -65,26 +58,18 @@ export class Share<A, E, R, R2> extends FxBase<A, E, R | R2 | Scope.Scope> {
           ),
           Effect.interruptible,
           Effect.forkDaemon,
-          Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this._FxFiber, Option.some(fiber)))),
-          Effect.flatMap(Fiber.join)
+          Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this._FxFiber, Option.some(fiber))))
         )
       } else {
-        return Option.match(
-          MutableRef.get(this._FxFiber),
-          {
-            onNone: () => Effect.unit,
-            onSome: Fiber.join
-          }
-        )
+        return Effect.void
       }
     })
   }
 
   private interrupt(): Effect.Effect<void, never, R | R2> {
-    return Effect.suspend(() => {
-      const fiber = Option.getOrNull(MutableRef.getAndSet(this._FxFiber, Option.none()))
-
-      return fiber ? Effect.zip(Fiber.interrupt(fiber), this.i1.interrupt) : this.i1.interrupt
+    return Option.match(MutableRef.getAndSet(this._FxFiber, Option.none()), {
+      onNone: () => Effect.void,
+      onSome: Fiber.interrupt
     })
   }
 }

package/src/internal/sync-operator.ts

@@ -1,4 +1,4 @@
-import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as ReadonlyArray from "effect/Array"
 
 import * as Effect from "effect/Effect"
 import { flow } from "effect/Function"
@@ -95,11 +95,11 @@ export function compileCauseSyncOperatorSink<R>(
 ): Sink.Sink<any, any, R> {
   return matchSyncOperator(operator, {
     Map: (op) => Sink.make((a) => sink.onFailure(op.f(a)), sink.onSuccess),
-    Filter: (op) => Sink.make((a) => op.f(a) ? sink.onFailure(a) : Effect.unit, sink.onSuccess),
+    Filter: (op) => Sink.make((a) => op.f(a) ? sink.onFailure(a) : Effect.void, sink.onSuccess),
     FilterMap: (op) =>
       Sink.make((a) =>
         Option.match(op.f(a), {
-          onNone: () => Effect.unit,
+          onNone: () => Effect.void,
           onSome: sink.onFailure
         }), sink.onSuccess)
   })

package/src/internal/sync-producer.ts

@@ -1,4 +1,6 @@
-import { Effect, Option, ReadonlyArray } from "effect"
+import * as Array from "effect/Array"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
 import type { Sink } from "../Sink.js"
 
 const DISCARD = { discard: true } as const
@@ -65,8 +67,8 @@ export function runReduce<A, B>(
   return matchSyncProducer(producer, {
     Success: (a) => syncOnce(() => f(initial, a)),
     FromSync: (a) => syncOnce(() => f(initial, a())),
-    FromArray: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f)),
-    FromIterable: (a) => syncOnce(() => ReadonlyArray.reduce(a, initial, f))
+    FromArray: (a) => syncOnce(() => Array.reduce(a, initial, f)),
+    FromIterable: (a) => syncOnce(() => Array.reduce(a, initial, f))
   })
 }
 
@@ -84,7 +86,7 @@ export function runReduceEffect<A, B, E2, R2>(
 }
 
 function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<A, never, R2>): Effect.Effect<unknown, never, R2> {
-  if (array.length === 0) return Effect.unit
+  if (array.length === 0) return Effect.void
   else if (array.length === 1) return sink.onSuccess(array[0])
   else {
     const [first, ...rest] = array
@@ -97,7 +99,7 @@ function arrayToSink<A, R2>(array: ReadonlyArray<A>, sink: Sink<A, never, R2>):
 }
 
 function iterableToSink<A, R2>(array: Iterable<A>, sink: Sink<A, never, R2>): Effect.Effect<unknown, never, R2> {
-  let effect: Effect.Effect<any, never, R2> = Effect.unit
+  let effect: Effect.Effect<any, never, R2> = Effect.void
 
   for (const item of array) {
     effect = Effect.zipRight(effect, sink.onSuccess(item))

package/src/internal/withKey.ts

@@ -37,7 +37,7 @@ function runWithKey<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
     const run = fx.run(Sink.make(
       (cause) => sink.onFailure(cause),
       (value) =>
-        Effect.gen(function*(_) {
+        Effect.gen(function*() {
           const key = options.getKey(value)
 
           // We don't need to do anything if the key is the same as the previous one
@@ -47,15 +47,15 @@ function runWithKey<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
             // If the key is the same, we just need to update the value
             if (prev.key === key) {
               prev.value = value
-              yield* _(RefSubject.set(prev.ref, value))
+              yield* RefSubject.set(prev.ref, value)
               return
             } else {
               // Otherwise, we need to remove the previous value
-              yield* _(prev.ref.interrupt)
+              yield* prev.ref.interrupt
             }
           }
 
-          const ref = yield* _(RefSubject.fromEffect(Effect.sync(() => state.value)))
+          const ref = yield* RefSubject.fromEffect(Effect.sync(() => state.value))
 
           // Create a new state
           const state: WithKeyState<A, B> = {
@@ -67,11 +67,11 @@ function runWithKey<A, E, R, B extends PropertyKey, C, E2, R2, R3>(
           previous = Option.some(state)
 
           // Create a new listener
-          yield* _(fork(options.onValue(state.ref, state.key).run(sink)))
+          yield* fork(options.onValue(state.ref, state.key).run(sink))
         })
     ))
 
-    return Effect.flatMap(run, () => Option.isSome(previous) ? previous.value.ref.interrupt : Effect.unit)
+    return Effect.flatMap(run, () => Option.isSome(previous) ? previous.value.ref.interrupt : Effect.void)
   }, ExecutionStrategy.sequential)
 }