effect 2.4.18 → 3.0.0

package/src/internal/queue.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import type * as Effect from "../Effect.js"
@@ -8,7 +9,6 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Queue from "../Queue.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 
@@ -125,7 +125,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
           ),
           core.zipRight(this.strategy.shutdown),
           core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-          core.asUnit
+          core.asVoid
         )
       })
     )
@@ -208,11 +208,11 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
       }
-      const values = ReadonlyArray.fromIterable(iterable)
+      const values = Array.fromIterable(iterable)
       const pTakers = this.queue.length() === 0
-        ? ReadonlyArray.fromIterable(unsafePollN(this.takers, values.length))
-        : ReadonlyArray.empty
-      const [forTakers, remaining] = pipe(values, ReadonlyArray.splitAt(pTakers.length))
+        ? Array.fromIterable(unsafePollN(this.takers, values.length))
+        : Array.empty
+      const [forTakers, remaining] = pipe(values, Array.splitAt(pTakers.length))
       for (let i = 0; i < pTakers.length; i++) {
         const taker = (pTakers as any)[i]
         const item = forTakers[i]
@@ -548,9 +548,9 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
                 isLastItem ?
                   pipe(
                     core.deferredInterruptWith(deferred, fiberId),
-                    core.asUnit
+                    core.asVoid
                   ) :
-                  core.unit,
+                  core.void,
               false,
               false
             )
@@ -602,7 +602,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   unsafeOffer(iterable: Iterable<A>, deferred: Deferred.Deferred<boolean>): void {
-    const stuff = Array.from(iterable)
+    const stuff = Array.fromIterable(iterable)
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i]
       if (i === stuff.length - 1) {
@@ -630,7 +630,7 @@ class DroppingStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   onCompleteTakersWithEmptyQueue(): void {
@@ -662,7 +662,7 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   onCompleteTakersWithEmptyQueue(): void {

package/src/internal/rateLimiter.ts

@@ -38,7 +38,7 @@ const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
     const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
       Effect.zipRight(latch.releaseAll),
       Effect.zipRight(semaphore.release(1)),
-      Effect.flatMap((free) => free === limit ? Effect.unit : refill)
+      Effect.flatMap((free) => free === limit ? Effect.void : refill)
     )
     yield* _(
       latch.take(1),

package/src/internal/redBlackTree/iterator.ts

@@ -1,5 +1,5 @@
+import * as Array from "../../Array.js"
 import * as Option from "../../Option.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import type * as RBT from "../../RedBlackTree.js"
 import type { RedBlackTreeImpl } from "../redBlackTree.js"
 import type * as Node from "./node.js"
@@ -83,7 +83,7 @@ export class RedBlackTreeIterator<in out K, out V> implements Iterator<[K, V]> {
    * Returns the key
    */
   get entry(): Option.Option<[K, V]> {
-    return Option.map(ReadonlyArray.last(this.stack), (node) => [node.key, node.value])
+    return Option.map(Array.last(this.stack), (node) => [node.key, node.value])
   }
 
   /**

package/src/internal/ref.ts

@@ -3,6 +3,7 @@ import { dual } from "../Function.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
+import * as Readable from "../Readable.js"
 import type * as Ref from "../Ref.js"
 import * as core from "./core.js"
 
@@ -17,7 +18,12 @@ export const refVariance = {
 
 class RefImpl<in out A> implements Ref.Ref<A> {
   readonly [RefTypeId] = refVariance
-  constructor(readonly ref: MutableRef.MutableRef<A>) {}
+  readonly [Readable.TypeId]: Readable.TypeId
+  constructor(readonly ref: MutableRef.MutableRef<A>) {
+    this[Readable.TypeId] = Readable.TypeId
+    this.get = core.sync(() => MutableRef.get(this.ref))
+  }
+  readonly get: Effect.Effect<A>
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<B> {
     return core.sync(() => {
       const current = MutableRef.get(this.ref)
@@ -40,7 +46,7 @@ export const unsafeMake = <A>(value: A): Ref.Ref<A> => new RefImpl(MutableRef.ma
 export const make = <A>(value: A): Effect.Effect<Ref.Ref<A>> => core.sync(() => unsafeMake(value))
 
 /** @internal */
-export const get = <A>(self: Ref.Ref<A>) => self.modify((a) => [a, a])
+export const get = <A>(self: Ref.Ref<A>) => self.get
 
 /** @internal */
 export const set = dual<

package/src/internal/reloadable.ts

@@ -139,5 +139,5 @@ export const reloadFork = <T extends Context.Tag<any, any>>(
       reloadable.reload,
       effect.ignoreLogged,
       fiberRuntime.forkDaemon,
-      core.asUnit
+      core.asVoid
     ))

package/src/internal/runtime.ts

@@ -1,4 +1,5 @@
 import { equals } from "effect/Equal"
+import type * as ReadonlyArray from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
@@ -12,7 +13,6 @@ import * as Inspectable from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
-import type * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as _scheduler from "../Scheduler.js"
@@ -66,7 +66,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
           core.scopeAddFinalizer(
             closeableScope,
             core.fiberIdWith((id) =>
-              equals(id, fiberRuntime.id()) ? core.unit : core.interruptAsFiber(fiberRuntime, id)
+              equals(id, fiberRuntime.id()) ? core.void : core.interruptAsFiber(fiberRuntime, id)
             )
           ),
           core.onExit(self, (exit) => _scope.close(closeableScope, exit))
@@ -135,7 +135,7 @@ class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.Asy
   readonly _tag = "AsyncFiberException"
   constructor(readonly fiber: Fiber.RuntimeFiber<A, E>) {
     super(
-      `Fiber #${fiber.id().id} cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work`
+      `Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`
     )
     this.name = this._tag
     this.stack = this.message
@@ -483,12 +483,12 @@ export const asyncEffect = <A, E, R, R3, E2, R2>(
                     onFailure: (cause) => core.deferredFailCause(deferred, cause),
                     onSuccess: (cleanup_) => {
                       cleanup = cleanup_
-                      return core.unit
+                      return core.void
                     }
                   }
                 )
               )),
-              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.unit))
+              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.void))
             )
           ))
     )

