Channel.catchIf — API

Channel.catchIfconsteffect/Channel.ts:4524

<
  OutErr,
  EB extends OutErr,
  OutElem1,
  OutErr1,
  OutDone1,
  InElem1,
  InErr1,
  InDone1,
  Env1,
  OutElem2 = Types.unassigned,
  OutErr2 = never,
  OutDone2 = never,
  InElem2 = unknown,
  InErr2 = unknown,
  InDone2 = unknown,
  Env2 = never
>(
  refinement: Predicate.Refinement<OutErr, EB>,
  f: (
    failure: EB
  ) => Channel<
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1
  >,
  orElse?:
    | ((
        failure: Exclude<OutErr, EB>
      ) => Channel<
        OutElem2,
        OutErr2,
        OutDone2,
        InElem2,
        InErr2,
        InDone2,
        Env2
      >)
    | undefined
): <OutElem, OutDone, InElem, InErr, InDone, Env>(
  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
) => Channel<
  OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
  | OutErr1
  | OutErr2
  | (OutElem2 extends Types.unassigned ? Exclude<OutErr, EB> : never),
  OutDone | OutDone1 | OutDone2,
  InElem & InElem1 & InElem2,
  InErr & InErr1 & InErr2,
  InDone & InDone1 & InDone2,
  Env | Env1 | Env2
>
<
  OutErr,
  OutElem1,
  OutErr1,
  OutDone1,
  InElem1,
  InErr1,
  InDone1,
  Env1,
  OutElem2 = Types.unassigned,
  OutErr2 = never,
  OutDone2 = never,
  InElem2 = unknown,
  InErr2 = unknown,
  InDone2 = unknown,
  Env2 = never
>(
  predicate: Predicate.Predicate<OutErr>,
  f: (
    failure: OutErr
  ) => Channel<
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1
  >,
  orElse?:
    | ((
        failure: OutErr
      ) => Channel<
        OutElem2,
        OutErr2,
        OutDone2,
        InElem2,
        InErr2,
        InDone2,
        Env2
      >)
    | undefined
): <OutElem, OutDone, InElem, InErr, InDone, Env>(
  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
) => Channel<
  OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
  | OutErr1
  | OutErr2
  | (OutElem2 extends Types.unassigned ? OutErr : never),
  OutDone | OutDone1 | OutDone2,
  InElem & InElem1 & InElem2,
  InErr & InErr1 & InErr2,
  InDone & InDone1 & InDone2,
  Env | Env1 | Env2
>
<
  OutElem,
  OutErr,
  OutDone,
  InElem,
  InErr,
  InDone,
  Env,
  EB extends OutErr,
  OutElem1,
  OutErr1,
  OutDone1,
  InElem1,
  InErr1,
  InDone1,
  Env1,
  OutElem2 = Types.unassigned,
  OutErr2 = never,
  OutDone2 = never,
  InElem2 = unknown,
  InErr2 = unknown,
  InDone2 = unknown,
  Env2 = never
>(
  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
  refinement: Predicate.Refinement<OutErr, EB>,
  f: (
    failure: EB
  ) => Channel<
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1
  >,
  orElse?:
    | ((
        failure: Exclude<OutErr, EB>
      ) => Channel<
        OutElem2,
        OutErr2,
        OutDone2,
        InElem2,
        InErr2,
        InDone2,
        Env2
      >)
    | undefined
): Channel<
  OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
  | OutErr1
  | OutErr2
  | (OutElem2 extends Types.unassigned ? Exclude<OutErr, EB> : never),
  OutDone | OutDone1 | OutDone2,
  InElem & InElem1 & InElem2,
  InErr & InErr1 & InErr2,
  InDone & InDone1 & InDone2,
  Env | Env1 | Env2
>
<
  OutElem,
  OutErr,
  OutDone,
  InElem,
  InErr,
  InDone,
  Env,
  OutElem1,
  OutErr1,
  OutDone1,
  InElem1,
  InErr1,
  InDone1,
  Env1,
  OutElem2 = Types.unassigned,
  OutErr2 = never,
  OutDone2 = never,
  InElem2 = unknown,
  InErr2 = unknown,
  InDone2 = unknown,
  Env2 = never
>(
  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
  predicate: Predicate.Predicate<OutErr>,
  f: (
    failure: OutErr
  ) => Channel<
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1
  >,
  orElse?:
    | ((
        failure: OutErr
      ) => Channel<
        OutElem2,
        OutErr2,
        OutDone2,
        InElem2,
        InErr2,
        InDone2,
        Env2
      >)
    | undefined
): Channel<
  OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
  | OutErr1
  | OutErr2
  | (OutElem2 extends Types.unassigned ? OutErr : never),
  OutDone | OutDone1 | OutDone2,
  InElem & InElem1 & InElem2,
  InErr & InErr1 & InErr2,
  InDone & InDone1 & InDone2,
  Env | Env1 | Env2
>

Recovers from typed channel errors that match a predicate or refinement.

When to use

Use to recover from typed channel errors when a predicate or refinement selects the failures that should switch to a recovery channel.

Details

Matching errors are handled by the recovery function. Non-matching errors are handled by orElse when provided. Without orElse, non-matching errors are re-failed.

error handlingcatch_catchFilter catchTag catchCauseFilter

Source effect/Channel.ts:4524221 lines

