# Fx.catch

Recovers from the first typed failure of an Fx by running a fallback Fx.

## Signatures

```ts
export { catch_ as catch };
```

```ts
export declare const catch_: {
    <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
};
```

## Why

Typed failures are part of an Fx's public error channel, so callers often
need to replace a failed producer based on its first typed failure. This is
the push-stream counterpart of Effect's typed recovery.

## Ownership and lifetime

The source runs until it reports a Cause containing a `Fail`. The first typed
failure starts exactly one fallback and the entire original Cause is replaced,
including any defects or interrupts composed beside that Fail. A Cause with
no Fail passes through unchanged. Source values already delivered remain
delivered. The fallback's services become requirements of the returned Fx,
and external interruption stops whichever run is active.

## Examples

```ts
import { catch as recover } from "@typed/fx/Fx"
import { fail, succeed } from "@typed/fx/Fx"

const resilient = recover(fail("offline"), (error) => succeed(error.length))
```

Recovering a Fail discards its complete composite Cause
```ts
import { Cause } from "effect"
import { catch as recover } from "@typed/fx/Fx"
import { failCause, succeed } from "@typed/fx/Fx"

const composite = Cause.combine(Cause.fail("offline"), Cause.die("socket defect"))
const recovered = recover(failCause(composite), () => succeed("cached"))
```