package/src/internal/schedule/intervals.ts

@@ -3,6 +3,7 @@ import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import * as Interval from "../../ScheduleInterval.js"
 import type * as Intervals from "../../ScheduleIntervals.js"
+import { getBugErrorMessage } from "../errors.js"
 
 /** @internal */
 const IntervalsSymbolKey = "effect/ScheduleIntervals"
@@ -109,7 +110,7 @@ const unionLoop = (
         that = Chunk.tailNonEmpty(that)
       }
     } else {
-      throw new Error("BUG: Intervals.unionLoop - please report an issue at https://github.com/Effect-TS/effect/issues")
+      throw new Error(getBugErrorMessage("Intervals.unionLoop"))
     }
   }
   return make(pipe(acc, Chunk.prepend(interval), Chunk.reverse))

package/src/internal/schedule.ts

@@ -18,7 +18,6 @@ import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
-import type * as Types from "../Types.js"
 import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
@@ -247,7 +246,7 @@ export const as = dual<
 >(2, (self, out) => map(self, () => out))
 
 /** @internal */
-export const asUnit = <Out, In, R>(
+export const asVoid = <Out, In, R>(
   self: Schedule.Schedule<Out, In, R>
 ): Schedule.Schedule<void, In, R> => map(self, constVoid)
 
@@ -1903,7 +1902,7 @@ export const retry_combined: {
     self: Effect.Effect<A, E, R>
   ) => Effect.Retry.Return<R, E, A, O>
   <B, E, R1>(
-    policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R1 | R>
   <A, E, R, O extends Effect.Retry.Options<E>>(
     self: Effect.Effect<A, E, R>,
@@ -1949,13 +1948,13 @@ export const retry_combined: {
 /** @internal */
 export const retryOrElse_Effect = dual<
   <A1, E, R1, A2, E2, R2>(
-    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
-    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
+    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2, R | R1 | R2>,
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
-    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
+    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A | A2, E2, R | R1 | R2>
 >(3, (self, policy, orElse) =>
   core.flatMap(
@@ -2060,7 +2059,7 @@ export const elapsed: Schedule.Schedule<Duration.Duration> = makeWithState(
 export const forever: Schedule.Schedule<number> = unfold(0, (n) => n + 1)
 
 /** @internal */
-export const once: Schedule.Schedule<void> = asUnit(recurs(1))
+export const once: Schedule.Schedule<void> = asVoid(recurs(1))
 
 /** @internal */
-export const stop: Schedule.Schedule<void> = asUnit(recurs(0))
+export const stop: Schedule.Schedule<void> = asVoid(recurs(0))

package/src/internal/scopedCache.ts

@@ -25,8 +25,8 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export interface CacheState<in out Key, out Error, out Value> {
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
+export interface CacheState<in out Key, out Value, out Error = never> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
   keys: _cache.KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
@@ -35,14 +35,14 @@ export interface CacheState<in out Key, out Error, out Value> {
 }
 
 /** @internal */
-export const makeCacheState = <Key, Error, Value>(
-  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>>,
+export const makeCacheState = <Key, Value, Error = never>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
   keys: _cache.KeySet<Key>,
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
-): CacheState<Key, Error, Value> => ({
+): CacheState<Key, Value, Error> => ({
   map,
   keys,
   accesses,
@@ -56,7 +56,7 @@ export const makeCacheState = <Key, Error, Value>(
  *
  * @internal
  */
-export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, Value> =>
+export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
     _cache.makeKeySet(),
@@ -74,13 +74,13 @@ export const initialCacheState = <Key, Error, Value>(): CacheState<Key, Error, V
  *
  * @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: _cache.MapKey<Key>
   readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
@@ -90,27 +90,27 @@ export interface Complete<out Key, out Error, out Value> {
 }
 
 /** @internal */
-export interface Pending<out Key, out Error, out Value> {
+export interface Pending<out Key, out Value, out Error> {
   readonly _tag: "Pending"
   readonly key: _cache.MapKey<Key>
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 }
 
 /** @internal */
-export interface Refreshing<out Key, out Error, out Value> {
+export interface Refreshing<out Key, out Value, out Error> {
   readonly _tag: "Refreshing"
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
-  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 = never>(
   key: _cache.MapKey<Key>,
   exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
   ownerCount: MutableRef.MutableRef<number>,
   entryStats: Cache.EntryStats,
   timeToLive: number
-): Complete<Key, Error, Value> =>
+): Complete<Key, Value, Error> =>
   Data.struct({
     _tag: "Complete",
     key,
@@ -121,10 +121,10 @@ export const complete = <Key, Error, Value>(
   })
 
 /** @internal */
-export const pending = <Key, Error, Value>(
+export const pending = <Key, Value, Error = never>(
   key: _cache.MapKey<Key>,
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
-): Pending<Key, Error, Value> =>
+): Pending<Key, Value, Error> =>
   Data.struct({
     _tag: "Pending",
     key,
@@ -132,10 +132,10 @@ export const pending = <Key, Error, Value>(
   })
 
 /** @internal */
-export const refreshing = <Key, Error, Value>(
+export const refreshing = <Key, Value, Error = never>(
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>,
-  complete: Complete<Key, Error, Value>
-): Refreshing<Key, Error, Value> =>
+  complete: Complete<Key, Value, Error>
+): Refreshing<Key, Value, Error> =>
   Data.struct({
     _tag: "Refreshing",
     scoped,
@@ -143,8 +143,8 @@ export const refreshing = <Key, Error, Value>(
   })
 
 /** @internal */
-export const toScoped = <Key, Error, Value>(
-  self: Complete<Key, Error, Value>
+export const toScoped = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
 ): Effect.Effect<Value, Error, Scope.Scope> =>
   Exit.matchEffect(self.exit, {
     onFailure: (cause) => core.failCause(cause),
@@ -156,15 +156,15 @@ export const toScoped = <Key, Error, Value>(
   })
 
 /** @internal */
-export const releaseOwner = <Key, Error, Value>(
-  self: Complete<Key, Error, Value>
+export const releaseOwner = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
 ): Effect.Effect<void> =>
   Exit.matchEffect(self.exit, {
-    onFailure: () => core.unit,
+    onFailure: () => core.void,
     onSuccess: ([, finalizer]) =>
       core.flatMap(
         core.sync(() => MutableRef.decrementAndGet(self.ownerCount)),
-        (numOwner) => effect.when(finalizer(Exit.unit), () => numOwner === 0)
+        (numOwner) => effect.when(finalizer(Exit.void), () => numOwner === 0)
       )
   })
 
@@ -186,13 +186,13 @@ const scopedCacheVariance = {
 }
 
 class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
-  implements ScopedCache.ScopedCache<Key, Error, Value>
+  implements ScopedCache.ScopedCache<Key, Value, Error>
 {
   readonly [ScopedCacheTypeId] = scopedCacheVariance
-  readonly cacheState: CacheState<Key, Error, Value>
+  readonly cacheState: CacheState<Key, Value, Error>
   constructor(
     readonly capacity: number,
-    readonly scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
+    readonly scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
     readonly clock: Clock.Clock,
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration,
     readonly context: Context.Context<Environment>
@@ -285,7 +285,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             this.resolveMapValue(value),
             core.flatMap(Option.match({
               onNone: () => {
-                const val = value as Complete<Key, Error, Value>
+                const val = value as Complete<Key, Value, Error>
                 const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
                 if (Equal.equals(current, value)) {
                   MutableHashMap.remove(this.cacheState.map, key)
@@ -315,14 +315,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             return releaseOwner(mapValue)
           }
           case "Pending": {
-            return core.unit
+            return core.void
           }
           case "Refreshing": {
             return releaseOwner(mapValue.complete)
           }
         }
       }
-      return core.unit
+      return core.void
     })
   }
 
@@ -383,7 +383,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             }
           }
         }
-        return core.flatMap(finalScoped, (s) => fiberRuntime.scopedEffect(core.asUnit(s)))
+        return core.flatMap(finalScoped, (s) => fiberRuntime.scopedEffect(core.asVoid(s)))
       })
     )
   }
@@ -393,7 +393,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
   }
 
   resolveMapValue(
-    value: MapValue<Key, Error, Value>,
+    value: MapValue<Key, Value, Error>,
     ignorePending = false
   ): Effect.Effect<Effect.Effect<Option.Option<Value>, Error, Scope.Scope>> {
     switch (value._tag) {
@@ -459,14 +459,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
               exit.value,
               release
             ])
-            const completedResult = complete<Key, Error, Value>(
+            const completedResult = complete<Key, Value, Error>(
               _cache.makeMapKey(key),
               exitWithFinalizer,
               MutableRef.make(1),
               _cache.makeEntryStats(now),
               expiredAt
             )
-            let previousValue: MapValue<Key, Error, Value> | undefined = undefined
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
             if (MutableHashMap.has(this.cacheState.map, key)) {
               previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             }
@@ -481,14 +481,14 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
             )
           }
           case "Failure": {
-            const completedResult = complete<Key, Error, Value>(
+            const completedResult = complete<Key, Value, Error>(
               _cache.makeMapKey(key),
               exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
               MutableRef.make(0),
               _cache.makeEntryStats(now),
               expiredAt
             )
-            let previousValue: MapValue<Key, Error, Value> | undefined = undefined
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
             if (MutableHashMap.has(this.cacheState.map, key)) {
               previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             }
@@ -524,8 +524,8 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     this.cacheState.misses = this.cacheState.misses + 1
   }
 
-  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Error, Value>> {
-    const cleanedKeys: Array<MapValue<Key, Error, Value>> = []
+  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
+    const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
     MutableQueue.offer(this.cacheState.accesses, key)
     if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
       let loop = true
@@ -558,16 +558,16 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     return cleanedKeys
   }
 
-  cleanMapValue(mapValue: MapValue<Key, Error, Value> | undefined): Effect.Effect<void> {
+  cleanMapValue(mapValue: MapValue<Key, Value, Error> | undefined): Effect.Effect<void> {
     if (mapValue === undefined) {
-      return core.unit
+      return core.void
     }
     switch (mapValue._tag) {
       case "Complete": {
         return releaseOwner(mapValue)
       }
       case "Pending": {
-        return core.unit
+        return core.void
       }
       case "Refreshing": {
         return releaseOwner(mapValue.complete)
@@ -586,13 +586,13 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
 }
 
 /** @internal */
-export const make = <Key, Environment, Error, Value>(
+export const make = <Key, Value, Error = never, Environment = never>(
   options: {
-    readonly lookup: ScopedCache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
     readonly capacity: number
     readonly timeToLive: Duration.DurationInput
   }
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> => {
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> => {
   const timeToLive = Duration.decode(options.timeToLive)
   return makeWith({
     capacity: options.capacity,
@@ -602,13 +602,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: ScopedCache.Lookup<Key, Environment, Error, Value>
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
     readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
   }
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
   core.flatMap(
     effect.clock,
     (clock) =>
@@ -620,12 +620,12 @@ export const makeWith = <Key, Environment, Error, Value>(
       )
   )
 
-const buildWith = <Key, Environment, Error, Value>(
+const buildWith = <Key, Value, Error = never, Environment = never>(
   capacity: number,
-  scopedLookup: ScopedCache.Lookup<Key, Environment, Error, Value>,
+  scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
   clock: Clock.Clock,
   timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration
-): Effect.Effect<ScopedCache.ScopedCache<Key, Error, Value>, never, Environment | Scope.Scope> =>
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
   fiberRuntime.acquireRelease(
     core.flatMap(
       core.context<Environment>(),

package/src/internal/scopedRef.ts

@@ -27,7 +27,7 @@ const scopedRefVariance = {
 
 /** @internal  */
 const close = <A>(self: ScopedRef.ScopedRef<A>): Effect.Effect<void> =>
-  core.flatMap(ref.get(self.ref), (tuple) => tuple[0].close(core.exitUnit))
+  core.flatMap(ref.get(self.ref), (tuple) => tuple[0].close(core.exitVoid))
 
 /** @internal */
 export const fromAcquire = <A, E, R>(
@@ -83,14 +83,14 @@ export const set = dual<
   core.flatten(
     synchronized.modifyEffect(self.ref, ([oldScope, value]) =>
       core.uninterruptible(
-        core.scopeClose(oldScope, core.exitUnit).pipe(
+        core.scopeClose(oldScope, core.exitVoid).pipe(
           core.zipRight(fiberRuntime.scopeMake()),
           core.flatMap((newScope) =>
             core.exit(fiberRuntime.scopeExtend(acquire, newScope)).pipe(
               core.flatMap((exit) =>
                 core.exitMatch(exit, {
                   onFailure: (cause) =>
-                    core.scopeClose(newScope, core.exitUnit).pipe(
+                    core.scopeClose(newScope, core.exitVoid).pipe(
                       core.as(
                         [
                           core.failCause(cause) as Effect.Effect<void, E>,
@@ -101,7 +101,7 @@ export const set = dual<
                   onSuccess: (value) =>
                     core.succeed(
                       [
-                        core.unit as Effect.Effect<void, E>,
+                        core.void as Effect.Effect<void, E>,
                         [newScope, value] as const
                       ] as const
                     )

package/src/internal/secret.ts

@@ -1,8 +1,8 @@
+import * as Array from "../Array.js"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import { hasProperty } from "../Predicate.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Secret from "../Secret.js"
 
 /** @internal */
@@ -56,7 +56,7 @@ export const make = (bytes: Array<number>): Secret.Secret => {
 
 /** @internal */
 export const fromIterable = (iterable: Iterable<string>): Secret.Secret =>
-  make(ReadonlyArray.fromIterable(iterable).map((char) => char.charCodeAt(0)))
+  make(Array.fromIterable(iterable).map((char) => char.charCodeAt(0)))
 
 /** @internal */
 export const fromString = (text: string): Secret.Secret => {