effect 4.0.0-beta.17 → 4.0.0-beta.19

package/dist/Stream.js

@@ -12,7 +12,6 @@ import * as Equal from "./Equal.js";
 import * as ExecutionPlan from "./ExecutionPlan.js";
 import * as Exit from "./Exit.js";
 import * as Fiber from "./Fiber.js";
-import * as Filter from "./Filter.js";
 import { constant, constTrue, constVoid, dual, identity } from "./Function.js";
 import * as internalExecutionPlan from "./internal/executionPlan.js";
 import * as internal from "./internal/stream.js";
@@ -2808,19 +2807,22 @@ export const race = /*#__PURE__*/dual(2, (left, right) => raceAll(left, right));
  * @since 2.0.0
  * @category Filtering
  */
-export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArray(toChannel(self), filter)));
+export const filter = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArray(toChannel(self), predicate)));
 /**
- * Effectfully filters and maps elements in a single pass.
+ * Filters and maps stream elements in one pass using a `Filter`.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMap = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArray(toChannel(self), filter)));
+/**
+ * Effectfully filters elements in a single pass.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
- *
- * const filter = Filter.makeEffect((n: number) =>
- *   Effect.succeed(n > 2 ? Result.succeed(n + 1) : Result.fail(n))
- * )
+ * import { Console, Effect, Stream } from "effect"
  *
- * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect(filter))
+ * const stream = Stream.make(1, 2, 3, 4).pipe(Stream.filterEffect((n) => Effect.succeed(n > 2)))
  *
  * const program = Effect.gen(function*() {
  *   const result = yield* Stream.runCollect(stream)
@@ -2828,27 +2830,32 @@ export const filter = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel
  * })
  *
  * Effect.runPromise(program)
- * // Output: [ 4, 5 ]
+ * // Output: [ 3, 4 ]
  * ```
  *
  * @since 2.0.0
  * @category Filtering
  */
-export const filterEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterArrayEffect(toChannel(self), filter)));
+export const filterEffect = /*#__PURE__*/dual(2, (self, predicate) => fromChannel(Channel.filterArrayEffect(toChannel(self), predicate)));
 /**
- * Partitions a stream using a Filter and exposes passing and failing values as queues.
+ * Effectfully filters and maps elements in a single pass.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const filterMapEffect = /*#__PURE__*/dual(2, (self, filter) => fromChannel(Channel.filterMapArrayEffect(toChannel(self), filter)));
+/**
+ * Partitions a stream using a `Filter` and exposes passing and failing values as queues.
  *
  * Each queue fails with the stream error or `Cause.Done` when the source ends.
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Result, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [passes, fails] = yield* Stream.make(1, 2, 3, 4).pipe(
- *     Stream.partitionQueue(
- *       Filter.make((n) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n)))
- *     )
+ *     Stream.partitionQueue((n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
  *   )
  *
  *   const passValues = yield* Stream.fromQueue(passes).pipe(Stream.runCollect)
@@ -2876,11 +2883,19 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   const fails = yield* Queue.make({
     capacity
   });
-  const partitionArr = Arr.partition(filter);
   yield* Effect.gen(function* () {
     while (true) {
       const chunk = yield* pull;
-      const [excluded, satisfying] = partitionArr(chunk);
+      const excluded = [];
+      const satisfying = [];
+      for (let i = 0; i < chunk.length; i++) {
+        const result = filter(chunk[i]);
+        if (Result.isFailure(result)) {
+          excluded.push(result.failure);
+        } else {
+          satisfying.push(result.success);
+        }
+      }
       let passFiber = undefined;
       if (satisfying.length > 0) {
         const leftover = Queue.offerAllUnsafe(passes, satisfying);
@@ -2904,38 +2919,14 @@ export const partitionQueue = /*#__PURE__*/dual(args => isStream(args[0]), /*#__
   return [passes, fails];
 }));
 /**
- * Splits a stream using an effectful filter, producing pass and fail streams.
+ * Splits a stream using an effectful `Filter`, producing pass and fail streams.
  *
  * @since 4.0.0
  * @category Filtering
- *
- * @example
- * ```ts
- * import { Console, Effect, Result, Stream } from "effect"
- *
- * const program = Effect.scoped(
- *   Effect.gen(function*() {
- *     const [evens, odds] = yield* Stream.make(1, 2, 3, 4).pipe(
- *       Stream.partitionEffect((n) =>
- *         Effect.succeed(n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- *       )
- *     )
- *     const result = yield* Effect.all({
- *       evens: Stream.runCollect(evens),
- *       odds: Stream.runCollect(odds)
- *     })
- *     yield* Console.log(result)
- *   })
- * )
- *
- * Effect.runPromise(program)
- * // Output: { evens: [ 2, 4 ], odds: [ 1, 3 ] }
- * ```
  */
-export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(self.pipe(mapEffect(filter, options), partitionQueue(identity, options)), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
+export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(mapEffect(self, a => filter(a), options), result => result, options), ([passes, fails]) => [fromQueue(passes), fromQueue(fails)]));
 /**
- * Splits a stream into excluded and satisfying substreams using a predicate,
- * refinement, or Filter.
+ * Splits a stream into excluded and satisfying substreams using a `Filter`.
  *
  * The faster stream may advance up to `bufferSize` elements ahead of the slower
  * one.
@@ -2945,12 +2936,12 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  *
  * @example
  * ```ts
- * import { Console, Effect, Stream } from "effect"
+ * import { Console, Effect, Result, Stream } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   const [excluded, satisfying] = yield* Stream.partition(
  *     Stream.make(1, 2, 3, 4),
- *     (n) => n % 2 === 0
+ *     (n) => n % 2 === 0 ? Result.succeed(n) : Result.fail(n)
  *   )
  *   const left = yield* Stream.runCollect(excluded)
  *   const right = yield* Stream.runCollect(satisfying)
@@ -2961,9 +2952,9 @@ export const partitionEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * })
  * ```
  */
