effect 2.0.0-next.56 → 2.0.0-next.57

package/src/internal/core.ts

@@ -18,7 +18,7 @@ import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashMap from "../HashMap.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as LogLevel from "../LogLevel.js"
 import type * as LogSpan from "../LogSpan.js"
@@ -81,10 +81,10 @@ export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
 /**
  * @internal
  */
-export const blocked = <R, E, A>(
-  blockedRequests: BlockedRequests.RequestBlock<R>,
-  _continue: Effect.Effect<R, E, A>
-): Effect.Blocked<R, E, A> => {
+export const blocked = <E, A>(
+  blockedRequests: BlockedRequests.RequestBlock,
+  _continue: Effect.Effect<never, E, A>
+): Effect.Blocked<E, A> => {
   const effect = new EffectPrimitive("Blocked") as any
   effect.i0 = blockedRequests
   effect.i1 = _continue
@@ -94,9 +94,9 @@ export const blocked = <R, E, A>(
 /**
  * @internal
  */
-export const runRequestBlock = <R>(
-  blockedRequests: BlockedRequests.RequestBlock<R>
-): Effect.Blocked<R, never, void> => {
+export const runRequestBlock = (
+  blockedRequests: BlockedRequests.RequestBlock
+): Effect.Effect<never, never, void> => {
   const effect = new EffectPrimitive("RunBlocked") as any
   effect.i0 = blockedRequests
   return effect
@@ -172,7 +172,7 @@ class EffectPrimitive {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -210,7 +210,7 @@ class EffectPrimitiveFailure {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -248,7 +248,7 @@ class EffectPrimitiveSuccess {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -269,17 +269,17 @@ export interface Async extends
 {}
 
 /** @internal */
-export interface Blocked<out R = any, out E = any, out A = any> extends
+export interface Blocked<out E = any, out A = any> extends
   Op<"Blocked", {
-    readonly i0: BlockedRequests.RequestBlock<R>
-    readonly i1: Effect.Effect<R, E, A>
+    readonly i0: BlockedRequests.RequestBlock
+    readonly i1: Effect.Effect<never, E, A>
   }>
 {}
 
 /** @internal */
-export interface RunBlocked<out R = any> extends
+export interface RunBlocked extends
   Op<"RunBlocked", {
-    readonly i0: BlockedRequests.RequestBlock<R>
+    readonly i0: BlockedRequests.RequestBlock
   }>
 {}
 
@@ -317,12 +317,7 @@ export interface OnSuccess extends
 {}
 
 /** @internal */
-export interface OnStep extends
-  Op<"OnStep", {
-    readonly i0: Primitive
-    i1(result: Exit.Exit<any, any> | Blocked): Primitive
-  }>
-{}
+export interface OnStep extends Op<"OnStep", { readonly i0: Primitive }> {}
 
 /** @internal */
 export interface OnSuccessAndFailure extends
@@ -406,28 +401,20 @@ export const acquireUseRelease = dual<
     flatMap(
       acquire,
       (a) =>
-        flatMap(exit(suspend(() => restore(step(use(a))))), (exit): Effect.Effect<R | R2 | R3, E | E2, A2> => {
-          if (exit._tag === "Success" && exit.value._op === "Blocked") {
-            const value = exit.value
-            return blocked(
-              value.i0,
-              acquireUseRelease(succeed(a), () => value.i1, release)
-            )
-          }
-          const flat = exitFlatten(exit as Exit.Exit<E2, Exit.Exit<E2, A2>>)
-          return suspend(() => release(a, flat)).pipe(
+        flatMap(exit(suspend(() => restore(use(a)))), (exit): Effect.Effect<R | R2 | R3, E | E2, A2> => {
+          return suspend(() => release(a, exit)).pipe(
             matchCauseEffect({
               onFailure: (cause) => {
-                switch (flat._tag) {
+                switch (exit._tag) {
                   case OpCodes.OP_FAILURE: {
-                    return failCause(internalCause.parallel(flat.i0, cause))
+                    return failCause(internalCause.parallel(exit.i0, cause))
                   }
                   case OpCodes.OP_SUCCESS: {
                     return failCause(cause)
                   }
                 }
               },
-              onSuccess: () => flat
+              onSuccess: () => exit
             })
           )
         })
@@ -452,28 +439,41 @@ export const async = <R, E, A>(
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<R, E, A> =>
   suspend(() => {
+    let backingResume: ((_: Effect.Effect<R, E, A>) => void) | undefined = undefined
+    let pendingEffect: Effect.Effect<R, E, A> | undefined = undefined
+    function proxyResume(effect: Effect.Effect<R, E, A>) {
+      if (backingResume) {
+        backingResume(effect)
+      } else if (pendingEffect === undefined) {
+        pendingEffect = effect
+      }
+    }
+    const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
+    effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
+      backingResume = resume
+      if (pendingEffect) {
+        resume(pendingEffect)
+      }
+    }
+    effect.i1 = blockingOn
+
     let cancelerRef: Effect.Effect<R, never, void> | void = undefined
     let controllerRef: AbortController | void = undefined
-    const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
     if (register.length !== 1) {
-      const controller = new AbortController()
-      controllerRef = controller
-      effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
-        cancelerRef = register(resume, controller.signal)
-      }
+      controllerRef = new AbortController()
+      cancelerRef = register(proxyResume, controllerRef.signal)
     } else {
-      effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
-        // @ts-expect-error
-        cancelerRef = register(resume)
-      }
+      cancelerRef = (register as any)(proxyResume)
     }
-    effect.i1 = blockingOn
-    return onInterrupt(effect, () => {
-      if (controllerRef) {
-        controllerRef.abort()
-      }
-      return cancelerRef ?? unit
-    })
+
+    return (cancelerRef || controllerRef) ?
+      onInterrupt(effect, (_) => {
+        if (controllerRef) {
+          controllerRef.abort()
+        }
+        return cancelerRef ?? unit
+      }) :
+      effect
   })
 
 /* @internal */
@@ -756,21 +756,9 @@ export const andThen = dual<
 /* @internal */
 export const step = <R, E, A>(
   self: Effect.Effect<R, E, A>
-): Effect.Effect<R, E, Exit.Exit<E, A> | Effect.Blocked<R, E, A>> => {
+): Effect.Effect<R, never, Exit.Exit<E, A> | Effect.Blocked<E, A>> => {
   const effect = new EffectPrimitive("OnStep") as any
   effect.i0 = self
-  effect.i1 = exitSucceed
-  return effect
-}
-
-/* @internal */
-export const flatMapStep = <R, E, A, R1, E1, B>(
-  self: Effect.Effect<R, E, A>,
-  f: (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>) => Effect.Effect<R1, E1, B>
-): Effect.Effect<R | R1, E1, B> => {
-  const effect = new EffectPrimitive("OnStep") as any
-  effect.i0 = self
-  effect.i1 = f
   return effect
 }
 
@@ -939,14 +927,7 @@ export const interruptWith = (fiberId: FiberId.FiberId): Effect.Effect<never, ne
 export const interruptible = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
-  const _continue = (orBlock: any) => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, interruptible(orBlock.i1))
-    } else {
-      return orBlock
-    }
-  }
-  effect.i1 = () => flatMapStep(self, _continue)
+  effect.i1 = () => self
   return effect
 }
 
@@ -956,17 +937,11 @@ export const interruptibleMask = <R, E, A>(
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
-  const _continue = (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>): Exit.Exit<E, A> | Effect.Blocked<R, E, A> => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, interruptible(step.i1))
-    }
-    return step
-  }
   effect.i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
     _runtimeFlags.interruption(oldFlags)
-      ? step(f(interruptible))
-      : step(f(uninterruptible))
-  return flatMap(effect, _continue)
+      ? f(interruptible)
+      : f(uninterruptible)
+  return effect
 }
 
 /* @internal */
@@ -1233,14 +1208,7 @@ export const uninterruptible: <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
-  effect.i1 = () => flatMapStep(self, _continue)
-  const _continue = (orBlock: any) => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, uninterruptible(orBlock.i1))
-    } else {
-      return orBlock
-    }
-  }
+  effect.i1 = () => self
   return effect
 }
 
