function interestingDifferenceInline(x?: number, y?: number) {
  if (x !== undefined && x > 12 && y !== undefined && y > 12) {
    // x and y correctly have type number here, undefined narrowed away.
    // however, my logic is duplicated.
    return x - y;
  } else {
    // x and y are not narrowed here, still have type undefined | number.
    return undefined;
  }
}

// I should be able to extract the duplicated logic into a function
// and get the same type narrowing
function interestingDifferenceExtracted(x?: number, y?: number) {
  if (isInteresting(x) && isInteresting(y)) {
    // TYPE ERROR: x and y should have type number here, but have number | undefined.
    return x - y;
  } else {
    return undefined;
  }
}

function isInteresting(x: number | undefined): boolean {
  // if this function returns true, x should be narrowed to number,
  // if this function returns false, it should not be narrowed at all.
  // We have implication in one direction, but not its inverse.
  return x !== undefined && x > 12;
}

// this is wrong:
function isInterestingIncorrectPredicate(x?: number): x is number {
  // this correctly narrows to number if we do if(isInterestingIncorrectPredicate(x)),
  // but incorrectly narrows to undefined if we do if(!isInterestingIncorrectPredicate(x))
  // type predicates are 'necessary and sufficient', but our condition is
  // 'sufficient but not necessary'. That is, we don't know that x is NOT a
  // number if this predicate returns false.
  return x !== undefined && x > 12;
}

// what we want is some kind of inverse predicate, something like:
// returning true gives us type information, returning false does not.
// function isInterestingDesired(x?: number): x is not undefined {
  // if this function returns true x is narrowed to number, excluding undefined.
  // if this function returns false nothing is narrowed.
// }