Support for type guards

[florianbepunkt]

Not sure if this is an issue or by design. How do type guards work with fp-ts?

Given the interfaces A & B

interface A {
  type: string;
  amount: number;
}

interface B extends A {
  type: "payout";
  amount: number;
}

and a type guard

const isB = (t: A): t is B => t.type === "payout";

In the following function t is not typed as B

import { fold } from "fp-ts/boolean";

const example = (t: A) => {
  pipe(
    t,
    isB,
    fold(
      () => doSomethingWithA(t),
      () => doSomethingWithB(t) // t is not typed as B
    )
  );
};

[DenisFrezzato]

fold from boolean module works with booleans, so the type level information of a type guard is lost. What you're doing is pattern matching with a variable, so I suggest you to use libraries like ts-pattern or ts-adt.

[mlegenhausen]

[PatrykWalach]

using Either with ternary inside of chain will properly infer type for b

import * as E from "fp-ts/Either";

declare function isB(t: A | B): t is B;

const example = (t: A | B) => {
  pipe(
    E.right(t),
    E.chain((t) => (isB(t) ? E.right(t) : E.left(t))),
    E.map(doSomethingWithB),
    E.orElseW((b) => E.right(doSomethingWithA))
  );
};

it might be possible to augment fromPredicate so arg of onFalse is narrowed onFalse: (a: Exclude<A, B>) => E

const notPossible = (t: A | B) => {
  pipe(
    t,
    E.fromPredicate(isB, identity),
    E.map(doSomethingWithB),
    E.orElseW((b) => E.right(doSomethingWithA))
  );
};

export declare const fromPredicate: {
  <A, B extends A, E>(refinement: Refinement<A, B>, onFalse: (a: Exclude<A, B>) => E): (a: A) => Either<E, B>
}