effect 2.4.19 → 3.0.1

package/src/internal/cache.ts

@@ -29,13 +29,13 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export type MapValue<Key, Error, Value> =
-  | Complete<Key, Error, Value>
-  | Pending<Key, Error, Value>
-  | Refreshing<Key, Error, Value>
+export type MapValue<Key, Value, Error> =
+  | Complete<Key, Value, Error>
+  | Pending<Key, Value, Error>
+  | Refreshing<Key, Value, Error>
 
 /** @internal */
-export interface Complete<out Key, out Error, out Value> {
+export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
   readonly key: MapKey<Key>
   readonly exit: Exit.Exit<Value, Error>
@@ -44,26 +44,26 @@ export interface Complete<out Key, out Error, out Value> {
 }
 
 /** @internal */
-export interface Pending<out Key, in out Error, in out Value> {
+export interface Pending<out Key, in out Value, in out Error> {
   readonly _tag: "Pending"
   readonly key: MapKey<Key>
   readonly deferred: Deferred.Deferred<Value, Error>
 }
 
 /** @internal */
-export interface Refreshing<out Key, in out Error, in out Value> {
+export interface Refreshing<out Key, in out Value, in out Error> {
   readonly _tag: "Refreshing"
   readonly deferred: Deferred.Deferred<Value, Error>
-  readonly complete: Complete<Key, Error, Value>
+  readonly complete: Complete<Key, Value, Error>
 }
 
 /** @internal */
-export const complete = <Key, Error, Value>(
+export const complete = <Key, Value, Error>(
   key: MapKey<Key>,
   exit: Exit.Exit<Value, Error>,
   entryStats: Cache.EntryStats,
   timeToLiveMillis: number
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Complete" as const,
     key,
@@ -73,10 +73,10 @@ export const complete = <Key, Error, Value>(
   })
 
 /** @internal */
-export const pending = <Key, Error, Value>(
+export const pending = <Key, Value, Error>(
   key: MapKey<Key>,
   deferred: Deferred.Deferred<Value, Error>
-): MapValue<Key, Error, Value> =>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Pending" as const,
     key,
@@ -84,10 +84,10 @@ export const pending = <Key, Error, Value>(
   })
 
 /** @internal */
-export const refreshing = <Key, Error, Value>(
+export const refreshing = <Key, Value, Error>(
   deferred: Deferred.Deferred<Value, Error>,
-  complete: Complete<Key, Error, Value>
-): MapValue<Key, Error, Value> =>
+  complete: Complete<Key, Value, Error>
+): MapValue<Key, Value, Error> =>
   Data.struct({
     _tag: "Refreshing" as const,
     deferred,
@@ -216,8 +216,8 @@ export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>()
  *
  * @internal
  */
-export interface CacheState<in out Key, in out Error, in out Value> {
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
+export interface CacheState<in out Key, in out Value, in out Error> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
   keys: KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
@@ -230,14 +230,14 @@ export interface CacheState<in out Key, in out Error, in out Value> {
  *
  * @internal
  */
-export const makeCacheState = <Key, Error, Value>(
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>>,
+export const makeCacheState = <Key, Value, Error>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
   keys: KeySet<Key>,
   accesses: MutableQueue.MutableQueue<MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
-): CacheState<Key, Error, Value> => ({
+): CacheState<Key, Value, Error> => ({
   map,
   keys,
   accesses,
@@ -251,7 +251,7 @@ export const makeCacheState = <Key, Error, Value>(
  *
  * @internal
  */
-export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, Value> =>
+export const initialCacheState = <Key, Value, Error>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
     makeKeySet(),
@@ -292,14 +292,14 @@ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({
   loadedMillis
 })
 
-class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<Key, Error, Value> {
+class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
   readonly [CacheTypeId] = cacheVariance
-  readonly cacheState: CacheState<Key, Error, Value>
+  readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,
     readonly context: Context.Context<any>,
     readonly fiberId: FiberId.FiberId,
-    readonly lookup: Cache.Lookup<Key, any, Error, Value>,
+    readonly lookup: Cache.Lookup<Key, Value, Error, any>,
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   ) {
     this.cacheState = initialCacheState()
@@ -443,7 +443,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
           }
         }
         if (value === undefined) {
-          return core.asUnit(this.lookupValueOf(key, deferred))
+          return core.asVoid(this.lookupValueOf(key, deferred))
         } else {
           switch (value._tag) {
             case "Complete": {
@@ -452,7 +452,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 if (Equal.equals(found, value)) {
                   MutableHashMap.remove(this.cacheState.map, k)
                 }
-                return core.asUnit(this.get(key))
+                return core.asVoid(this.get(key))
               }
               // Only trigger the lookup if we're still the current value, `completedResult`
               return pipe(
@@ -460,13 +460,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
                 effect.when(() => {
                   const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                   if (Equal.equals(current, value)) {
-                    const mapValue = refreshing(deferred, value as Complete<Key, Error, Value>)
+                    const mapValue = refreshing(deferred, value as Complete<Key, Value, Error>)
                     MutableHashMap.set(this.cacheState.map, k, mapValue)
                     return true
                   }
                   return false
                 }),
-                core.asUnit
+                core.asVoid
               )
             }
             case "Pending": {
@@ -496,7 +496,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
         MutableHashMap.set(
           this.cacheState.map,
           k,
-          mapValue as Complete<Key, Error, Value>
+          mapValue as Complete<Key, Value, Error>
         )
       })
     )
@@ -545,7 +545,7 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
   }
 
   resolveMapValue(
-    value: MapValue<Key, Error, Value>,
+    value: MapValue<Key, Value, Error>,
     ignorePending = false
   ): Effect.Effect<Option.Option<Value>, Error> {
     return effect.clockWith((clock) => {
@@ -665,13 +665,13 @@ class CacheImpl<in out Key, in out Error, in out Value> implements Cache.Cache<K
 }
 
 /** @internal */
-export const make = <Key, Environment, Error, Value>(
+export const make = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> => {
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -681,13 +681,13 @@ export const make = <Key, Environment, Error, Value>(
 }
 
 /** @internal */
-export const makeWith = <Key, Environment, Error, Value>(
+export const makeWith = <Key, Value, Error = never, Environment = never>(
   options: {
     readonly capacity: number
-    readonly lookup: Cache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: Cache.Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<Cache.Cache<Key, Error, Value>, never, Environment> =>
+): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> =>
   core.map(
     fiberRuntime.all([core.context<Environment>(), core.fiberId]),
     ([context, fiberId]) =>
@@ -701,12 +701,12 @@ export const makeWith = <Key, Environment, Error, Value>(
   )
 
 /** @internal */
-export const unsafeMakeWith = <Key, Error, Value>(
+export const unsafeMakeWith = <Key, Value, Error = never>(
   capacity: number,
-  lookup: Cache.Lookup<Key, never, Error, Value>,
+  lookup: Cache.Lookup<Key, Value, Error>,
   timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
-): Cache.Cache<Key, Error, Value> =>
-  new CacheImpl<Key, Error, Value>(
+): Cache.Cache<Key, Value, Error> =>
+  new CacheImpl<Key, Value, Error>(
     capacity,
     Context.empty() as Context.Context<any>,
     none,

package/src/internal/cause.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import * as Either from "../Either.js"
@@ -11,9 +12,7 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, isFunction } from "../Predicate.js"
 import type { Predicate, Refinement } from "../Predicate.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
-import type { ParentSpan, Span } from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type { AnySpan, Span } from "../Tracer.js"
 import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 
@@ -585,7 +584,7 @@ const flattenCauseLoop = (
   while (1) {
     const [parallel, sequential] = pipe(
       causes,
-      ReadonlyArray.reduce(
+      Arr.reduce(
         [HashSet.empty<unknown>(), Chunk.empty<Cause.Cause<unknown>>()] as const,
         ([parallel, sequential], cause) => {
           const [par, seq] = evaluateCause(cause)
@@ -991,7 +990,7 @@ export const pretty = <E>(cause: Cause.Cause<E>): string => {
       message += `\r\n${filterStack(e.stack)}`
     }
     if (e.span) {
-      let current: Span | ParentSpan | undefined = e.span
+      let current: Span | AnySpan | undefined = e.span
       let i = 0
       while (current && current._tag === "Span" && i < 10) {
         message += `\r\n    at ${current.name}`
@@ -1047,7 +1046,7 @@ export const prettyErrorMessage = (u: unknown): string => {
       hasProperty(u, "toString") &&
       isFunction(u["toString"]) &&
       u["toString"] !== Object.prototype.toString &&
-      u["toString"] !== Array.prototype.toString
+      u["toString"] !== globalThis.Array.prototype.toString
     ) {
       return u["toString"]()
     }

package/src/internal/channel/channelExecutor.ts

@@ -162,7 +162,7 @@ export class ChannelExecutor<
                               Effect.flatMap(Fiber.interrupt(fiber), () =>
                                 Effect.suspend(() => {
                                   const effect = this.restorePipe(exit, inputExecutor)
-                                  return effect !== undefined ? effect : Effect.unit
+                                  return effect !== undefined ? effect : Effect.void
                                 }))
                             )
                           )
@@ -188,7 +188,7 @@ export class ChannelExecutor<
                     (effect) =>
                       Effect.sync(() => {
                         const prevLastClose = this._closeLastSubstream === undefined
-                          ? Effect.unit
+                          ? Effect.void
                           : this._closeLastSubstream
                         this._closeLastSubstream = pipe(prevLastClose, Effect.zipRight(effect))
                       })
@@ -217,7 +217,7 @@ export class ChannelExecutor<
                   this._emitted = this._currentChannel.out
                   this._currentChannel = (this._activeSubexecutor !== undefined ?
                     undefined :
-                    core.unit) as core.Primitive | undefined
+                    core.void) as core.Primitive | undefined
                   result = ChannelState.Emit()
                   break
                 }
@@ -252,13 +252,13 @@ export class ChannelExecutor<
                         const state = this.doneHalt(cause)
                         return state !== undefined && ChannelState.isFromEffect(state) ?
                           state.effect :
-                          Effect.unit
+                          Effect.void
                       },
                       onSuccess: (value) => {
                         const state = this.doneSucceed(value)
                         return state !== undefined && ChannelState.isFromEffect(state) ?
                           state.effect :
-                          Effect.unit
+                          Effect.void
                       }
                     })
                   ) as ChannelState.ChannelState<unknown, Env> | undefined
@@ -279,7 +279,7 @@ export class ChannelExecutor<
 
                   this.addFinalizer((exit) => {
                     const effect = this.restorePipe(exit, previousInput)
-                    return effect !== undefined ? effect : Effect.unit
+                    return effect !== undefined ? effect : Effect.void
                   })
 
                   this._currentChannel = this._currentChannel.right() as core.Primitive
@@ -382,7 +382,7 @@ export class ChannelExecutor<
       }
       next = this._doneStack.pop() as Continuation.Primitive | undefined
     }
-    const effect = (finalizers.length === 0 ? Effect.unit : runFinalizers(finalizers, exit)) as Effect.Effect<
+    const effect = (finalizers.length === 0 ? Effect.void : runFinalizers(finalizers, exit)) as Effect.Effect<
       unknown,
       never,
       Env
@@ -414,7 +414,7 @@ export class ChannelExecutor<
       const effect = currInput.close(exit)
       return effect
     }
-    return Effect.unit
+    return Effect.void
   }
 
   close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<unknown, never, Env> | undefined {
@@ -608,7 +608,7 @@ export class ChannelExecutor<
     })
     this._activeSubexecutor = undefined
     return state === undefined ?
-      Effect.unit :
+      Effect.void :
       ChannelState.effect(state)
   }
 
@@ -622,7 +622,7 @@ export class ChannelExecutor<
         Effect.forEach((closeFunc) =>
           pipe(
             Effect.sync(() => closeFunc(subexecutorDone)),
-            Effect.flatMap((closeEffect) => closeEffect !== undefined ? closeEffect : Effect.unit)
+            Effect.flatMap((closeEffect) => closeEffect !== undefined ? closeEffect : Effect.void)
           ), { discard: true })
       )
     )
@@ -802,7 +802,7 @@ export class ChannelExecutor<
     return ChannelState.Read(
       subexecutor.upstreamExecutor,
       (effect) => {
-        const closeLastSubstream = this._closeLastSubstream === undefined ? Effect.unit : this._closeLastSubstream
+        const closeLastSubstream = this._closeLastSubstream === undefined ? Effect.void : this._closeLastSubstream
         this._closeLastSubstream = undefined
         return pipe(
           this._executeCloseLastSubstream(closeLastSubstream),
@@ -999,7 +999,7 @@ export class ChannelExecutor<
 }
 
 const ifNotNull = <Env>(effect: Effect.Effect<unknown, never, Env> | undefined): Effect.Effect<unknown, never, Env> =>
-  effect !== undefined ? effect : Effect.unit
+  effect !== undefined ? effect : Effect.void
 
 const runFinalizers = <Env>(
   finalizers: Array<ErasedFinalizer<Env>>,
@@ -1007,7 +1007,7 @@ const runFinalizers = <Env>(
 ): Effect.Effect<unknown, never, Env> => {
   return pipe(
     Effect.forEach(finalizers, (fin) => Effect.exit(fin(exit))),
-    Effect.map((exits) => pipe(Exit.all(exits), Option.getOrElse(() => Exit.unit))),
+    Effect.map((exits) => pipe(Exit.all(exits), Option.getOrElse(() => Exit.void))),
     Effect.flatMap((exit) => Effect.suspend(() => exit as Exit.Exit<unknown>))
   )
 }
@@ -1075,7 +1075,7 @@ export const readUpstream = <A, E2, R, E>(
           Effect.catchAllCause((cause) =>
             Effect.suspend(() => {
               const doneEffect = current.onDone(Exit.failCause(cause)) as Effect.Effect<void>
-              return doneEffect === undefined ? Effect.unit : doneEffect
+              return doneEffect === undefined ? Effect.void : doneEffect
             })
           ),
           Effect.matchCauseEffect({ onFailure, onSuccess: () => read() })
@@ -1120,7 +1120,7 @@ export const runScoped = <Env, InErr, InDone, OutErr, OutDone>(
       (exec, exit) => {
         const finalize = exec.close(exit)
         if (finalize === undefined) {
-          return Effect.unit
+          return Effect.void
         }
         return Effect.tapErrorCause(
           finalize,

package/src/internal/channel/channelState.ts

@@ -127,7 +127,7 @@ export const isRead = <E, R>(self: ChannelState<E, R>): self is Read => (self as
 
 /** @internal */
 export const effect = <E, R>(self: ChannelState<E, R>): Effect.Effect<void, E, R> =>
-  isFromEffect(self) ? self.effect as Effect.Effect<void, E, R> : Effect.unit
+  isFromEffect(self) ? self.effect as Effect.Effect<void, E, R> : Effect.void
 
 /** @internal */
 export const effectOrUndefinedIgnored = <E, R>(self: ChannelState<E, R>): Effect.Effect<void, E, R> | undefined =>

package/src/internal/channel/singleProducerAsyncInput.ts

@@ -100,7 +100,7 @@ class SingleProducerAsyncInputImpl<in out Err, in out Elem, in out Done>
       Ref.modify(this.ref, (state) =>
         state._tag === OP_STATE_EMPTY ?
           [Deferred.await(state.notifyProducer), state as State<Err, Elem, Done>] :
-          [Effect.unit, state])
+          [Effect.void, state])
     )
   }
 

package/src/internal/channel.ts

@@ -44,7 +44,7 @@ export const acquireUseRelease = <Acquired, OutErr, Env, OutElem1, InElem, InErr
     core.fromEffect(
       Ref.make<
         (exit: Exit.Exit<OutDone, OutErr>) => Effect.Effect<any, never, Env>
-      >(() => Effect.unit)
+      >(() => Effect.void)
     ),
     (ref) =>
       pipe(
@@ -78,7 +78,7 @@ export const as = dual<
 ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone2, InDone, Env> => map(self, () => value))
 
 /** @internal */
-export const asUnit = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+export const asVoid = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
 ): Channel.Channel<OutElem, InElem, OutErr, InErr, void, InDone, Env> => map(self, constVoid)
 
@@ -931,8 +931,8 @@ export const mapOutEffectPar = dual<
                 onLeft: (outDone) => {
                   const lock = withPermits(n)
                   return Effect.zipRight(
-                    Effect.interruptible(lock(Effect.unit)),
-                    Effect.asUnit(Queue.offer(
+                    Effect.interruptible(lock(Effect.void)),
+                    Effect.asVoid(Queue.offer(
                       queue,
                       Effect.succeed(Either.left(outDone))
                     ))
@@ -942,7 +942,7 @@ export const mapOutEffectPar = dual<
                   Effect.gen(function*($) {
                     const deferred = yield* $(Deferred.make<OutElem1, OutErr1>())
                     const latch = yield* $(Deferred.make<void>())
-                    yield* $(Effect.asUnit(Queue.offer(
+                    yield* $(Effect.asVoid(Queue.offer(
                       queue,
                       Effect.map(Deferred.await(deferred), Either.right)
                     )))
@@ -1189,7 +1189,7 @@ export const mergeAllWith = (
               pipe(
                 Queue.offer(queue, Effect.failCause(cause)),
                 Effect.zipRight(Deferred.succeed(errorSignal, void 0)),
-                Effect.asUnit
+                Effect.asVoid
               )
           )
         )
@@ -1204,7 +1204,7 @@ export const mergeAllWith = (
             onLeft: (outDone) =>
               Effect.raceWith(
                 Effect.interruptible(Deferred.await(errorSignal)),
-                Effect.interruptible(withPermits(concurrencyN)(Effect.unit)),
+                Effect.interruptible(withPermits(concurrencyN)(Effect.void)),
                 {
                   onSelfDone: (_, permitAcquisition) => Effect.as(Fiber.interrupt(permitAcquisition), false),
                   onOtherDone: (_, failureAwait) =>
@@ -2211,7 +2211,7 @@ export const toPull = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
       Effect.sync(() => new executor.ChannelExecutor(self, void 0, identity)),
       (exec, exit) => {
         const finalize = exec.close(exit)
-        return finalize === undefined ? Effect.unit : finalize
+        return finalize === undefined ? Effect.void : finalize
       }
     ),
     (exec) => Effect.suspend(() => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
@@ -2316,7 +2316,7 @@ export const withSpan = dual<
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
@@ -2329,7 +2329,7 @@ export const withSpan = dual<
     options?: {
       readonly attributes?: Record<string, unknown> | undefined
       readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-      readonly parent?: Tracer.ParentSpan | undefined
+      readonly parent?: Tracer.AnySpan | undefined
       readonly root?: boolean | undefined
       readonly context?: Context.Context<never> | undefined
     }
@@ -2363,7 +2363,7 @@ const writeChunkWriter = <OutElem>(
   chunk: Chunk.Chunk<OutElem>
 ): Channel.Channel<OutElem> => {
   return idx === len
-    ? core.unit
+    ? core.void
     : pipe(
       core.write(pipe(chunk, Chunk.unsafeGet(idx))),
       core.flatMap(() => writeChunkWriter(idx + 1, len, chunk))

package/src/internal/clock.ts

@@ -85,8 +85,8 @@ class ClockImpl implements Clock.Clock {
 
   sleep(duration: Duration.Duration): Effect.Effect<void> {
     return core.async<void>((resume) => {
-      const canceler = globalClockScheduler.unsafeSchedule(() => resume(core.unit), duration)
-      return core.asUnit(core.sync(canceler))
+      const canceler = globalClockScheduler.unsafeSchedule(() => resume(core.void), duration)
+      return core.asVoid(core.sync(canceler))
     })
   }
 }