effect 3.14.21 → 3.15.0

package/src/internal/core-effect.ts

@@ -237,21 +237,36 @@ export const catchSomeDefect = dual<
 
 /* @internal */
 export const catchTag = dual<
-  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, A1, E1, R1>(
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>,
-  <A, E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
+  <E, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, A1, E1, R1>(
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>,
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
     self: Effect.Effect<A, E, R>,
-    k: K,
-    f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-  ) => Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1>
->(3, <A, E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
-  self: Effect.Effect<A, E, R>,
-  k: K,
-  f: (e: Extract<E, { _tag: K }>) => Effect.Effect<A1, E1, R1>
-): Effect.Effect<A | A1, Exclude<E, { _tag: K }> | E1, R | R1> =>
-  core.catchIf(self, Predicate.isTagged(k) as Predicate.Refinement<E, Extract<E, { _tag: K }>>, f) as any)
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ) => Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1>
+>(
+  (args: any) => core.isEffect(args[0]),
+  <A, E, R, const K extends Arr.NonEmptyReadonlyArray<E extends { _tag: string } ? E["_tag"] : never>, R1, E1, A1>(
+    self: Effect.Effect<A, E, R>,
+    ...args: [...tags: K, f: (e: Extract<NoInfer<E>, { _tag: K[number] }>) => Effect.Effect<A1, E1, R1>]
+  ): Effect.Effect<A | A1, Exclude<E, { _tag: K[number] }> | E1, R | R1> => {
+    const f = args[args.length - 1] as any
+    let predicate: Predicate.Predicate<E>
+    if (args.length === 2) {
+      predicate = Predicate.isTagged(args[0] as string)
+    } else {
+      predicate = (e) => {
+        const tag = Predicate.hasProperty(e, "_tag") ? e["_tag"] : undefined
+        if (!tag) return false
+        for (let i = 0; i < args.length - 1; i++) {
+          if (args[i] === tag) return true
+        }
+        return false
+      }
+    }
+    return core.catchIf(self, predicate as Predicate.Refinement<E, Extract<E, { _tag: K[number] }>>, f) as any
+  }
+)
 
 /** @internal */
 export const catchTags: {
@@ -505,24 +520,15 @@ export const filterMap = dual<
 
 /* @internal */
 export const filterOrDie: {
-  <A, B extends A>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orDieWith: (a: Types.NoInfer<A>) => unknown
+  <A, B extends A = A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
-  <A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orDieWith: (a: Types.NoInfer<A>) => unknown
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
-    orDieWith: (a: A) => unknown
+    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    orDieWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => unknown
   ): Effect.Effect<B, E, R>
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A>,
-    orDieWith: (a: A) => unknown
-  ): Effect.Effect<A, E, R>
 } = dual(
   3,
   <A, E, R>(
@@ -534,20 +540,15 @@ export const filterOrDie: {
 
 /* @internal */
 export const filterOrDieMessage: {
-  <A, B extends A>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
+  <A, B extends A = A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
     message: string
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E, R>
-  <A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    message: string
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-  <A, E, R, B extends A>(
+  <A, E, R, B extends A = A>(
     self: Effect.Effect<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
+    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
     message: string
   ): Effect.Effect<B, E, R>
-  <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R>
 } = dual(
   3,
   <A, E, R>(self: Effect.Effect<A, E, R>, predicate: Predicate.Predicate<A>, message: string): Effect.Effect<A, E, R> =>
@@ -556,24 +557,15 @@ export const filterOrDieMessage: {
 
 /* @internal */
 export const filterOrElse: {
-  <A, B extends A, C, E2, R2>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orElse: (a: Types.NoInfer<A>) => Effect.Effect<C, E2, R2>
+  <A, C, E2, R2, B extends A = A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+    orElse: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
-  <A, B, E2, R2>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orElse: (a: Types.NoInfer<A>) => Effect.Effect<B, E2, R2>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | B, E2 | E, R2 | R>
-  <A, E, R, B extends A, C, E2, R2>(
+  <A, E, R, C, E2, R2, B extends A = A>(
     self: Effect.Effect<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
-    orElse: (a: A) => Effect.Effect<C, E2, R2>
+    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    orElse: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
   ): Effect.Effect<B | C, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E | E2, R | R2>
 } = dual(3, <A, E, R, B, E2, R2>(
   self: Effect.Effect<A, E, R>,
   predicate: Predicate.Predicate<A>,
@@ -586,71 +578,43 @@ export const filterOrElse: {
 
 /** @internal */
 export const liftPredicate = dual<
-  {
-    <A, B extends A, E>(
-      refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): (a: A) => Effect.Effect<B, E>
-    <A, E>(
-      predicate: Predicate.Predicate<Types.NoInfer<A>>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): (a: A) => Effect.Effect<A, E>
-  },
-  {
-    <A, E, B extends A>(
-      self: A,
-      refinement: Predicate.Refinement<A, B>,
-      orFailWith: (a: A) => E
-    ): Effect.Effect<B, E>
-    <A, E>(
-      self: A,
-      predicate: Predicate.Predicate<Types.NoInfer<A>>,
-      orFailWith: (a: Types.NoInfer<A>) => E
-    ): Effect.Effect<A, E>
-  }
+  <T extends A, E, B extends T = T, A = T>(
+    predicate: Predicate.Refinement<T, B> | Predicate.Predicate<T>,
+    orFailWith: (a: Types.EqualsWith<T, B, A, Exclude<A, B>>) => E
+  ) => (a: A) => Effect.Effect<Types.EqualsWith<T, B, A, B>, E>,
+  <A, E, B extends A = A>(
+    self: A,
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ) => Effect.Effect<B, E>
 >(
   3,
-  <A, E>(
+  <A, E, B extends A = A>(
     self: A,
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orFailWith: (a: Types.NoInfer<A>) => E
-  ): Effect.Effect<A, E> => core.suspend(() => predicate(self) ? core.succeed(self) : core.fail(orFailWith(self)))
+    predicate: Predicate.Refinement<A, B> | Predicate.Predicate<A>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E
+  ): Effect.Effect<B, E> =>
+    core.suspend(() => predicate(self) ? core.succeed(self as B) : core.fail(orFailWith(self as any)))
 )
 
 /* @internal */
 export const filterOrFail: {
-  <A, B extends A, E2>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>,
-    orFailWith: (a: Types.NoInfer<A>) => E2
+  <A, E2, B extends A = A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>,
+    orFailWith: (a: Types.EqualsWith<A, B, Types.NoInfer<A>, Exclude<Types.NoInfer<A>, B>>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
-  <A, E2>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>,
-    orFailWith: (a: Types.NoInfer<A>) => E2
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
-  <A, B extends A>(
-    refinement: Predicate.Refinement<Types.NoInfer<A>, B>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
-  <A>(
-    predicate: Predicate.Predicate<Types.NoInfer<A>>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementException | E, R>
-  <A, E, R, B extends A, E2>(
+  <A, E, R, E2, B extends A = A>(
     self: Effect.Effect<A, E, R>,
-    refinement: Predicate.Refinement<A, B>,
-    orFailWith: (a: A) => E2
-  ): Effect.Effect<B, E | E2, R>
-  <A, E, R, E2>(
-    self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A>,
-    orFailWith: (a: A) => E2
-  ): Effect.Effect<A, E | E2, R>
-  <A, E, R, B extends A>(
+    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>,
+    orFailWith: (a: Types.EqualsWith<A, B, A, Exclude<A, B>>) => E2
+  ): Effect.Effect<B, E2 | E, R>
+  <A, B extends A = A>(
+    predicate: Predicate.Predicate<Types.NoInfer<A>> | Predicate.Refinement<Types.NoInfer<A>, B>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementException | E, R>
+  <A, E, R, B extends A = A>(
     self: Effect.Effect<A, E, R>,
-    refinement: Predicate.Refinement<A, B>
+    predicate: Predicate.Predicate<A> | Predicate.Refinement<A, B>
   ): Effect.Effect<B, E | Cause.NoSuchElementException, R>
-  <A, E, R>(
-    self: Effect.Effect<A, E, R>,
-    predicate: Predicate.Predicate<A>
-  ): Effect.Effect<A, E | Cause.NoSuchElementException, R>
 } = dual((args) => core.isEffect(args[0]), <A, E, R, E2>(
   self: Effect.Effect<A, E, R>,
   predicate: Predicate.Predicate<A>,

package/src/internal/stream.ts

@@ -7200,6 +7200,74 @@ export const transduce = dual<
   }
 )
 
+/** @internal */
+export const toAsyncIterableRuntime = dual<
+  <A, XR>(
+    runtime: Runtime.Runtime<XR>
+  ) => <E, R extends XR>(self: Stream.Stream<A, E, R>) => AsyncIterable<A>,
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>
+  ) => AsyncIterable<A>
+>(
+  (args) => isStream(args[0]),
+  <A, E, XR, R extends XR>(
+    self: Stream.Stream<A, E, R>,
+    runtime: Runtime.Runtime<XR>
+  ): AsyncIterable<A> => {
+    const runFork = Runtime.runFork(runtime)
+    return {
+      [Symbol.asyncIterator]() {
+        let currentResolve: ((value: IteratorResult<A>) => void) | undefined = undefined
+        let currentReject: ((reason: any) => void) | undefined = undefined
+        let fiber: Fiber.RuntimeFiber<void, E> | undefined = undefined
+        const latch = Effect.unsafeMakeLatch(false)
+        return {
+          next() {
+            if (!fiber) {
+              fiber = runFork(runForEach(self, (value) =>
+                latch.whenOpen(Effect.sync(() => {
+                  latch.unsafeClose()
+                  currentResolve!({ done: false, value })
+                  currentResolve = currentReject = undefined
+                }))))
+              fiber.addObserver((exit) => {
+                fiber = Effect.runFork(latch.whenOpen(Effect.sync(() => {
+                  if (exit._tag === "Failure") {
+                    currentReject!(Cause.squash(exit.cause))
+                  } else {
+                    currentResolve!({ done: true, value: void 0 })
+                  }
+                  currentResolve = currentReject = undefined
+                })))
+              })
+            }
+            return new Promise<IteratorResult<A>>((resolve, reject) => {
+              currentResolve = resolve
+              currentReject = reject
+              latch.unsafeOpen()
+            })
+          },
+          return() {
+            if (!fiber) return Promise.resolve({ done: true, value: void 0 })
+            return Effect.runPromise(Effect.as(Fiber.interrupt(fiber), { done: true, value: void 0 }))
+          }
+        }
+      }
+    }
+  }
+)
+
+/** @internal */
+export const toAsyncIterable = <A, E>(self: Stream.Stream<A, E>): AsyncIterable<A> =>
+  toAsyncIterableRuntime(self, Runtime.defaultRuntime)
+
+/** @internal */
+export const toAsyncIterableEffect = <A, E, R>(
+  self: Stream.Stream<A, E, R>
+): Effect.Effect<AsyncIterable<A>, never, R> =>
+  Effect.map(Effect.runtime<R>(), (runtime) => toAsyncIterableRuntime(self, runtime))
+
 /** @internal */
 export const unfold = <S, A>(s: S, f: (s: S) => Option.Option<readonly [A, S]>): Stream.Stream<A> =>
   unfoldChunk(s, (s) => pipe(f(s), Option.map(([a, s]) => [Chunk.of(a), s])))

package/src/internal/version.ts

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