A negate function for type guards

foo.ts

type TypeGuard<T, U extends T> = (value: T) => value is U;

const negate = <T, U extends T>(
    typeGuard: TypeGuard<T, U>,
): TypeGuard<T, Exclude<T, U>> => (value): value is Exclude<T, U> =>
    typeGuard(value) === false;

// Example

const checkIsArray = <T>(value: T | any[]): value is any[] =>
    Array.isArray(value);
const checkIsNotArray = negate(checkIsArray);

declare const value: string | string[];
if (checkIsNotArray(value)) {
    value; // type here is `string` 🎉
}

Note: negate can only work if the input type guard is generic. It won't work in situations like this:

declare function isString(candidate: unknown): candidate is string;

const isNotString = negate(isString); // 🤷‍♂️

I think the issue there is that types cannot be excluded from unknown (in this case, Exclude<unknown, string> => unknown).

If you don't use unknown, it works:

declare function isString(candidate: string | number): candidate is string;

… but I guess that's not always an option! I guess Exclude only works for filtering union types, so the parameter has to be a union.