@typed/fx 1.27.4 → 1.28.0

package/src/internal/effect-operator.ts

@@ -221,7 +221,7 @@ export function compileCauseEffectOperatorSink<R>(
             op.f(a),
             Sink.make(
               (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
-              (b) => b ? sink.onFailure(a) : Effect.unit
+              (b) => b ? sink.onFailure(a) : Effect.void
             )
           ),
         sink.onSuccess
@@ -234,7 +234,7 @@ export function compileCauseEffectOperatorSink<R>(
             Sink.make(
               (cause2) => sink.onFailure(Cause.sequential(a, cause2)),
               Option.match({
-                onNone: () => Effect.unit,
+                onNone: () => Effect.void,
                 onSome: sink.onFailure
               })
             )

package/src/internal/effect-producer.ts

@@ -1,4 +1,4 @@
-import type { Cause } from "effect"
+import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
 import type * as Sink from "../Sink.js"
@@ -94,7 +94,7 @@ export function runEffect<A, E, R, B, E2, R2>(
           Effect.asyncEffect((resume) => {
             const onFailure = (cause: Cause.Cause<E | E2>) => Effect.succeed(resume(Effect.failCause(cause)))
 
-            return Effect.asUnit(Effect.matchCauseEffect(
+            return Effect.asVoid(Effect.matchCauseEffect(
               Effect.scheduleFrom(
                 producer.input,
                 i,
@@ -103,7 +103,7 @@ export function runEffect<A, E, R, B, E2, R2>(
                   (a) => Effect.catchAllCause(f(a), onFailure)
                 )
               ),
-              { onFailure, onSuccess: () => Effect.succeed(resume(Effect.unit)) }
+              { onFailure, onSuccess: () => Effect.succeed(resume(Effect.void)) }
             ))
           })
       )

package/src/internal/helpers.ts

@@ -1,65 +1,112 @@
 import { getOption } from "@typed/context"
-import { Equivalence, Unify } from "effect"
-import type { Duration, Exit } from "effect"
 import * as Cause from "effect/Cause"
+import * as Deferred from "effect/Deferred"
+import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import * as Equal from "effect/Equal"
+import * as Equivalence from "effect/Equivalence"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
+import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
 import * as FiberSet from "effect/FiberSet"
 import * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
 import * as Scope from "effect/Scope"
 import * as SynchronizedRef from "effect/SynchronizedRef"
 import * as TestClock from "effect/TestClock"
+import * as Unify from "effect/Unify"
 import type { FlattenStrategy, FxFork, ScopedFork } from "../Fx.js"
 import type * as Sink from "../Sink.js"
 
-export function withBuffers<A, E, R>(size: number, sink: Sink.Sink<A, E, R>) {
-  const buffers: Array<Array<A>> = Array.from({ length: size }, () => [])
-  const finished = new Set<number>()
-  let currentIndex = 0
-
-  const drainBuffer = (index: number): Effect.Effect<void, never, R> => {
-    const effect = Effect.forEach(buffers[index], sink.onSuccess)
-    buffers[index] = []
-
-    return Effect.flatMap(effect, () => finished.has(index) ? onEnd(index) : Effect.unit)
-  }
-
-  const onSuccess = (index: number, value: A) => {
-    if (index === currentIndex) {
-      const buffer = buffers[index]
+export function withBuffers<A, E, R>(
+  size: number,
+  sink: Sink.Sink<A, E, R>,
+  id: FiberId.FiberId
+) {
+  const buffers = indexedBuffers(size, sink, id)
+  const onSuccess = (index: number, value: A) => buffers.get(index)!.onSuccess(value)
+  const onEnd = (index: number) => buffers.get(index)!.onEnd
 
-      if (buffer.length === 0) {
-        return sink.onSuccess(value)
-      } else {
-        buffer.push(value)
+  return {
+    onSuccess: (i: number, a: A) => onSuccess(i, a),
+    onEnd: (i: number) => onEnd(i)
+  } as const
+}
 
-        return drainBuffer(index)
-      }
-    } else {
-      buffers[index].push(value)
+function indexedBuffers<A, E, R>(
+  size: number,
+  sink: Sink.Sink<A, E, R>,
+  id: FiberId.FiberId
+) {
+  const buffers = new Map<number, ReturnType<typeof IndexedBuffer<A, E, R>>>()
+
+  const last = size - 1
+  for (let i = 0; i < size; i++) {
+    const deferred = Deferred.unsafeMake<void>(id)
+    const state = {
+      ready: i === 0,
+      deferred
+    }
 
-      return Effect.unit
+    // First should start immediately
+    if (i === 0) {
+      Deferred.unsafeDone(deferred, Exit.void)
     }
+
+    buffers.set(
+      i,
+      IndexedBuffer(
+        state,
+        sink,
+        i === last ? Effect.void : Effect.suspend(() => {
+          const next = buffers.get(i + 1)!
+          next.state.ready = true
+          return Deferred.done(next.state.deferred, Exit.void)
+        })
+      )
+    )
   }
 
-  const onEnd = (index: number) => {
-    finished.add(index)
+  return buffers
+}
 
-    if (index === currentIndex && ++currentIndex < size) {
-      return drainBuffer(currentIndex)
+function IndexedBuffer<A, E, R>(
+  state: {
+    ready: boolean
+    deferred: Deferred.Deferred<void>
+  },
+  sink: Sink.Sink<A, E, R>,
+  onDone: Effect.Effect<void>
+) {
+  let buffer: Array<A> = []
+
+  const onSuccess = (value: A) => {
+    if (state.ready) {
+      if (buffer.length === 0) return sink.onSuccess(value)
+      buffer.push(value)
+      const effect = Effect.forEach(buffer, sink.onSuccess)
+      buffer = []
+      return effect
     } else {
-      return Effect.unit
+      buffer.push(value)
+      return Effect.void
     }
   }
 
+  const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
+    if (buffer.length === 0) return onDone
+    const effect = Effect.forEach(buffer, sink.onSuccess)
+    buffer = []
+    return Effect.zipRight(effect, onDone)
+  })
+
   return {
+    state,
     onSuccess,
     onEnd
-  } as const
+  }
 }
 
 export const withScope = <A, E, R>(
@@ -112,7 +159,7 @@ export function withSwitchFork<A, E, R>(
   return withScopedFork(
     (fork, scope) =>
       Effect.flatMap(
-        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.unit),
+        SynchronizedRef.make<Fiber.Fiber<unknown>>(Fiber.void),
         (ref) => runSwitchFork(ref, fork, scope, f)
       ),
     executionStrategy
@@ -164,7 +211,7 @@ export function withExhaustFork<A, E, R>(
                     )
                   )
             ), scope),
-          () => Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+          () => Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.void)
         )
     )
   }, executionStrategy)
