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

package/src/Option.ts

@@ -31,7 +31,7 @@
  * **Gotchas**
  *
  * - `Option.some(null)` is a valid `Some`; use {@link fromNullishOr} to treat `null`/`undefined` as `None`
- * - {@link filterMap} is an alias for {@link flatMap}
+ * - {@link filterMap} uses a `Filter` callback that returns `Result`
  * - {@link getOrThrow} throws a generic `Error`; prefer {@link getOrThrowWith} for custom errors
  * - `None` is a singleton; compare with {@link isNone}, not `===`
  * - When yielded in `Effect.gen`, a `None` becomes a `NoSuchElementError` defect
@@ -77,6 +77,7 @@ import * as Combiner from "./Combiner.ts"
 import type { EffectIterator, Yieldable } from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import * as Equivalence from "./Equivalence.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constNull, constUndefined, dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
@@ -3441,79 +3442,88 @@ export const partitionMap: {
   return result.isFailure(e) ? [some(e.failure), none()] : [none(), some(e.success)]
 })
 
-// TODO(4.0): remove?
 /**
- * Alias of {@link flatMap}. Applies a function returning `Option` to the value
- * inside a `Some`, flattening the result.
+ * Transforms and filters an `Option` using a `Filter` callback.
+ *
+ * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+ * value, while `Result.fail` discards it.
  *
  * **Example** (Filtering and transforming)
  *
  * ```ts
  * import { Option } from "effect"
+ * import * as Result from "effect/Result"
  *
  * console.log(Option.filterMap(
  *   Option.some(2),
- *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+ *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
  * ))
  * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
  * ```
  *
- * @see {@link flatMap} (canonical)
  * @see {@link filter} for predicate-based filtering
  *
  * @category Filtering
  * @since 2.0.0
  */
 export const filterMap: {
-  // TODO(4.0): remove?
   /**
-   * Alias of {@link flatMap}. Applies a function returning `Option` to the value
-   * inside a `Some`, flattening the result.
+   * Transforms and filters an `Option` using a `Filter` callback.
+   *
+   * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+   * value, while `Result.fail` discards it.
    *
    * **Example** (Filtering and transforming)
    *
    * ```ts
    * import { Option } from "effect"
+   * import * as Result from "effect/Result"
    *
    * console.log(Option.filterMap(
    *   Option.some(2),
-   *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+   *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
    * ))
    * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
    * ```
    *
-   * @see {@link flatMap} (canonical)
    * @see {@link filter} for predicate-based filtering
    *
    * @category Filtering
    * @since 2.0.0
    */
-  <A, B>(f: (a: A) => Option<B>): (self: Option<A>) => Option<B>
-  // TODO(4.0): remove?
+  <A, B, X>(f: Filter.Filter<A, B, X>): (self: Option<A>) => Option<B>
   /**
-   * Alias of {@link flatMap}. Applies a function returning `Option` to the value
-   * inside a `Some`, flattening the result.
+   * Transforms and filters an `Option` using a `Filter` callback.
+   *
+   * The callback returns a `Result`: `Result.succeed` keeps and transforms the
+   * value, while `Result.fail` discards it.
    *
    * **Example** (Filtering and transforming)
    *
    * ```ts
    * import { Option } from "effect"
+   * import * as Result from "effect/Result"
    *
    * console.log(Option.filterMap(
    *   Option.some(2),
-   *   (n) => (n % 2 === 0 ? Option.some(`Even: ${n}`) : Option.none())
+   *   (n) => (n % 2 === 0 ? Result.succeed(`Even: ${n}`) : Result.failVoid)
    * ))
    * // Output: { _id: 'Option', _tag: 'Some', value: 'Even: 2' }
    * ```
    *
-   * @see {@link flatMap} (canonical)
    * @see {@link filter} for predicate-based filtering
    *
    * @category Filtering
    * @since 2.0.0
    */
-  <A, B>(self: Option<A>, f: (a: A) => Option<B>): Option<B>
-} = flatMap
+  <A, B, X>(self: Option<A>, f: Filter.Filter<A, B, X>): Option<B>
+} = dual(2, <A, B, X>(self: Option<A>, f: Filter.Filter<A, B, X>): Option<B> => {
+  if (isNone(self)) {
+    return none()
+  }
+  const next = f(self.value)
+  return result.isSuccess(next) ? some(next.success) : none()
+})
 
 /**
  * Filters an `Option` using a predicate. Returns `None` if the predicate is
@@ -3723,7 +3733,7 @@ export const filter: {
 } = dual(
   2,
   <A>(self: Option<A>, predicate: Predicate<A>): Option<A> =>
-    filterMap(self, (b) => (predicate(b) ? option.some(b) : option.none))
+    isNone(self) ? none() : predicate(self.value) ? some(self.value) : none()
 )
 
 /**

package/src/Pull.ts

@@ -95,7 +95,7 @@ export const catchDone: {
   effect: Effect<A, E, R>,
   f: (leftover: Cause.Done.Extract<E>) => Effect<A2, E2, R2>
 ): Effect<A | A2, ExcludeDone<E> | E2, R | R2> =>
-  internalEffect.catchCauseIf(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
+  internalEffect.catchCauseFilter(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
 
 /**
  * Checks if a Cause contains any done errors.

package/src/Record.ts

@@ -7,6 +7,7 @@
 import type * as Combiner from "./Combiner.ts"
 import * as Equal from "./Equal.ts"
 import type { Equivalence } from "./Equivalence.ts"
+import type * as Filter from "./Filter.ts"
 import { dual, identity } from "./Function.ts"
 import type { TypeLambda } from "./HKT.ts"
 import * as Option from "./Option.ts"
@@ -1002,16 +1003,16 @@ export const mapEntries: {
 )
 
 /**
- * Transforms a record into a record by applying the function `f` to each key and value in the original record.
- * If the function returns `Some`, the key-value pair is included in the output record.
+ * Transforms a record by applying the function `f` to each key and value in the original record.
+ * If the function succeeds, the key-value pair is included in the output record.
  *
  * @example
  * ```ts
- * import { Option, Record } from "effect"
+ * import { Record, Result } from "effect"
  * import * as assert from "node:assert"
  *
  * const x = { a: 1, b: 2, c: 3 }
- * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+ * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
  * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
  * ```
  *
@@ -1020,52 +1021,52 @@ export const mapEntries: {
  */
 export const filterMap: {
   /**
-   * Transforms a record into a record by applying the function `f` to each key and value in the original record.
-   * If the function returns `Some`, the key-value pair is included in the output record.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B>(f: (a: A, key: K) => Option.Option<B>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(f: Filter.Filter<A, B, X, [key: K]>): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   /**
-   * Transforms a record into a record by applying the function `f` to each key and value in the original record.
-   * If the function returns `Some`, the key-value pair is included in the output record.
+   * Transforms a record by applying the function `f` to each key and value in the original record.
+   * If the function succeeds, the key-value pair is included in the output record.
    *
    * @example
    * ```ts
-   * import { Option, Record } from "effect"
+   * import { Record, Result } from "effect"
    * import * as assert from "node:assert"
    *
    * const x = { a: 1, b: 2, c: 3 }
-   * const f = (a: number, key: string) => a > 2 ? Option.some(a * 2) : Option.none()
+   * const f = (a: number, key: string) => a > 2 ? Result.succeed(a * 2) : Result.failVoid
    * assert.deepStrictEqual(Record.filterMap(x, f), { c: 6 })
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B, X>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, B, X, [key: K]>): Record<ReadonlyRecord.NonLiteralKey<K>, B>
 } = dual(
   2,
-  <K extends string, A, B>(
+  <K extends string, A, B, X>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Option.Option<B>
+    f: Filter.Filter<A, B, X, [key: K]>
   ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
     const out: Record<string, B> = empty()
     for (const key of keys(self)) {
-      const o = f(self[key], key)
-      if (Option.isSome(o)) {
-        out[key] = o.value
+      const result = f(self[key], key)
+      if (R.isSuccess(result)) {
+        out[key] = result.success
       }
     }
     return out
@@ -1187,9 +1188,18 @@ export const filter: {
  */
 export const getSomes: <K extends string, A>(
   self: ReadonlyRecord<K, Option.Option<A>>
-) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = filterMap(
-  identity
-)
+) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = <K extends string, A>(
+  self: ReadonlyRecord<K, Option.Option<A>>
+): Record<ReadonlyRecord.NonLiteralKey<K>, A> => {
+  const out: Record<string, A> = empty()
+  for (const key of keys(self)) {
+    const option = self[key]
+    if (Option.isSome(option)) {
+      out[key] = option.value
+    }
+  }
+  return out
+}
 
 /**
  * Given a record with `Result` values, returns a new record containing only the `Err` values, preserving the original keys.
@@ -1262,7 +1272,7 @@ export const getSuccesses = <K extends string, A, E>(
 }
 
 /**
- * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+ * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
  *
  * @example
  * ```ts
@@ -1271,15 +1281,15 @@ export const getSuccesses = <K extends string, A, E>(
  *
  * const x = { a: 1, b: 2, c: 3 }
  * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
- * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+ * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
  * ```
  *
  * @category filtering
  * @since 2.0.0
  */
