effect 3.0.0 → 3.0.2

package/src/internal/metric/state.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
@@ -80,7 +80,7 @@ class CounterState<A extends (number | bigint)> implements MetricState.MetricSta
   }
 }
 
-const arrayEquals = Array.getEquivalence(Equal.equals)
+const arrayEquals = Arr.getEquivalence(Equal.equals)
 
 /** @internal */
 class FrequencyState implements MetricState.MetricState.Frequency {
@@ -91,14 +91,14 @@ class FrequencyState implements MetricState.MetricState.Frequency {
   [Hash.symbol](): number {
     return pipe(
       Hash.string(FrequencyStateSymbolKey),
-      Hash.combine(Hash.array(Array.fromIterable(this.occurrences.entries()))),
+      Hash.combine(Hash.array(Arr.fromIterable(this.occurrences.entries()))),
       Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyState(that) && arrayEquals(
-      Array.fromIterable(this.occurrences.entries()),
-      Array.fromIterable(that.occurrences.entries())
+      Arr.fromIterable(this.occurrences.entries()),
+      Arr.fromIterable(that.occurrences.entries())
     )
   }
   pipe() {

package/src/internal/metric.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+import * as Arr from "../Array.js"
 import * as Clock from "../Clock.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
@@ -275,7 +275,7 @@ export const taggedWithLabelsInput = dual<
       (input, extraTags) =>
         self.unsafeUpdate(
           input,
-          Array.union(f(input), extraTags)
+          Arr.union(f(input), extraTags)
         ),
       self.unsafeValue
     ),
@@ -294,8 +294,8 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) => {
   return make(
     self.keyType,
-    (input, extraTags1) => self.unsafeUpdate(input, Array.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(Array.union(extraTags, extraTags1))
+    (input, extraTags1) => self.unsafeUpdate(input, Arr.union(extraTags, extraTags1)),
+    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1))
   )
 })
 

package/src/internal/queue.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+import * as Arr from "../Array.js"
 import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import type * as Effect from "../Effect.js"
@@ -208,11 +208,11 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
       }
-      const values = Array.fromIterable(iterable)
+      const values = Arr.fromIterable(iterable)
       const pTakers = this.queue.length() === 0
-        ? Array.fromIterable(unsafePollN(this.takers, values.length))
-        : Array.empty
-      const [forTakers, remaining] = pipe(values, Array.splitAt(pTakers.length))
+        ? Arr.fromIterable(unsafePollN(this.takers, values.length))
+        : Arr.empty
+      const [forTakers, remaining] = pipe(values, Arr.splitAt(pTakers.length))
       for (let i = 0; i < pTakers.length; i++) {
         const taker = (pTakers as any)[i]
         const item = forTakers[i]
@@ -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.fromIterable(iterable)
+    const stuff = Arr.fromIterable(iterable)
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i]
       if (i === stuff.length - 1) {

package/src/internal/redBlackTree/iterator.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import * as Option from "../../Option.js"
 import type * as RBT from "../../RedBlackTree.js"
 import type { RedBlackTreeImpl } from "../redBlackTree.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(Array.last(this.stack), (node) => [node.key, node.value])
+    return Option.map(Arr.last(this.stack), (node) => [node.key, node.value])
   }
 
   /**

package/src/internal/secret.ts

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

package/src/internal/sink.ts

@@ -1,4 +1,4 @@
-import * as Array from "../Array.js"
+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"
@@ -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), Array.span(predicate))
+      const [collected, leftovers] = pipe(Chunk.toReadonlyArray(input), Arr.span(predicate))
       if (leftovers.length === 0) {
         return collectAllWhileReader(
           predicate,

package/src/internal/stm/tPriorityQueue.ts

@@ -1,4 +1,4 @@
-import * as Array from "../../Array.js"
+import * as Arr from "../../Array.js"
 import * as Chunk from "../../Chunk.js"
 import { dual, pipe } from "../../Function.js"
 import * as Option from "../../Option.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.fromIterable(iterable).reduce(
+        Arr.fromIterable(iterable).reduce(
           (map, value) =>
             pipe(
               map,
@@ -52,8 +52,8 @@ export const fromIterable =
                   map,
                   SortedMap.get(value),
                   Option.match({
-                    onNone: () => Array.of(value),
-                    onSome: Array.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: () => Array.of(value),
-        onSome: Array.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.fromIterable(values).reduce(
+    Arr.fromIterable(values).reduce(
       (map, value) =>
         SortedMap.set(
           map,
           value,
           Option.match(SortedMap.get(map, value), {
-            onNone: () => Array.of(value),
-            onSome: Array.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> = Array.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, Array.splitAt(n - index))
+      const [left, right] = pipe(value, Arr.splitAt(n - index))
       for (const value of left) {
         builder.push(value)
       }

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.0.0"
+let moduleVersion = "3.0.2"
 
 export const getCurrentVersion = () => moduleVersion