@@ -1250,17 +1218,11 @@ export const uninterruptibleMask = <R, E, A>(
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
-  const _continue = (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>): Exit.Exit<E, A> | Effect.Blocked<R, E, A> => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, uninterruptible(step.i1))
-    }
-    return step
-  }
   effect.i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
     _runtimeFlags.interruption(oldFlags)
-      ? step(f(interruptible))
-      : step(f(uninterruptible))
-  return flatMap(effect, _continue)
+      ? f(interruptible)
+      : f(uninterruptible)
+  return effect
 }
 
 /* @internal */
@@ -1557,8 +1519,8 @@ export const FiberRefTypeId: FiberRef.FiberRefTypeId = Symbol.for(
   FiberRefSymbolKey
 ) as FiberRef.FiberRefTypeId
 
-/** @internal */
 const fiberRefVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 
@@ -1675,7 +1637,9 @@ export const RequestResolverTypeId: RequestResolver.RequestResolverTypeId = Symb
 ) as RequestResolver.RequestResolverTypeId
 
 const requestResolverVariance = {
+  /* c8 ignore next */
   _A: (_: unknown) => _,
+  /* c8 ignore next */
   _R: (_: never) => _
 }
 
@@ -1741,16 +1705,16 @@ export const resolverLocally = dual<
   ))
 
 /** @internal */
