Improvement of type checking with array methods "some"/"every"

[Eugene-Musika]

Suggestion

🔍 Search Terms

some, every, type check for array values, Array.some(), Array.every()

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Add type guard checking for arrays.

📃 Motivating Example

const funcString = (a: string, b: string) => void;
const funcArray = (a: string[], b: string[]) => void;
const a: string | string[];
const b: string | string[];

if (Array.isArray(a) && Array.isArray(b)) {
	funcArray(a, b); // Works!
}

if ([a, b].every(Array.isArray)) {
	funcArray(a, b); // Error, type "string | string[]" can not be assigned for type "string[]"
}

if (typeof a === 'string' && typeof b === string)) {
	funcString(a, b); // Works!
}

if ([a, b].some(Array.isArray)) {
	return;
}
funcString(a, b); // Error, type "string | string[]" can not be assigned for type "string"

[RyanCavanaugh]

There'd be no way to do this except by hardcoding in detection of this exact pattern which, while cute, seems not prevalent enough in idiomatic JS to warrant the special case.

[Eugene-Musika]

@RyanCavanaugh sorry to hear that... But thanks for response! Perhaps then I should close the issue? Or should it remain open just in case?

[fatcerberus]

Interestingly, this also doesn't work:

const foo = [a, b] as const;
if (foo.every(Array.isArray)) {
	funcArray(foo[0], foo[1]);  // also error
}

While every does act as a type guard, it narrows it to <TupleType> & readonly any[][] which TS isn't smart enough to figure out means every element is an array. Removing the as const makes the error go away, but then it just "narrows" foo to any[][] which isn't very nice. ☹️

[typescript-bot]

This issue has been marked as "Too Complex" and has seen no recent activity. It has been automatically closed for house-keeping purposes.