Infer typeof self if unspecified on cast

Suggestion

🔍 Search Terms

• type casting
• implicit typing
• syntactic sugar

✅ 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

It would be a lot cleaner if when you cast a type to some other type (for example NonNullable) you don’t have to specify typeof self.

📃 Motivating Example

if you have an Array that could be undefined you can filter out undefined like so

const array = ["one", undefined, "two"].filter(Boolean);
console.log(array) // ["one", "two"]

but in this case the type would still be (string | undefined)[] so it would cause linting errors later in the code. While this may be specific to the .filter method, it may be unreasonable to expect all methods accurately account for type checks like this. So one easy way to fix this would just be to do

const arrayUndefined = ["one", undefined, "two"]

const array = arrayUndefined.filter(Boolean) as NonNullable<UnArrayify<typeof arrayUndefined>>

what I’m suggesting is that instead of requiring you do typeof arrayUndefined you can instead do an implicit cast to make the code cleaner

const arrayUndefined = ["one", undefined, "two"]

// it's implied that UnArrayify would be called with <typeof array.filter(Boolean)>
const array = arrayUndefined.filter(Boolean) as NonNullable<UnArrayify>

💻 Use Cases

I would like this because it would result in cleaner typing for unhandled edgecases in the typescript linter

[MartinJohns]

You can achieve something like that trivially using a helper function without weird and confusing type shenanigans:

function asMutable<T>(value: T): Mutable<T> { return value; }

const context = asMutable(await import("github")).context);

[MartinJohns]

What do you mean by type guard? Do you mind providing an example

function isNotUndefined<T>(value: T | undefined): value is T {
  return value !== undefined;
}

const array1 = ["one", undefined, "two"].filter(Boolean); // type is (string | undefined)[]
const array2 = ["one", undefined, "two"].filter(isNotUndefined); // type is string[]

No type-assertion needed. Every type-assertion is a potential issue, because you overwrite the type-system and tell the compiler “shh… trust me, it’s this type” (even if this may not be the case).