effect 2.4.19 → 3.0.1

package/src/internal/sink.ts

@@ -1,3 +1,4 @@
+import * as Arr 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), Arr.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 Arr 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(
+        Arr.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: () => Arr.of(value),
+                    onSome: Arr.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: () => Arr.of(value),
+        onSome: Arr.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(
+    Arr.fromIterable(values).reduce(
       (map, value) =>
         SortedMap.set(
           map,
           value,
           Option.match(SortedMap.get(map, value), {
-            onNone: () => ReadonlyArray.of(value),
-            onSome: ReadonlyArray.prepend(value)
+            onNone: () => Arr.of(value),
+            onSome: Arr.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> = Arr.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, Arr.splitAt(n - index))
       for (const value of left) {
         builder.push(value)
       }

package/src/internal/stm/tPubSub.ts

@@ -1,8 +1,8 @@
+import * as RA from "../../Array.js"
 import * as Effect from "../../Effect.js"
 import { dual, identity, pipe } from "../../Function.js"
 import * as HashSet from "../../HashSet.js"
 import * as Option from "../../Option.js"
-import * as RA from "../../ReadonlyArray.js"
 import type * as Scope from "../../Scope.js"
 import type * as STM from "../../STM.js"
 import type * as TPubSub from "../../TPubSub.js"
@@ -64,7 +64,7 @@ class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
 
   awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
-    (isShutdown) => isShutdown ? stm.unit : core.retry
+    (isShutdown) => isShutdown ? stm.void : core.retry
   )
 
   capacity(): number {
@@ -195,7 +195,7 @@ class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
 
   awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
-    (isShutdown) => isShutdown ? stm.unit : core.retry
+    (isShutdown) => isShutdown ? stm.void : core.retry
   )
 
   capacity(): number {

package/src/internal/stm/tQueue.ts

@@ -1,8 +1,8 @@
+import * as RA from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.js"
 import { hasProperty, type Predicate } from "../../Predicate.js"
-import * as RA from "../../ReadonlyArray.js"
 import * as STM from "../../STM.js"
 import type * as TQueue from "../../TQueue.js"
 import type * as TRef from "../../TRef.js"
@@ -110,7 +110,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
 
   shutdown: STM.STM<void> = core.withSTMRuntime((runtime) => {
     tRef.unsafeSet(this.ref, void 0, runtime.journal)
-    return stm.unit
+    return stm.void
   })
 
   isShutdown: STM.STM<boolean> = core.effect<never, boolean>((journal) => {
@@ -120,7 +120,7 @@ class TQueueImpl<in out A> implements TQueue.TQueue<A> {
 
   awaitShutdown: STM.STM<void> = core.flatMap(
     this.isShutdown,
-    (isShutdown) => isShutdown ? stm.unit : core.retry
+    (isShutdown) => isShutdown ? stm.void : core.retry
   )
 
   offer(value: A): STM.STM<boolean> {

package/src/internal/stm/tSet.ts

@@ -1,9 +1,9 @@
+import * as RA from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as HashSet from "../../HashSet.js"
 import type * as Option from "../../Option.js"
 import { hasProperty, type Predicate } from "../../Predicate.js"
-import * as RA from "../../ReadonlyArray.js"
 import * as STM from "../../STM.js"
 import type * as TMap from "../../TMap.js"
 import type * as TSet from "../../TSet.js"

package/src/internal/stream/haltStrategy.ts

@@ -53,33 +53,42 @@ export const isEither = (self: HaltStrategy.HaltStrategy): self is HaltStrategy.
 
 /** @internal */
 export const match = dual<
-  <Z>(onLeft: () => Z, onRight: () => Z, onBoth: () => Z, onEither: () => Z) => (self: HaltStrategy.HaltStrategy) => Z,
+  <Z>(options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }) => (self: HaltStrategy.HaltStrategy) => Z,
   <Z>(
     self: HaltStrategy.HaltStrategy,
-    onLeft: () => Z,
-    onRight: () => Z,
-    onBoth: () => Z,
-    onEither: () => Z
+    options: {
+      readonly onLeft: () => Z
+      readonly onRight: () => Z
+      readonly onBoth: () => Z
+      readonly onEither: () => Z
+    }
   ) => Z
->(5, <Z>(
+>(2, <Z>(
   self: HaltStrategy.HaltStrategy,
-  onLeft: () => Z,
-  onRight: () => Z,
-  onBoth: () => Z,
-  onEither: () => Z
+  options: {
+    readonly onLeft: () => Z
+    readonly onRight: () => Z
+    readonly onBoth: () => Z
+    readonly onEither: () => Z
+  }
 ): Z => {
   switch (self._tag) {
     case OpCodes.OP_LEFT: {
-      return onLeft()
+      return options.onLeft()
     }
     case OpCodes.OP_RIGHT: {
-      return onRight()
+      return options.onRight()
     }
     case OpCodes.OP_BOTH: {
-      return onBoth()
+      return options.onBoth()
     }
     case OpCodes.OP_EITHER: {
-      return onEither()
+      return options.onEither()
     }
   }
 })