# filterInputEffect

Effectfully decides whether each successful input reaches the Sink.

Calling `onSuccess(value)` invokes `f(value)` immediately to construct the
predicate Effect; allocation and throws happen before an acknowledgment is
returned. Running the acknowledgment later executes that Effect in the caller's
fiber. `true` forwards one value, `false` none, and failure sends its Cause to
the Sink failure callback. Calls are not serialized; the producer controls
order and concurrency. Output behavior is unchanged.

## Signatures

```ts
export declare const filterInputEffect: {
    <A, R3, E>(f: (a: A) => Effect.Effect<boolean, E, R3>): <R, B, E2, R2>(push: Push<A, E, R, B, E2, R2>) => Push<A, E, R | R3, B, E2, R2>;
    <A, E, R, B, E2, R2, R3>(push: Push<A, E, R, B, E2, R2>, f: (a: A) => Effect.Effect<boolean, E, R3>): Push<A, E, R | R3, B, E2, R2>;
};
```

## Why

This supports authorization and service-backed eligibility checks directly at
the consumer boundary.

## Ownership and lifetime

Predicate Effect construction is eager; its execution and downstream callback
belong to the fiber that runs the returned acknowledgment, whose interruption
stops them. Predicate services join input `R`; typed `E` is consumed through
the Sink failure channel.

## Examples

```ts
import { Effect } from "effect"
import * as Fx from "@typed/fx/Fx"
import * as Push from "@typed/fx/Push"
import * as Sink from "@typed/fx/Sink"

const even = Push.filterInputEffect(
  Push.make(Sink.make(() => Effect.void, (_n: number) => Effect.void), Fx.empty),
  (n) => Effect.succeed(n % 2 === 0)
)
```