-export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(filter, {
+export const partition = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, options) => Effect.map(partitionQueue(self, filter, {
   capacity: options?.bufferSize ?? 16
-})(self), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
+}), ([passes, fails]) => [fromQueue(fails), fromQueue(passes)]));
 /**
  * Returns the specified stream if the given condition is satisfied, otherwise
  * returns an empty stream.
@@ -3219,7 +3210,7 @@ catch_ as catch };
  */
 export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Channel.tapError(f), fromChannel));
 /**
- * Recovers from errors that match a filter by switching to a recovery stream.
+ * Recovers from errors that match a predicate by switching to a recovery stream.
  *
  * When a failure matches the filter, the stream switches to the recovery
  * stream. Non-matching failures propagate downstream, so the error type is
@@ -3233,12 +3224,12 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  *
  * @example
  * ```ts
- * import { Console, Effect, Filter, Stream } from "effect"
+ * import { Console, Effect, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2).pipe(
  *   Stream.concat(Stream.fail(42)),
  *   Stream.catchIf(
- *     Filter.fromPredicate((error): error is 42 => error === 42),
+ *     (error): error is 42 => error === 42,
  *     () => Stream.make(999)
  *   )
  * )
@@ -3255,7 +3246,15 @@ export const tapError = /*#__PURE__*/dual(2, (self, f) => self.channel.pipe(Chan
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
+export const catchIf = /*#__PURE__*/dual(args => isStream(args[0]), (self, predicate, f, orElse) => fromChannel(Channel.catchIf(toChannel(self), predicate, e => f(e).channel, orElse && (e => orElse(e).channel))));
+/**
+ * Recovers from errors that match a `Filter` by switching to a recovery
+ * stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchFilter = /*#__PURE__*/dual(args => isStream(args[0]), (self, filter, f, orElse) => fromChannel(Channel.catchFilter(toChannel(self), filter, e => f(e).channel, orElse && (e => orElse(e).channel))));
 /**
  * Recovers from failures whose `_tag` matches the provided value by switching to
  * the stream returned by `f`.
@@ -3331,7 +3330,7 @@ export const catchTag = /*#__PURE__*/dual(args => isStream(args[0]), (self, k, f
  */
 export const catchTags = /*#__PURE__*/dual(args => isStream(args[0]), (self, cases, orElse) => {
   let keys;
-  return catchIf(self, e => {
+  return catchFilter(self, e => {
     keys ??= Object.keys(cases);
     return hasProperty(e, "_tag") && isString(e["_tag"]) && keys.includes(e["_tag"]) ? Result.succeed(e) : Result.fail(e);
   }, e => cases[e["_tag"]](e), orElse);
@@ -3487,7 +3486,15 @@ export const mapError = /*#__PURE__*/dual(2, (self, f) => fromChannel(Channel.ma
  * @since 4.0.0
  * @category Error Handling
  */
-export const catchCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseIf(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => fromChannel(Channel.catchCauseIf(self.channel, predicate, cause => f(cause).channel)));
+/**
+ * Recovers from stream failures by filtering the `Cause` and switching to a
+ * recovery stream.
+ *
+ * @since 4.0.0
+ * @category Error Handling
+ */
+export const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => fromChannel(Channel.catchCauseFilter(self.channel, filter, (failure, cause) => f(failure, cause).channel)));
 /**
  * Switches to a fallback stream if this stream is empty.
  *
@@ -3901,13 +3908,34 @@ export const takeUntilEffect = /*#__PURE__*/dual(args => isStream(args[0]), (sel
  * @since 2.0.0
  * @category Filtering
  */
-export const takeWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const takeWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let i = 0;
   let done = false;
   const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
     const out = [];
     for (let j = 0; j < chunk.length; j++) {
-      const result = Filter.apply(f, chunk[j], i++);
+      if (!predicate(chunk[j], i++)) {
+        done = true;
+        break;
+      }
+      out.push(chunk[j]);
+    }
+    return Arr.isReadonlyArrayNonEmpty(out) ? Effect.succeed(out) : done ? Cause.done() : pump;
+  });
+  return pump;
+})));
+/**
+ * Takes the longest initial prefix of elements that satisfy the filter.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const takeWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let done = false;
+  const pump = Effect.flatMap(Effect.suspend(() => done ? Cause.done() : pull), chunk => {
+    const out = [];
+    for (let j = 0; j < chunk.length; j++) {
+      const result = filter(chunk[j]);
       if (Result.isFailure(result)) {
         done = true;
         break;
@@ -4044,11 +4072,27 @@ export const dropUntilEffect = /*#__PURE__*/dual(2, (self, predicate) => drop(dr
  * @since 2.0.0
  * @category Filtering
  */
-export const dropWhile = /*#__PURE__*/dual(2, (self, f) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+export const dropWhile = /*#__PURE__*/dual(2, (self, predicate) => transformPull(self, (pull, _scope) => Effect.sync(() => {
   let dropping = true;
   let index = 0;
   const filtered = Effect.flatMap(pull, arr => {
-    const found = arr.findIndex(a => Result.isFailure(Filter.apply(f, a, index++)));
+    const found = arr.findIndex(a => !predicate(a, index++));
+    if (found === -1) return filtered;
+    dropping = false;
+    return Effect.succeed(arr.slice(found));
+  });
+  return Effect.suspend(() => dropping ? filtered : pull);
+})));
+/**
+ * Drops elements while the filter succeeds.
+ *
+ * @since 4.0.0
+ * @category Filtering
+ */
+export const dropWhileFilter = /*#__PURE__*/dual(2, (self, filter) => transformPull(self, (pull, _scope) => Effect.sync(() => {
+  let dropping = true;
+  const filtered = Effect.flatMap(pull, arr => {
+    const found = arr.findIndex(a => Result.isFailure(filter(a)));
     if (found === -1) return filtered;
     dropping = false;
     return Effect.succeed(arr.slice(found));