export const catchIf: {
  <
    OutErr,
    EB extends OutErr,
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1,
    OutElem2 = Types.unassigned,
    OutErr2 = never,
    OutDone2 = never,
    InElem2 = unknown,
    InErr2 = unknown,
    InDone2 = unknown,
    Env2 = never
  >(
    refinement: Predicate.Refinement<OutErr, EB>,
    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
    orElse?:
      | ((
        failure: Exclude<OutErr, EB>
      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
      | undefined
  ): <
    OutElem,
    OutDone,
    InElem,
    InErr,
    InDone,
    Env
  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
    OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
    OutErr1 | OutErr2 | (OutElem2 extends Types.unassigned ? Exclude<OutErr, EB> : never),
    OutDone | OutDone1 | OutDone2,
    InElem & InElem1 & InElem2,
    InErr & InErr1 & InErr2,
    InDone & InDone1 & InDone2,
    Env | Env1 | Env2
  >
  <
    OutErr,
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1,
    OutElem2 = Types.unassigned,
    OutErr2 = never,
    OutDone2 = never,
    InElem2 = unknown,
    InErr2 = unknown,
    InDone2 = unknown,
    Env2 = never
  >(
    predicate: Predicate.Predicate<OutErr>,
    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
    orElse?:
      | ((
        failure: OutErr
      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
      | undefined
  ): <
    OutElem,
    OutDone,
    InElem,
    InErr,
    InDone,
    Env
  >(self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>) => Channel<
    OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
    OutErr1 | OutErr2 | (OutElem2 extends Types.unassigned ? OutErr : never),
    OutDone | OutDone1 | OutDone2,
    InElem & InElem1 & InElem2,
    InErr & InErr1 & InErr2,
    InDone & InDone1 & InDone2,
    Env | Env1 | Env2
  >
  <
    OutElem,
    OutErr,
    OutDone,
    InElem,
    InErr,
    InDone,
    Env,
    EB extends OutErr,
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1,
    OutElem2 = Types.unassigned,
    OutErr2 = never,
    OutDone2 = never,
    InElem2 = unknown,
    InErr2 = unknown,
    InDone2 = unknown,
    Env2 = never
  >(
    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
    refinement: Predicate.Refinement<OutErr, EB>,
    f: (failure: EB) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
    orElse?:
      | ((
        failure: Exclude<OutErr, EB>
      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
      | undefined
  ): Channel<
    OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
    OutErr1 | OutErr2 | (OutElem2 extends Types.unassigned ? Exclude<OutErr, EB> : never),
    OutDone | OutDone1 | OutDone2,
    InElem & InElem1 & InElem2,
    InErr & InErr1 & InErr2,
    InDone & InDone1 & InDone2,
    Env | Env1 | Env2
  >
  <
    OutElem,
    OutErr,
    OutDone,
    InElem,
    InErr,
    InDone,
    Env,
    OutElem1,
    OutErr1,
    OutDone1,
    InElem1,
    InErr1,
    InDone1,
    Env1,
    OutElem2 = Types.unassigned,
    OutErr2 = never,
    OutDone2 = never,
    InElem2 = unknown,
    InErr2 = unknown,
    InDone2 = unknown,
    Env2 = never
  >(
    self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
    predicate: Predicate.Predicate<OutErr>,
    f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
    orElse?:
      | ((
        failure: OutErr
      ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
      | undefined
  ): Channel<
    OutElem | OutElem1 | Exclude<OutElem2, Types.unassigned>,
    OutErr1 | OutErr2 | (OutElem2 extends Types.unassigned ? OutErr : never),
    OutDone | OutDone1 | OutDone2,
    InElem & InElem1 & InElem2,
    InErr & InErr1 & InErr2,
    InDone & InDone1 & InDone2,
    Env | Env1 | Env2
  >
} = dual((args) => isChannel(args[0]), <
  OutElem,
  OutErr,
  OutDone,
  InElem,
  InErr,
  InDone,
  Env,
  OutElem1,
  OutErr1,
  OutDone1,
  InElem1,
  InErr1,
  InDone1,
  Env1,
  OutElem2 = never,
  OutErr2 = OutErr,
  OutDone2 = never,
  InElem2 = unknown,
  InErr2 = unknown,
  InDone2 = unknown,
  Env2 = never
>(
  self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
  predicate: Predicate.Predicate<OutErr>,
  f: (failure: OutErr) => Channel<OutElem1, OutErr1, OutDone1, InElem1, InErr1, InDone1, Env1>,
  orElse?:
    | ((
      failure: OutErr
    ) => Channel<OutElem2, OutErr2, OutDone2, InElem2, InErr2, InDone2, Env2>)
    | undefined
): Channel<
  OutElem | OutElem1 | OutElem2,
  OutErr1 | OutErr2,
  OutDone | OutDone1 | OutDone2,
  InElem & InElem1 & InElem2,
  InErr & InErr1 & InErr2,
  InDone & InDone1 & InDone2,
  Env | Env1 | Env2
> =>
  catch_(
    self,
    (err): Channel<
      OutElem1 | OutElem2,
      OutErr1 | OutErr2,
      OutDone1 | OutDone2,
      InElem1 & InElem2,
      InErr1 & InErr2,
      InDone1 & InDone2,
      Env1 | Env2
    > => {
      return predicate(err)
        ? f(err)
        : orElse
        ? orElse(err)
        : fail(err as any) as any
    }
  ))

Referenced by 2 symbols

Channel.catchTag Stream.catchIf