@@ -184,7 +231,7 @@ export function withExhaustLatestFork<A, E, R>(
         const reset = Ref.set(ref, undefined)
 
         // Wait for the current fiber to finish
-        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.unit)
+        const awaitNext = Effect.flatMap(Ref.get(ref), (fiber) => fiber ? Fiber.join(fiber) : Effect.void)
 
         // Run the next value that's be saved for replay if it exists
 
@@ -192,7 +239,7 @@ export function withExhaustLatestFork<A, E, R>(
           Ref.get(nextEffect),
           (next) => {
             if (Option.isNone(next)) {
-              return Effect.unit
+              return Effect.void
             }
 
             return Effect.all([
@@ -263,7 +310,7 @@ export function withBoundedFork(capacity: number) {
                   )
                 )
               ), scope),
-            () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.unit)
+            () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers) : Effect.void)
           )
       ), executionStrategy)
   }
@@ -355,7 +402,7 @@ export function tupleSink<A extends ReadonlyArray<any>, E, R, B, E2, R2>(
       if (values.size === expected) {
         return sink.onSuccess(getValues())
       } else {
-        return Effect.unit
+        return Effect.void
       }
     })
   })
@@ -385,7 +432,7 @@ export function withDebounceFork<A, E, R>(
             ),
             () =>
               SynchronizedRef.get(ref).pipe(Effect.flatMap(Option.match({
-                onNone: () => Effect.unit,
+                onNone: () => Effect.void,
                 onSome: Fiber.join
               })))
           )
@@ -422,7 +469,7 @@ export class RingBuffer<A> {
   ) {
     switch (this._size) {
       case 0:
-        return Effect.unit
+        return Effect.void
       case 1:
         return f(this._buffer[0], 0)
       case 2:
@@ -451,7 +498,7 @@ export class RingBuffer<A> {
 
 export function awaitScopeClose(scope: Scope.Scope) {
   return Effect.asyncEffect<unknown, never, never, never, never, never>((cb) =>
-    Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.unit)))
+    Scope.addFinalizerExit(scope, () => Effect.sync(() => cb(Effect.void)))
   )
 }
 
@@ -484,7 +531,7 @@ export class MulticastEffect<A, E, R> extends Effectable.Class<A, E, R> {
       if (this._fiber) {
         return Fiber.interruptFork(this._fiber)
       } else {
-        return Effect.unit
+        return Effect.void
       }
     })
   }

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)
 }