-export const requestBlockLocally = <R, A>(
-  self: BlockedRequests.RequestBlock<R>,
+export const requestBlockLocally = <A>(
+  self: BlockedRequests.RequestBlock,
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock<R> => _blockedRequests.reduce(self, LocallyReducer(ref, value))
+): BlockedRequests.RequestBlock => _blockedRequests.reduce(self, LocallyReducer(ref, value))
 
-const LocallyReducer = <R, A>(
+const LocallyReducer = <A>(
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock.Reducer<R, BlockedRequests.RequestBlock<R>> => ({
+): BlockedRequests.RequestBlock.Reducer<BlockedRequests.RequestBlock> => ({
   emptyCase: () => _blockedRequests.empty,
   parCase: (left, right) => _blockedRequests.par(left, right),
   seqCase: (left, right) => _blockedRequests.seq(left, right),
@@ -1769,18 +1733,10 @@ export const fiberRefLocally: {
   <A>(self: FiberRef.FiberRef<A>, value: A) => <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>,
   <R, E, B, A>(use: Effect.Effect<R, E, B>, self: FiberRef.FiberRef<A>, value: A) => Effect.Effect<R, E, B>
 >(3, (use, self, value) =>
-  flatMap(
-    acquireUseRelease(
-      zipLeft(fiberRefGet(self), fiberRefSet(self, value)),
-      () => step(use),
-      (oldValue) => fiberRefSet(self, oldValue)
-    ),
-    (res) => {
-      if (res._op === "Blocked") {
-        return blocked(res.i0, fiberRefLocally(res.i1, self, value))
-      }
-      return res
-    }
+  acquireUseRelease(
+    zipLeft(fiberRefGet(self), fiberRefSet(self, value)),
+    () => use,
+    (oldValue) => fiberRefSet(self, oldValue)
   ))
 
 /* @internal */
@@ -2199,12 +2155,16 @@ export const YieldableError: new(message?: string) => Cause.YieldableError = (fu
       return fail(this)
     }
     toString() {
-      return this.stack ?? `${this.name}: ${this.message}`
+      return this.message ? `${this.name}: ${this.message}` : this.name
     }
     toJSON() {
       return { ...this }
     }
     [NodeInspectSymbol](): string {
+      const stack = this.stack
+      if (stack) {
+        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
+      }
       return this.toString()
     }
   }

package/src/internal/deferred.ts

@@ -12,7 +12,9 @@ export const DeferredTypeId: Deferred.DeferredTypeId = Symbol.for(
 
 /** @internal */
 export const deferredVariance = {
+  /* c8 ignore next */
   _E: (_: any) => _,
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/effect/circular.ts

@@ -534,6 +534,7 @@ export const SynchronizedTypeId: Synchronized.SynchronizedRefTypeId = Symbol.for
 
 /** @internal */
 export const synchronizedVariance = {
+  /* c8 ignore next */
   _A: (_: any) => _
 }
 

package/src/internal/effectable.ts

@@ -23,29 +23,43 @@ export const ChannelTypeId: Channel.ChannelTypeId = Symbol.for("effect/Channel")
 
 /** @internal */
 export const effectVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _,
+
   _V: moduleVersion
 }
 
-/** @internal */
-export const sinkVariance = {
+const sinkVariance = {
+  /* c8 ignore next */
   _R: (_: never) => _,
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _In: (_: unknown) => _,
+  /* c8 ignore next */
   _L: (_: never) => _,
+  /* c8 ignore next */
   _Z: (_: never) => _
 }
 
-/** @internal */
-export const channelVariance = {
+const channelVariance = {
+  /* c8 ignore next */
   _Env: (_: never) => _,
+  /* c8 ignore next */
   _InErr: (_: unknown) => _,
+  /* c8 ignore next */
   _InElem: (_: unknown) => _,
+  /* c8 ignore next */
   _InDone: (_: unknown) => _,
+  /* c8 ignore next */
   _OutErr: (_: never) => _,
+  /* c8 ignore next */
   _OutElem: (_: never) => _,
+  /* c8 ignore next */
   _OutDone: (_: never) => _
 }
 

package/src/internal/either.ts

@@ -6,7 +6,7 @@ import type * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
 import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type { Option } from "../Option.js"
 import { hasProperty } from "../Predicate.js"
 import { EffectPrototype } from "./effectable.js"
@@ -26,7 +26,7 @@ const CommonProto = {
     return this.toJSON()
   },
   toString<E, A>(this: Either.Left<E, A>) {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
 }
 

package/src/internal/fiber.ts

@@ -27,7 +27,9 @@ export const FiberTypeId: Fiber.FiberTypeId = Symbol.for(
 
 /** @internal */
 export const fiberVariance = {
+  /* c8 ignore next */
   _E: (_: never) => _,
+  /* c8 ignore next */
   _A: (_: never) => _
 }
 

package/src/internal/fiberId.ts

@@ -4,7 +4,7 @@ import { dual, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { hasProperty } from "../Predicate.js"
@@ -49,7 +49,7 @@ class None implements FiberId.None {
     return isFiberId(that) && that._tag === OP_NONE
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   toJSON() {
     return {
@@ -85,7 +85,7 @@ class Runtime implements FiberId.Runtime {
       this.startTimeMillis === that.startTimeMillis
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   toJSON() {
     return {
@@ -123,7 +123,7 @@ class Composite implements FiberId.Composite {
       Equal.equals(this.right, that.right)
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   toJSON() {
     return {