effect 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/Effect.d.ts

@@ -4704,6 +4704,33 @@ export declare const catchIf: {
      */
     <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(self: Effect<A, E, R>, filter: Filter.OrPredicate<NoInfer<E>, Result>, f: (e: Filter.Pass<E, Result>) => Effect<A2, E2, R2>, orElse?: ((e: Filter.Fail<E, Result>) => Effect<A3, E3, R3>) | undefined): Effect<A | A2 | A3, E2 | E3, R | R2 | R3>;
 };
+/**
+ * Catches `NoSuchElementError` failures and converts them to `Option.none`.
+ *
+ * Success values become `Option.some`, `NoSuchElementError` becomes
+ * `Option.none`, and all other errors are preserved.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ *
+ * const some = Effect.fromNullishOr(1).pipe(Effect.catchNoSuchElement)
+ * const none = Effect.fromNullishOr(null).pipe(Effect.catchNoSuchElement)
+ *
+ * Effect.runPromise(some).then(console.log) // { _id: 'Option', _tag: 'Some', value: 1 }
+ * Effect.runPromise(none).then(console.log) // { _id: 'Option', _tag: 'None' }
+ * ```
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Effect.optionFromOptional`
+ *
+ * @since 2.0.0
+ * @category Error Handling
+ */
+export declare const catchNoSuchElement: <A, E, R>(self: Effect<A, E, R>) => Effect<Option<A>, Exclude<E, Cause.NoSuchElementError>, R>;
 /**
  * Recovers from specific failures based on a predicate.
  *
@@ -7433,6 +7460,32 @@ export declare const filter: {
      * @category Filtering
      */
     <A>(predicate: Predicate.Predicate<NoInfer<A>>): (elements: Iterable<A>) => Effect<Array<A>>;
+    /**
+     * Filters elements of an iterable using a predicate, refinement, effectful
+     * predicate, or `Filter.FilterEffect`.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Filter, Result } from "effect"
+     *
+     * // Sync predicate
+     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
+     *
+     * // Effectful predicate
+     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
+     *
+     * // FilterEffect
+     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
+     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
+     * )
+     * ```
+     *
+     * @since 2.0.0
+     * @category Filtering
+     */
+    <A, B, X>(filter: Filter.Filter<NoInfer<A>, B, X>, options?: {
+        readonly concurrency?: Concurrency | undefined;
+    }): (elements: Iterable<A>) => Effect<Array<B>>;
     /**
      * Filters elements of an iterable using a predicate, refinement, effectful
      * predicate, or `Filter.FilterEffect`.
@@ -7533,6 +7586,30 @@ export declare const filter: {
      * @category Filtering
      */
     <A>(elements: Iterable<A>, predicate: Predicate.Predicate<A>): Effect<Array<A>>;
+    /**
+     * Filters elements of an iterable using a predicate, refinement, effectful
+     * predicate, or `Filter.FilterEffect`.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Filter, Result } from "effect"
+     *
+     * // Sync predicate
+     * const evens = Effect.filter([1, 2, 3, 4], (n) => n % 2 === 0)
+     *
+     * // Effectful predicate
+     * const checked = Effect.filter([1, 2, 3], (n) => Effect.succeed(n > 1))
+     *
+     * // FilterEffect
+     * const mapped = Effect.filter([1, 2, 3, 4], (n) =>
+     *   Effect.succeed(n % 2 === 0 ? Result.succeed(n * 2) : Result.fail(n))
+     * )
+     * ```
+     *
+     * @since 2.0.0
+     * @category Filtering
+     */
+    <A, B, X>(elements: Iterable<A>, filter: Filter.Filter<NoInfer<A>, B, X>): Effect<Array<B>>;
     /**
      * Filters elements of an iterable using a predicate, refinement, effectful
      * predicate, or `Filter.FilterEffect`.