-export const partitionMap: {
+export const partition: {
   /**
-   * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+   * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1288,17 +1298,17 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(f: (a: A, key: K) => Result<C, B>): (
+  <K extends string, A, B, C>(f: Filter.Filter<A, C, B, [key: K]>): (
     self: ReadonlyRecord<K, A>
   ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   /**
-   * Partitions the elements of a record into two groups: those that match a predicate, and those that don't.
+   * Partitions the elements of a record into two groups: those that match a filter, and those that don't.
    *
    * @example
    * ```ts
@@ -1307,18 +1317,18 @@ export const partitionMap: {
    *
    * const x = { a: 1, b: 2, c: 3 }
    * const f = (n: number) => (n % 2 === 0 ? Result.succeed(n) : Result.fail(n))
-   * assert.deepStrictEqual(Record.partitionMap(x, f), [{ a: 1, c: 3 }, { b: 2 }])
+   * assert.deepStrictEqual(Record.partition(x, f), [{ a: 1, c: 3 }, { b: 2 }])
    * ```
    *
    * @category filtering
    * @since 2.0.0
    */
-  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: (a: A, key: K) => Result<C, B>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
+  <K extends string, A, B, C>(self: ReadonlyRecord<K, A>, f: Filter.Filter<A, C, B, [key: K]>): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
   <K extends string, A, B, C>(
     self: ReadonlyRecord<K, A>,
-    f: (a: A, key: K) => Result<C, B>
+    f: Filter.Filter<A, C, B, [key: K]>
   ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>] => {
     const left: Record<string, B> = empty()
     const right: Record<string, C> = empty()
@@ -1354,126 +1364,7 @@ export const partitionMap: {
  */
 export const separate: <K extends string, A, B>(
   self: ReadonlyRecord<K, Result<B, A>>
-) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partitionMap(identity)
-
-/**
- * Partitions a record into two separate records based on the result of a predicate function.
- *
- * @example
- * ```ts
- * import { Record } from "effect"
- * import * as assert from "node:assert"
- *
- * assert.deepStrictEqual(
- *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
- *   [{ a: 1 }, { b: 3 }]
- * )
- * ```
- *
- * @category filtering
- * @since 2.0.0
- */
-export const partition: {
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
-    self: ReadonlyRecord<K, A>
-  ) => [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A>(predicate: (a: NoInfer<A>, key: K) => boolean): (
-    self: ReadonlyRecord<K, A>
-  ) => [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A, B extends A>(self: ReadonlyRecord<K, A>, refinement: (a: A, key: K) => a is B): [
-    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
-    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
-  ]
-  /**
-   * Partitions a record into two separate records based on the result of a predicate function.
-   *
-   * @example
-   * ```ts
-   * import { Record } from "effect"
-   * import * as assert from "node:assert"
-   *
-   * assert.deepStrictEqual(
-   *   Record.partition({ a: 1, b: 3 }, (n) => n > 2),
-   *   [{ a: 1 }, { b: 3 }]
-   * )
-   * ```
-   *
-   * @category filtering
-   * @since 2.0.0
-   */
-  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (a: A, key: K) => boolean): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
-} = dual(
-  2,
-  <K extends string, A>(
-    self: ReadonlyRecord<K, A>,
-    predicate: (a: A, key: K) => boolean
-  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>] => {
-    const left: Record<string, A> = empty()
-    const right: Record<string, A> = empty()
-    for (const key of keys(self)) {
-      if (predicate(self[key], key)) {
-        right[key] = self[key]
-      } else {
-        left[key] = self[key]
-      }
-    }
-    return [left, right]
-  }
-)
+) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partition(identity)
 
 /**
  * Retrieve the keys of a given record as an array.

package/src/Sink.ts

@@ -9,7 +9,7 @@ import * as Clock from "./Clock.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
-import * as Filter from "./Filter.ts"
+import type * as Filter from "./Filter.ts"
 import type { LazyArg } from "./Function.ts"
 import { constant, constFalse, constTrue, constVoid, dual, identity, pipe } from "./Function.ts"
 import * as internalStream from "./internal/stream.ts"
@@ -1454,18 +1454,40 @@ export const takeWhile: {
    * @category constructors
    */
   <In>(predicate: Predicate<In>): Sink<Array<In>, In, In>
-  /**
-   * @since 4.0.0
-   * @category constructors
-   */
-  <In, Out, X>(filter: Filter.Filter<In, Out, X>): Sink<Array<Out>, In, In>
-} = <In>(filter: Filter.Filter<In, any, any> | Predicate<In>): Sink<Array<any>, In, In> =>
+} = <In>(predicate: Predicate<In>): Sink<Array<In>, In, In> =>
   fromTransform((upstream) => {
-    const out = Arr.empty<any>()
+    const out = Arr.empty<In>()
     return upstream.pipe(
       Effect.flatMap((arr) => {
         for (let i = 0; i < arr.length; i++) {
-          const result = Filter.apply(filter as any, arr[i])
+          if (!predicate(arr[i])) {
+            const leftover: Arr.NonEmptyReadonlyArray<In> | undefined = (i + 1) < arr.length
+              ? arr.slice(i + 1) as any
+              : undefined
+            return Cause.done([out, leftover] as const)
+          }
+          out.push(arr[i])
+        }
+        return Effect.void
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone((end) => Effect.succeed<End<Array<In>, In>>(end ?? [out]))
+    )
+  })
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const takeWhileFilter = <In, Out, X>(
+  filter: Filter.Filter<In, Out, X>
+): Sink<Array<Out>, In, In> =>
+  fromTransform((upstream) => {
+    const out = Arr.empty<Out>()
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        for (let i = 0; i < arr.length; i++) {
+          const result = filter(arr[i])
           if (Result.isFailure(result)) {
             const leftover: Arr.NonEmptyReadonlyArray<In> | undefined = (i + 1) < arr.length
               ? arr.slice(i + 1) as any
@@ -1477,7 +1499,7 @@ export const takeWhile: {
         return Effect.void
       }),
       Effect.forever({ disableYield: true }),
-      Pull.catchDone((end) => Effect.succeed<End<Array<any>, In>>(end ?? [out]))
+      Pull.catchDone((end) => Effect.succeed<End<Array<Out>, In>>(end ?? [out]))
     )
   })
 
@@ -1491,27 +1513,57 @@ export const takeWhileEffect: {
    * @category constructors
    */
   <In, E, R>(predicate: (input: In) => Effect.Effect<boolean, E, R>): Sink<Array<In>, In, In, E, R>
-  /**
-   * @since 4.0.0
-   * @category constructors
-   */
-  <In, Out, X, E, R>(filter: Filter.FilterEffect<In, Out, X, E, R>): Sink<Array<Out>, In, In, E, R>
-} = <In, Out, X, E, R>(
-  filter: Filter.FilterEffect<In, Out, X, E, R> | ((input: In) => Effect.Effect<boolean, E, R>)
+} = <In, E, R>(
+  predicate: (input: In) => Effect.Effect<boolean, E, R>
+): Sink<Array<In>, In, In, E, R> =>
+  fromTransform((upstream) => {
+    const out = Arr.empty<In>()
+    let leftover: Arr.NonEmptyReadonlyArray<In> | undefined = undefined
+    return upstream.pipe(
+      Effect.flatMap((arr) => {
+        let i = 0
+        return Effect.whileLoop({
+          while: () => i < arr.length,
+          body: constant(Effect.flatMap(
+            Effect.suspend(() => {
+              const input = arr[i++]
+              return Effect.map(predicate(input), (passes) => [input, passes] as const)
+            }),
+            ([input, passes]) => {
+              if (!passes) {
+                if (i < arr.length) {
+                  leftover = arr.slice(i) as any
+                }
+                return Cause.done()
+              }
+              out.push(input)
+              return Effect.void
+            }
+          )),
+          step: constVoid
+        })
+      }),
+      Effect.forever({ disableYield: true }),
+      Pull.catchDone(() => Effect.succeed([out, leftover] as const))
+    )
+  })
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const takeWhileFilterEffect = <In, Out, X, E, R>(
+  filter: Filter.FilterEffect<In, Out, X, E, R>
 ): Sink<Array<Out>, In, In, E, R> =>
   fromTransform((upstream) => {
-    const f: Filter.FilterEffect<In, any, any, E, R> = (input: In) =>
-      Effect.map((filter as any)(input), (b: any) =>
-        typeof b === "boolean" ? (b ? Result.succeed(input) : Result.fail(undefined)) : b)
     const out = Arr.empty<Out>()
     let leftover: Arr.NonEmptyReadonlyArray<In> | undefined = undefined
     return upstream.pipe(
       Effect.flatMap((arr) => {
         let i = 0
         return Effect.whileLoop({
-          while: () =>
-            i < arr.length,
-          body: constant(Effect.flatMap(Effect.suspend(() => f(arr[i++])), (result) => {
+          while: () => i < arr.length,
+          body: constant(Effect.flatMap(Effect.suspend(() => filter(arr[i++])), (result) => {
             if (Result.isFailure(result)) {
               if (i < arr.length) {
                 leftover = arr.slice(i) as any