@typed/fx 1.27.3 → 1.28.0

package/src/Fx.ts

@@ -4,35 +4,33 @@
  */
 
 import type * as Ctx from "@typed/context"
-import type {
-  ConfigProvider,
-  Duration,
-  Equivalence,
-  ExecutionStrategy,
-  Exit,
-  Fiber,
-  FiberId,
-  FiberRef,
-  HashSet,
-  Pipeable,
-  Predicate,
-  PubSub,
-  Request,
-  Runtime,
-  Scope,
-  Tracer
-} from "effect"
 import * as Cause from "effect/Cause"
-import type { DurationInput } from "effect/Duration"
+import type * as ConfigProvider from "effect/ConfigProvider"
+import type * as Duration from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
+import type * as Equivalence from "effect/Equivalence"
+import type * as ExecutionStrategy from "effect/ExecutionStrategy"
+import type * as Exit from "effect/Exit"
+import type * as Fiber from "effect/Fiber"
+import type * as FiberId from "effect/FiberId"
+import type * as FiberRef from "effect/FiberRef"
 import { dual, identity } from "effect/Function"
+import type * as HashSet from "effect/HashSet"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
+import type * as Pipeable from "effect/Pipeable"
+import type * as Predicate from "effect/Predicate"
 import { hasProperty } from "effect/Predicate"
+import type * as PubSub from "effect/PubSub"
 import * as Queue from "effect/Queue"
+import type * as Request from "effect/Request"
+import type * as Runtime from "effect/Runtime"
 import * as Schedule from "effect/Schedule"
+import type * as Scope from "effect/Scope"
+import type * as Tracer from "effect/Tracer"
 import type * as Types from "effect/Types"
+import type * as Utils from "effect/Utils"
 import * as Emitter from "./Emitter.js"
 import * as core from "./internal/core.js"
 import * as coreKeyed from "./internal/keyed.js"
@@ -89,7 +87,7 @@ export namespace Fx {
   /**
    * @since 1.20.0
    */
-  export type Unify<T> = [T] extends [Fx<infer A, infer E, infer R> | infer _] ? Fx<A, E, R> : never
+  export type Unify<T> = [T] extends [Fx<infer A, infer E, infer R>] ? Fx<A, E, R> : never
 }
 
 /**
@@ -1037,11 +1035,11 @@ export const middleware: {
 export const onExit: {
   <R2>(
     f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>
-  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R2>
+  ): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | R2>
 
   <A, E, R, R2>(
     fx: Fx<A, E, R>,
-    f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R2>
+    f: (exit: Exit.Exit<unknown>) => Effect.Effect<unknown, never, R | R2>
   ): Fx<A, E, R | R2>
 } = dual(2, core.onExit)
 
@@ -1227,7 +1225,7 @@ export const withSpan: {
     readonly root?: boolean
     readonly context?: Ctx.Context<never>
   }): Fx<A, E, R>
-} = dual(3, core.withSpan)
+} = dual((args) => isFx(args[0]), core.withSpan)
 
 /**
  * @since 1.20.0
@@ -2246,7 +2244,12 @@ export const at: {
 export function drainLayer<FXS extends ReadonlyArray<Fx<any, never, any>>>(
   ...fxs: FXS
 ): Layer.Layer<never, never, Exclude<Fx.Context<FXS[number]>, Scope.Scope>> {
-  return Layer.scopedDiscard(Effect.forkWithErrorHandler(core.drain(core.mergeAll(fxs)), Effect.logError))
+  return Layer.scopedDiscard(
+    Effect.forkWithErrorHandler(
+      core.drain(core.mergeAll(fxs)),
+      (e) => Effect.logError(`Error originating from Fx.drainLayer`, Cause.fail(e))
+    )
+  )
 }
 
 /**
@@ -2310,23 +2313,24 @@ export const partitionMap: {
 /**
  * @since 1.20.0
  */
-export const gen: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+export const gen: <Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ) => Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Effect.Effect.Context<Y["value"]> | Fx.Context<FX>
+  (Y extends Utils.YieldWrap<Effect.Effect<infer _, infer E, any>> ? E : never) | Fx.Error<FX>,
+  (Y extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never) | Fx.Context<FX>
 > = core.gen
 
 /**
  * @since 1.20.0
  */
