effect 2.4.19 → 3.0.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 => {

package/src/internal/sink.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import * as Cause from "../Cause.js"
 import type * as Channel from "../Channel.js"
 import * as Chunk from "../Chunk.js"
@@ -17,7 +18,6 @@ import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, type Predicate, type Refinement } from "../Predicate.js"
 import * as PubSub from "../PubSub.js"
 import * as Queue from "../Queue.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type * as Scope from "../Scope.js"
 import type * as Sink from "../Sink.js"
@@ -213,7 +213,7 @@ const collectAllWhileReader = <In>(
 ): Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, never, never, Chunk.Chunk<In>, unknown> =>
   core.readWith({
     onInput: (input: Chunk.Chunk<In>) => {
-      const [collected, leftovers] = pipe(Chunk.toReadonlyArray(input), ReadonlyArray.span(predicate))
+      const [collected, leftovers] = pipe(Chunk.toReadonlyArray(input), Array.span(predicate))
       if (leftovers.length === 0) {
         return collectAllWhileReader(
           predicate,
@@ -565,7 +565,7 @@ const dropLoop = <In>(
       )
     },
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
 
 /** @internal */
@@ -600,7 +600,7 @@ const dropUntilEffectReader = <In, R, E>(
         channel.unwrap
       ),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
 
 /** @internal */
@@ -649,7 +649,7 @@ const dropWhileEffectReader = <In, R, E>(
         channel.unwrap
       ),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
 
 /** @internal */
@@ -1346,7 +1346,7 @@ export const forEach = <In, X, E, R>(f: (input: In) => Effect.Effect<X, E, R>):
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(core.fromEffect(Effect.forEach(input, (v) => f(v), { discard: true })), core.flatMap(() => process)),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
   return new SinkImpl(process)
 }
@@ -1358,7 +1358,7 @@ export const forEachChunk = <In, X, E, R>(
   const process: Channel.Channel<never, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => pipe(core.fromEffect(f(input)), core.flatMap(() => process)),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
   return new SinkImpl(process)
 }
@@ -1370,7 +1370,7 @@ export const forEachWhile = <In, E, R>(
   const process: Channel.Channel<Chunk.Chunk<In>, Chunk.Chunk<In>, E, E, void, unknown, R> = core.readWithCause({
     onInput: (input: Chunk.Chunk<In>) => forEachWhileReader(f, input, 0, input.length, process),
     onFailure: core.failCause,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
   return new SinkImpl(process)
 }
@@ -1405,10 +1405,10 @@ export const forEachChunkWhile = <In, E, R>(
     onInput: (input: Chunk.Chunk<In>) =>
       pipe(
         core.fromEffect(f(input)),
-        core.flatMap((cont) => cont ? reader : core.unit)
+        core.flatMap((cont) => cont ? reader : core.void)
       ),
     onFailure: core.fail,
-    onDone: () => core.unit
+    onDone: () => core.void
   })
   return new SinkImpl(reader)
 }

package/src/internal/stm/stm/tExit.ts

@@ -183,5 +183,8 @@ export const retry: TExit<never> = {
   }
 }
 
-/** @internal */
-export const unit = (): TExit<void> => succeed(undefined)
+const void_: TExit<void> = succeed(undefined)
+export {
+  /** @internal */
+  void_ as void
+}

package/src/internal/stm/stm.ts

@@ -1,3 +1,4 @@
+import * as RA from "../../Array.js"
 import * as Cause from "../../Cause.js"
 import * as Chunk from "../../Chunk.js"
 import * as Context from "../../Context.js"
@@ -10,9 +11,8 @@ import { constFalse, constTrue, constVoid, dual, identity, pipe } from "../../Fu
 import * as Option from "../../Option.js"
 import type { Predicate, Refinement } from "../../Predicate.js"
 import * as predicate from "../../Predicate.js"
-import * as RA from "../../ReadonlyArray.js"
 import type * as STM from "../../STM.js"
-import type { MergeRecord, NoInfer } from "../../Types.js"
+import type { MergeRecord } from "../../Types.js"
 import * as effectCore from "../core.js"
 import * as SingleShotGen from "../singleShotGen.js"
 import * as core from "./core.js"
@@ -98,7 +98,7 @@ export const asSomeError = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<A, Option.
   pipe(self, mapError(Option.some))
 
 /** @internal */
-export const asUnit = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<void, E, R> => pipe(self, core.map(constVoid))
+export const asVoid = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<void, E, R> => pipe(self, core.map(constVoid))
 
 /** @internal */
 export const attempt = <A>(evaluate: LazyArg<A>): STM.STM<A, unknown> =>
@@ -273,7 +273,7 @@ export const catchTags: {
   }))
 
 /** @internal */
-export const check = (predicate: LazyArg<boolean>): STM.STM<void> => suspend(() => predicate() ? unit : core.retry)
+export const check = (predicate: LazyArg<boolean>): STM.STM<void> => suspend(() => predicate() ? void_ : core.retry)
 
 /** @internal */
 export const collect = dual<
@@ -573,7 +573,7 @@ export const forEach = dual<
           const loop: STM.STM<void, E, R> = suspend(() => {
             const next = iterator.next()
             if (next.done) {
-              return unit
+              return void_
             }
             return pipe(f(next.value), core.flatMap(() => loop))
           })
@@ -713,7 +713,7 @@ export const if_ = dual<
 
 /** @internal */
 export const ignore = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<void, never, R> =>
