Make assert, truthy and falsy typeguards

[ZachHaber]

This will make ava easier to use with typescript and allow for removing redundant checks.

// with change
const actual = 3 as number | undefined;
if (t.assert(actual)) {
    // actual is `number` here
} else {
    // actual is `undefined` here
}

// before change
const actual = 3 as number | undefined;
t.assert(actual);
// Need a separate if branch from the assertion
if (actual) {
    // actual is `number` here
} else {
    // actual is `undefined` here
}

Since ava is a library and to reduce any type errors in existing projects, it's best to use the most exact approach to the typeguards as possible. For most use cases something akin to actual is NonNullable<T> is completely valid, but in this case it's very likely that things like boolean will be passed in.

Unfortunately typescript doesn't have convenient Falsy or Truthy utility types, so the best approach I've seen so far is to enumerate all possibilities (except NaN) to make up Falsy and then use that to Exclude Falsy types. NaN doesn't have it's own type, so the typeguard won't be able to differentiate between them no matter what we do.

[novemberborn]

Neat! @sindresorhus you OK reviewing?

[sindresorhus]

I don't think never is correct here.

[ZachHaber]

I don't think we can use anything besides never there and have it work correctly. The only things that typescript doesn't complain about using there are never and any or a subset of the T type. If you make it any then falsy(true) thinks it's falsy.

This is also the exact opposite condition I setup in truthy and assert:
actual is Exclude<T,Falsy> where Exclude is Exclude<T,U> = T extends U ? never : T becomes actual is T extends Falsy ? never : T which is the opposite condition of the falsy assertion.

I included the test-types with both the if case and the else case so you can see the types as they work. For further showcasing of the types, I setup a quick Playground example if you want to try changing what the assertions are.

Playing around with it, the current conditions don't work well for number and string primitives. Typescript seems to not recognize that 0 is a subset of number unless you use an as const expression with it. Similar results for an empty string ('') but even more wacky as '' will make typescript think it is truthy with a value of '', but '' as const makes typescript recognize it as falsy. Typescript also doesn't separate out 0 or '' from their primitive values.

So far, I think I'm having the most accurate approach using (playground link)

function falsy<T>(actual: T): actual is T extends Exclude<T, Falsy>? never : T {
    return !actual;
};
function truthy<T>(actual: T): actual is Exclude<T, Falsy> {
    return !!actual;
};

In which case the only remaining issue is that for a type of number or string, typescript doesn't think that they could ever be falsy.

[sindresorhus]

I don't think we can use anything besides never there and have it work correctly.

You're right. I read the signature incorrectly.

So far, I think I'm having the most accurate approach using (playground link)

👍

[ZachHaber]

With your suggestion of multiple overloads, that partially works, but runs into an issue where union types would fall back to the base behavior of the generic rather than the behavior of the overload.

I think I've cracked it for falsy, but I can't get the same to work for truthy as Typescript has no way to just invert a type. playground - As you can see from the screenshot, falsy works great, but truthy is missing 0 in the else clause, and I don't think there's really anything we can do about it...

type FalsyValue = false | 0 | 0n | '' | null | undefined;
type Falsy<T> = T extends Exclude<T, FalsyValue> ? (T extends number | string | bigint ? T & FalsyValue : never) : T;

function falsy<T>(actual: T): actual is Falsy<T> {
    return !actual;
};
function truthy<T>(actual: T): actual is T extends Falsy<T> ? never : T {
    return !!actual;
};

[sindresorhus]

This looks good 👍

[sindresorhus]

but truthy is missing 0 in the else clause, and I don't think there's really anything we can do about it...

I would mention this in the doc comments.

[sindresorhus]

Does it work to have specific overloads?

Suggested change

	<T>(actual: T, message?: string): actual is T extends Falsy ? T :never;
	(actual: 0): true;
	(actual: ''): true;
	<T>(actual: T, message?: string): actual is T extends Falsy ? T :never;

[sindresorhus]

I don't think we can use anything besides never there and have it work correctly.

You're right. I read the signature incorrectly.

So far, I think I'm having the most accurate approach using (playground link)

👍

[sindresorhus]

Suggested change

	<T>(actual: T, message?: string): actual is T extends Falsy ? T :never;
	<T>(actual: T, message?: string): actual is T extends Falsy ? T : never;

[ZachHaber]

I gave it my best shot for a reasonably concise note about the type issue for truthy/assert. The nice thing about the issues being where they are is that if they are reaching that issue, then that means the test failed anyway... 🙃