Snippets used in my talk “Who Guards the Type Guards?” (https://www.youtube.com/watch?v=StyKp5dgN_Y)

0. What are type guards.ts

/**
 * A.K.A. type guard
 */
type Refinement<T, U extends T> = (candidate: T) => candidate is U;

function isString(candidate: unknown): candidate is string {
  return typeof candidate === 'string';
}

1. Use cases.ts

interface Apple { species: 'Malus domestica' }
interface Cucumber { species: 'C. sativus' }

type Fruit = Apple | Cucumber;

/**
 * Mixed items.
 */
declare const basket: Fruit[];

/**
 * Apples only.
 */
let apples: Apple[];

apples = basket.filter((fruit): boolean => fruit.species === 'Malus domestica');
apples = basket.filter((fruit): fruit is Apple => fruit.species === 'Malus domestica');

2. The problem.ts

export function isString(candidate: unknown): candidate is string {
  return typeof candidate === 'number'; // 🤷‍♂️
}

3. Solution one.ts

import { some, none, getRefinement } from 'fp-ts/lib/Option'

const isString = getRefinement<unknown, string>(
  (candidate) => typeof candidate === 'string'
    ? some(candidate)
    : none
)

4. Solution two.ts

class Some<T> {
  constructor(readonly value: T) {}
}

class None {}

type Option<T> = Some<T> | None;

function getRefinement<T, U extends T>(getOption: (candidate: T) => Option<U>): Refinement<T, U> {
  return (candidate: T): candidate is U =>
    getOption(candidate) instanceof Some;
}

5. Composition.ts

import Refinement, { either } from 'refinements';

abstract class Fruit {
  readonly species: string;
}

class Orange extends Fruit {
  readonly species: 'orange';
}

class Mango extends Fruit {
  readonly species: 'mango';
}

const isOrange: Refinement<Fruit, Orange> = Refinement.create(
  fruit =>
    fruit instanceof Orange
      ? Refinement.hit(fruit)
      : Refinement.miss
);

const isMango: Refinement<Fruit, Mango> = Refinement.create(
  fruit =>
    fruit instanceof Mango
      ? Refinement.hit(fruit)
      : Refinement.miss
);

const isJuicy = either(isOrange, isMango)

6. Negation.ts

import Refinement, { not } from 'refinements';

type Stable = 'inherit' | 'initial' | 'revert' | 'unset';
type Prefixed = '-moz-initial';

type CSSProperty = Stable | Prefixed;

const isPrefixed = Refinement.create(
  (property: CSSProperty) =>
    property === '-moz-initial'
      ? Refinement.hit(property)
      : Refinement.miss
);

const isStandard = not(isPrefixed);