-  match(self, { onFailure: () => unit, onSuccess: () => unit })
+  match(self, { onFailure: () => void_, onSuccess: () => void_ })
 
 /** @internal */
 export const isFailure = <A, E, R>(self: STM.STM<A, E, R>): STM.STM<boolean, never, R> =>
@@ -806,7 +806,7 @@ const loopDiscardLoop = <Z, R, E, X>(
       core.flatMap(() => loopDiscardLoop(inc(initial), cont, inc, body))
     )
   }
-  return unit
+  return void_
 }
 
 /** @internal */
@@ -872,7 +872,7 @@ export const none = <A, E, R>(self: STM.STM<Option.Option<A>, E, R>): STM.STM<vo
   core.matchSTM(self, {
     onFailure: (e) => core.fail(Option.some(e)),
     onSuccess: Option.match({
-      onNone: () => unit,
+      onNone: () => void_,
       onSome: () => core.fail(Option.none())
     })
   })
@@ -1370,7 +1370,11 @@ export const try_: {
 }
 
 /** @internal */
-export const unit: STM.STM<void> = core.succeed(void 0)
+const void_: STM.STM<void> = core.succeed(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const unless = dual<

package/src/internal/stm/tMap.ts

@@ -1,3 +1,4 @@
+import * as RA from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import * as Equal from "../../Equal.js"
 import type { LazyArg } from "../../Function.js"
@@ -6,7 +7,6 @@ import * as Hash from "../../Hash.js"
 import * as HashMap from "../../HashMap.js"
 import * as Option from "../../Option.js"
 import { hasProperty } from "../../Predicate.js"
-import * as RA from "../../ReadonlyArray.js"
 import * as STM from "../../STM.js"
 import type * as TArray from "../../TArray.js"
 import type * as TMap from "../../TMap.js"
@@ -187,7 +187,7 @@ export const forEach = dual<
   reduceSTM(
     self,
     void 0 as void,
-    (_, value, key) => stm.asUnit(f(key, value))
+    (_, value, key) => stm.asVoid(f(key, value))
   ))
 
 /** @internal */
@@ -501,7 +501,7 @@ export const setIfAbsent = dual<
     get(self, key),
     Option.match({
       onNone: () => set(self, key, value),
-      onSome: () => stm.unit
+      onSome: () => stm.void
     })
   ))
 

package/src/internal/stm/tPriorityQueue.ts

@@ -1,9 +1,9 @@
+import * as Array from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import type * as Order from "../../Order.js"
 import type { Predicate } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as SortedMap from "../../SortedMap.js"
 import type * as STM from "../../STM.js"
 import type * as TPriorityQueue from "../../TPriorityQueue.js"
@@ -42,7 +42,7 @@ export const fromIterable =
   <A>(order: Order.Order<A>) => (iterable: Iterable<A>): STM.STM<TPriorityQueue.TPriorityQueue<A>> =>
     pipe(
       tRef.make(
-        Array.from(iterable).reduce(
+        Array.fromIterable(iterable).reduce(
           (map, value) =>
             pipe(
               map,
@@ -52,8 +52,8 @@ export const fromIterable =
                   map,
                   SortedMap.get(value),
                   Option.match({
-                    onNone: () => ReadonlyArray.of(value),
-                    onSome: ReadonlyArray.prepend(value)
+                    onNone: () => Array.of(value),
+                    onSome: Array.prepend(value)
                   })
                 )
               )
@@ -86,8 +86,8 @@ export const offer = dual<
       map,
       value,
       Option.match(SortedMap.get(map, value), {
-        onNone: () => ReadonlyArray.of(value),
-        onSome: ReadonlyArray.prepend(value)
+        onNone: () => Array.of(value),
+        onSome: Array.prepend(value)
       })
     )))
 
@@ -97,14 +97,14 @@ export const offerAll = dual<
   <A>(self: TPriorityQueue.TPriorityQueue<A>, values: Iterable<A>) => STM.STM<void>
 >(2, (self, values) =>
   tRef.update(self.ref, (map) =>
-    Array.from(values).reduce(
+    Array.fromIterable(values).reduce(
       (map, value) =>
         SortedMap.set(
           map,
           value,
           Option.match(SortedMap.get(map, value), {
-            onNone: () => ReadonlyArray.of(value),
-            onSome: ReadonlyArray.prepend(value)
+            onNone: () => Array.of(value),
+            onSome: Array.prepend(value)
           })
         ),
       map
@@ -147,7 +147,7 @@ export const retainIf = dual<
       self.ref,
       (map) =>
         SortedMap.reduce(map, SortedMap.empty(SortedMap.getOrder(map)), (map, value, key) => {
-          const filtered: ReadonlyArray<A> = ReadonlyArray.filter(value, predicate)
+          const filtered: ReadonlyArray<A> = Array.filter(value, predicate)
           return filtered.length > 0 ?
             SortedMap.set(map, key, filtered as [A, ...Array<A>]) :
             SortedMap.remove(map, key)
@@ -228,7 +228,7 @@ export const takeUpTo = dual<
     let next: IteratorResult<readonly [A, [A, ...Array<A>]], any>
     while ((next = iterator.next()) && !next.done && index < n) {
       const [key, value] = next.value
-      const [left, right] = pipe(value, ReadonlyArray.splitAt(n - index))
+      const [left, right] = pipe(value, Array.splitAt(n - index))
       for (const value of left) {
         builder.push(value)
       }