-export const genScoped: <Y extends Effect.EffectGen<any, any, any>, FX extends Fx<any, any, any>>(
+export const genScoped: <Y extends Utils.YieldWrap<Effect.Effect<any, any, any>>, FX extends Fx<any, any, any>>(
   f: (_: Effect.Adapter) => Generator<Y, FX, any>
 ) => Fx<
   Fx.Success<FX>,
-  Effect.Effect.Error<Y["value"]> | Fx.Error<FX>,
-  Exclude<Effect.Effect.Context<Y["value"]> | Fx.Context<FX>, Scope.Scope>
+  (Y extends Utils.YieldWrap<Effect.Effect<infer _, infer E, any>> ? E : never) | Fx.Error<FX>,
+  | Exclude<Y extends Utils.YieldWrap<Effect.Effect<any, any, infer R>> ? R : never, Scope.Scope>
+  | Exclude<Fx.Context<FX>, Scope.Scope>
 > = core.genScoped
 
 /**
@@ -2448,9 +2452,9 @@ export const withEmitter = <A, E = never, E2 = never, R = never>(
  * @since 1.18.0
  */
 export const delay: {
-  (delay: DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>
-  <A, E, R>(fx: Fx<A, E, R>, delay: DurationInput): Fx<A, E, R | Scope.Scope>
-} = dual(2, function<A, E, R>(fx: Fx<A, E, R>, delay: DurationInput): Fx<A, E, R | Scope.Scope> {
+  (delay: Duration.DurationInput): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>
+  <A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope>
+} = dual(2, function<A, E, R>(fx: Fx<A, E, R>, delay: Duration.DurationInput): Fx<A, E, R | Scope.Scope> {
   return core.flatMap(fx, (a) => core.fromEffect(Effect.delay(Effect.succeed(a), delay)))
 })
 
@@ -2500,9 +2504,9 @@ export function fromDequeue<A>(dequeue: Queue.Dequeue<A>): Fx<A>
 export function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A>): Fx<A, never, I>
 export function fromDequeue<I, A>(dequeue: Ctx.Dequeue<I, A> | Queue.Dequeue<A>): Fx<A, never, I> {
   return core.make((sink) =>
-    Effect.gen(function*(_) {
-      while (yield* _(dequeueIsActive(dequeue))) {
-        yield* _(dequeue.take, Effect.matchCauseEffect(sink))
+    Effect.gen(function*() {
+      while (yield* dequeueIsActive(dequeue)) {
+        yield* Effect.matchCauseEffect(dequeue.take, sink)
       }
     })
   )
@@ -2571,3 +2575,17 @@ export function promise<A>(f: (signal: AbortSignal) => Promise<A>) {
 export function promiseFx<A, E = never, R = never>(f: (signal: AbortSignal) => Promise<Fx<A, E, R>>) {
   return fromFxEffect(Effect.promise(f))
 }
+
+const void_ = succeed<void>(undefined)
+const null_ = succeed<null>(null)
+
+export {
+  /**
+   * @since 2.0.0
+   */
+  null_ as null,
+  /**
+   * @since 2.0.0
+   */
+  void_ as void
+}

package/src/Idle.ts

@@ -159,12 +159,12 @@ export interface WhileIdleRequestOptions<R, E, R2, E2> extends IdleRequestOption
 export const whileIdle = <R, E, R2, E2>(
   options: WhileIdleRequestOptions<R, E, R2, E2>
 ): Effect.Effect<void, E | E2, Scope.Scope | R | R2> =>
-  Effect.gen(function*(_) {
-    while (yield* _(options.while)) {
-      const deadline = yield* _(whenIdle(options))
+  Effect.gen(function*() {
+    while (yield* options.while) {
+      const deadline = yield* whenIdle(options)
 
       while (shouldContinue(deadline)) {
-        yield* _(options.body)
+        yield* options.body
       }
     }
   })
@@ -246,12 +246,12 @@ class IdleQueueImpl<I> implements IdleQueue<I> {
             else {
               const [part, task] = result.value
               this.queue.delete(part)
-              yield* _(task)
+              yield* task
             }
           }
 
           if (this.queue.size > 0) {
-            yield* _(run)
+            yield* run
           } else {
             this.scheduled = false
           }
@@ -260,7 +260,7 @@ class IdleQueueImpl<I> implements IdleQueue<I> {
 
     this.scheduleNextRun = Effect.provideService(
       Effect.suspend(() => {
-        if (this.queue.size === 0) return Effect.unit
+        if (this.queue.size === 0) return Effect.void
 
         this.scheduled = true
 

package/src/Match.ts

@@ -3,6 +3,7 @@
  */
 
 import { getGuard, type GuardInput } from "@typed/guard"
+import { isNonEmptyReadonlyArray, reduce } from "effect/Array"
 import * as Cause from "effect/Cause"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
@@ -12,7 +13,6 @@ import * as Fiber from "effect/Fiber"
 import { identity } from "effect/Function"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
-import { isNonEmptyReadonlyArray, reduce } from "effect/ReadonlyArray"
 import * as Scope from "effect/Scope"
 import * as Fx from "./Fx.js"
 import { withScopedFork } from "./internal/helpers.js"
@@ -166,17 +166,17 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
             when: When<R | R2 | Scope.Scope, E | E2, I, A, O>,
             value: A
           ) =>
-            Effect.gen(function*(_) {
+            Effect.gen(function*() {
               if (previous?.when === when) {
-                yield* _(RefSubject.set(previous.ref, value))
+                yield* RefSubject.set(previous.ref, value)
               } else {
                 // Interrupt any previous resources
                 if (previous !== undefined) {
-                  yield* _(previous.interrupt)
+                  yield* previous.interrupt
                 }
 
                 // RefSubject to pass along to our matching function
-                const refSubject = yield* _(RefSubject.of(value))
+                const refSubject = yield* RefSubject.of(value)
 
                 // Track if the case is ended
                 const hasEnded = MutableRef.make(false)
@@ -184,19 +184,17 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
                 const endSignal = Subject.unsafeMake<void>(0)
 
                 // Run the case
-                const fiber = yield* _(
-                  fork(
-                    Fx.mergeFirst(when.onMatch(refSubject), Fx.tap(endSignal, () => MutableRef.set(hasEnded, true)))
-                      .run(
-                        Sink.make(
-                          (cause) =>
-                            MutableRef.get(hasEnded) || Cause.isInterruptedOnly(cause)
-                              ? Effect.unit
-                              : sink.onFailure(cause),
-                          (value) => MutableRef.get(hasEnded) ? Effect.unit : sink.onSuccess(Option.some(value))
-                        )
+                const fiber = yield* fork(
+                  Fx.mergeFirst(when.onMatch(refSubject), Fx.tap(endSignal, () => MutableRef.set(hasEnded, true)))
+                    .run(
+                      Sink.make(
+                        (cause) =>
+                          MutableRef.get(hasEnded) || Cause.isInterruptedOnly(cause)
+                            ? Effect.void
+                            : sink.onFailure(cause),
+                        (value) => MutableRef.get(hasEnded) ? Effect.void : sink.onSuccess(Option.some(value))
                       )
-                  )
+                    )
                 )
 
                 previous = new Matched(
@@ -211,11 +209,11 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
             }).pipe(Effect.provideService(Scope.Scope, parentScope))
 
           function matchWhen<A>(input: I, when: When<R | R2 | Scope.Scope, E | E2, I, A, O>) {
-            return Effect.gen(function*(_) {
-              const matched = yield* _(when.guard(input))
+            return Effect.gen(function*() {
+              const matched = yield* when.guard(input)
 
               if (Option.isSome(matched)) {
-                yield* _(onMatch(when, matched.value))
+                yield* onMatch(when, matched.value)
 
                 return true
               } else {
@@ -225,14 +223,14 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
           }
 
           function matchInput(input: I) {
-            return Effect.gen(function*(_) {
+            return Effect.gen(function*() {
               // Allow failures to be accumulated, such that errors do not break the overall match
               // and additional matchers can be attempted against first
               const causes: Array<Cause.Cause<E | E2>> = []
 
               // If there's a previous match, attempt it first to avoid re-testing all cases in order
               if (previous !== undefined) {
-                const matchedExit = yield* _(matchWhen(input, previous.when), Effect.exit)
+                const matchedExit = yield* Effect.exit(matchWhen(input, previous.when))
 
                 if (Exit.isFailure(matchedExit)) {
                   causes.push(matchedExit.cause)
@@ -245,7 +243,7 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
                 // Don't test this case twice
                 if (when === previous?.when) continue
 
-                const matchedExit = yield* _(matchWhen(input, when), Effect.exit)
+                const matchedExit = yield* Effect.exit(matchWhen(input, when))
 
                 if (Exit.isFailure(matchedExit)) {
                   causes.push(matchedExit.cause)
@@ -256,13 +254,13 @@ class TypeMatcherImpl<I, O, E, R> implements TypeMatcher<I, O, E, R> {
 
               if (isNonEmptyReadonlyArray(causes)) {
                 const [first, ...rest] = causes
-                yield* _(sink.onFailure(reduce(rest, first, Cause.sequential)))
+                yield* sink.onFailure(reduce(rest, first, Cause.sequential))
               } else {
                 if (previous !== undefined) {
-                  yield* _(previous.interrupt)
+                  yield* previous.interrupt
                 }
 
-                yield* _(sink.onSuccess(Option.none()))
+                yield* sink.onSuccess(Option.none())
               }
             })
           }

package/src/Pull.ts

@@ -32,7 +32,7 @@ function schedulePull<A, E, R, R2, R3>(
         Cause.failureOrCause(cause).pipe(
           Either.match({
             onLeft: Option.match({
-              onNone: () => Effect.sync(() => resume(Effect.unit)),
+              onNone: () => Effect.sync(() => resume(Effect.void)),
               onSome: (e: E) => sink.onFailure(Cause.fail(e))
             }),
             onRight: sink.onFailure
@@ -41,7 +41,7 @@ function schedulePull<A, E, R, R2, R3>(
       onSuccess: (chunk: Chunk.Chunk<A>) => Effect.forEach(chunk, sink.onSuccess, { discard: true })
     }).pipe(
       f,
-      Effect.flatMap(() => Effect.sync(() => resume(Effect.unit)))
+      Effect.flatMap(() => Effect.sync(() => resume(Effect.void)))
     )
   )
 }

package/src/Push.ts

@@ -3,10 +3,13 @@
  * @since 1.20.0
  */
 
-import type { Effect, Option, Pipeable, Scope } from "effect"
 import type { Cause } from "effect/Cause"
+import type * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
+import type * as Option from "effect/Option"
+import type * as Pipeable from "effect/Pipeable"
 import { pipeArguments } from "effect/Pipeable"
+import type * as Scope from "effect/Scope"
 import type { Fx } from "./Fx.js"
 import * as core from "./internal/core.js"
 import { FxBase } from "./internal/protos.js"

package/src/RefArray.ts

@@ -4,13 +4,13 @@
  */
 
 import type * as C from "@typed/context"
+import * as ReadonlyArray from "effect/Array"
 import type * as Effect from "effect/Effect"
 import { equals } from "effect/Equal"
 import type { Equivalence } from "effect/Equivalence"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
 import type * as Order from "effect/Order"
-import * as ReadonlyArray from "effect/ReadonlyArray"
 import type * as Scope from "effect/Scope"
 import type * as Fx from "./Fx.js"
 import * as RefSubject from "./RefSubject.js"

package/src/RefHashMap.ts

@@ -3,12 +3,12 @@
  */
 
 import type { IdentifierConstructor, IdentifierOf } from "@typed/context"
-import type { Scope } from "effect"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
 import * as HashMap from "effect/HashMap"
 import * as HashSet from "effect/HashSet"
 import type { Option } from "effect/Option"
+import type * as Scope from "effect/Scope"
 import type * as Fx from "./Fx.js"
 import * as RefSubject from "./RefSubject.js"