'!' shouldn't cast the type predicate to boolean

[kujon]

TypeScript can currently infer the remainder of the type that has been narrowed down, without any issues:

const isError = <T>(value: T | Error): value is Error => value instanceof Error;

const foo = (value: string | number | Error) => {
    if (isError(value)) {
        return value.message; // number, because of the type guard
    } else {
        return value.toString(); // Everything that is not a number.
    }
}

When ! operator is used on the type predicate, the compiler casts it to boolean immediately.

const isError = <T>(value: T | Error): value is Error => value instanceof Error;

type Something = number;
type SomethingElse = string;

const getSomething = (): Something | Error => 42;
const getSomethingElse = (): SomethingElse | Error => Math.random() > 0.5 ? 'foo' : Error('bugger');

const loadsOfData = [
    getSomething(),
    getSomethingElse()
];

const allThingsFailed = loadsOfData.filter(isError); // Error[]
const allThingsSuccessful = loadsOfData.filter(elem => !isError(elem)); // (string | number | Error)[]

Because of this, you can often end in situations, where you write a lot of unnecessary code:

const isError = <T>(value: T | Error): value is Error => value instanceof Error;
const isNotError = <T>(value: T | Error): value is T => !(value instanceof Error);

Given that there seems to be the way TS represents a concept of Type less AnotherType, I'd be grand if the bang operator on type predicates worked the same way.

[ghost]

Looks like a duplicate of #5101 (infer type predicate) and #18280 (negation types).
elem => !isError(elem) is a new function expression and has no explicit type declaration; and a type predicate is never inferred.
Since there's no way to represent a !Error type currently, you may have to write a filterNot or partition helper.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.