effect 3.7.0 → 3.7.2

package/dist/esm/internal/version.js

@@ -1,4 +1,4 @@
-let moduleVersion = "3.7.0";
+let moduleVersion = "3.7.2";
 export const getCurrentVersion = () => moduleVersion;
 export const setCurrentVersion = version => {
   moduleVersion = version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "3.7.0",
+  "version": "3.7.2",
   "description": "The missing standard library for TypeScript, for writing production-grade software.",
   "license": "MIT",
   "repository": {

package/src/Array.ts

@@ -1255,7 +1255,8 @@ export const sortWith: {
   <A, B>(self: Iterable<A>, f: (a: A) => B, order: Order.Order<B>): Array<A>
 } = dual(
   3,
-  <A, B>(self: Iterable<A>, f: (a: A) => B, order: Order.Order<B>): Array<A> => sort(self, Order.mapInput(order, f))
+  <A, B>(self: Iterable<A>, f: (a: A) => B, order: Order.Order<B>): Array<A> =>
+    Array.from(self).map((a) => [a, f(a)] as const).sort((a, b) => order(a[1], b[1])).map((x) => x[0])
 )
 
 /**

package/src/Effect.ts

@@ -1832,7 +1832,7 @@ export const catchSomeDefect: {
 export const catchTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect<A1, E1, R1>
+    f: (e: NoInfer<Extract<E, { _tag: K }>>) => Effect<A1, E1, R1>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A1 | A, E1 | Exclude<E, { _tag: K }>, R1 | R>
   <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1, A1>(
     self: Effect<A, E, R>,
@@ -4347,7 +4347,7 @@ export const tapError: {
 export const tapErrorTag: {
   <K extends E extends { _tag: string } ? E["_tag"] : never, E, A1, E1, R1>(
     k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect<A1, E1, R1>
+    f: (e: NoInfer<Extract<E, { _tag: K }>>) => Effect<A1, E1, R1>
   ): <A, R>(self: Effect<A, E, R>) => Effect<A, E | E1, R1 | R>
   <A, E, R, K extends E extends { _tag: string } ? E["_tag"] : never, A1, E1, R1>(
     self: Effect<A, E, R>,

package/src/Micro.ts

@@ -3465,6 +3465,9 @@ export const forEach: {
     let result: MicroExit<any, any> | undefined = undefined
     const items = Array.from(iterable)
     let length = items.length
+    if (length === 0) {
+      return onExit(Either.right(options?.discard ? undefined : []))
+    }
     const out: Array<B> | undefined = options?.discard ? undefined : new Array(length)
     let index = 0
     let inProgress = 0

package/src/Stream.ts

@@ -532,14 +532,20 @@ export const branchAfter: {
 export const broadcast: {
   <N extends number>(
     n: N,
-    maximumLag: number
-  ): <A, E, R>(
-    self: Stream<A, E, R>
-  ) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     n: N,
-    maximumLag: number
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): Effect.Effect<TupleOf<N, Stream<A, E>>, never, Scope.Scope | R>
 } = internal.broadcast
 
@@ -552,8 +558,21 @@ export const broadcast: {
  * @category utils
  */
 export const broadcastDynamic: {
-  (maximumLag: number): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
-  <A, E, R>(self: Stream<A, E, R>, maximumLag: number): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
+  (
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
+  ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
+  <A, E, R>(
+    self: Stream<A, E, R>,
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
+  ): Effect.Effect<Stream<A, E>, never, Scope.Scope | R>
 } = internal.broadcastDynamic
 
 /**
@@ -569,14 +588,22 @@ export const broadcastDynamic: {
 export const broadcastedQueues: {
   <N extends number>(
     n: N,
-    maximumLag: number
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, R | Scope.Scope>
+  ) => Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
   <A, E, R, N extends number>(
     self: Stream<A, E, R>,
     n: N,
-    maximumLag: number
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): Effect.Effect<TupleOf<N, Queue.Dequeue<Take.Take<A, E>>>, never, Scope.Scope | R>
 } = internal.broadcastedQueues
 
@@ -592,13 +619,21 @@ export const broadcastedQueues: {
  */
 export const broadcastedQueuesDynamic: {
   (
-    maximumLag: number
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): <A, E, R>(
     self: Stream<A, E, R>
-  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, R | Scope.Scope>
+  ) => Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
   <A, E, R>(
     self: Stream<A, E, R>,
-    maximumLag: number
+    maximumLag: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): Effect.Effect<Effect.Effect<Queue.Dequeue<Take.Take<A, E>>, never, Scope.Scope>, never, Scope.Scope | R>
 } = internal.broadcastedQueuesDynamic
 
@@ -4888,11 +4923,19 @@ export const timeoutTo: {
  */
 export const toPubSub: {
   (
-    capacity: number
+    capacity: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
   <A, E, R>(
     self: Stream<A, E, R>,
-    capacity: number
+    capacity: number | { readonly capacity: "unbounded"; readonly replay?: number | undefined } | {
+      readonly capacity: number
+      readonly strategy?: "sliding" | "dropping" | "suspend" | undefined
+      readonly replay?: number | undefined
+    }
   ): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, Scope.Scope | R>
 } = internal.toPubSub
 

package/src/internal/stream.ts

@@ -2405,7 +2405,7 @@ export const either = <A, E, R>(self: Stream.Stream<A, E, R>): Stream.Stream<Eit
   pipe(self, map(Either.right), catchAll((error) => make(Either.left(error))))
 
 /** @internal */
-export const empty: Stream.Stream<never> = new StreamImpl(core.write(Chunk.empty()))
+export const empty: Stream.Stream<never> = new StreamImpl(core.void)
 
 /** @internal */
 export const ensuring = dual<

package/src/internal/version.ts

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