Scoped types

[oliveryasuna]

🔍 Search Terms

scope scoped scopes type types

✅ Viability Checklist

• 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 isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

It would be great if you could scope types. Types could be scoped like everything else with { SCOPE }.

📃 Motivating Example

Code can be written more intentionally. If a type is meant to only be used within a specific function, for example, it should be defined in that function.

type User = {
  id: string
  name: string,
  lastLogin: Date
};

function getUser(id: number): User {
  type UserInDb = {
    id: number,
    name: string,
    lastLogin: number
  };

  const user: UserInDb = fetchUserById(id);

  return {
    id: user.id,
    name: user.name,
    lastLogin: new Date(user.lastLogin)
  };
}

💻 Use Cases

1. What do you want to use this for?

This would allow developer to write clearer and more intentional code. A scoped type would clearly demonstrate that it is only used within the scope it is defined.

3. What shortcomings exist with current approaches?

The language does not demonstrate how and where a type is used.

5. What workarounds are you using in the meantime?

There are no alternatives at the moment.

[fatcerberus]

I'm confused by the motivating example - surely the return type of fetchUserById is a type that's already accessible to you so defining the same type locally is redundant?

[xiBread]

Feel like this has been suggested before... If not then #7061 is related

[jcalz]

I'm confused. The function-local type works just fine. The only problems with this code seem to be that you have not declared fetchUserById(), and you're trying to assign a number to a string for some reason. What, specifically, is the problem we're trying to solve here?

[oliveryasuna]

I'm confused. The function-local type works just fine. The only problems with this code seem to be that you have not declared fetchUserById(), and you're trying to assign a number to a string for some reason. What, specifically, is the problem we're trying to solve here?

I suppose my example was a poor one. Though, we often write functions that use intermediate types different than the return type. Right now, you have to define those types on a module's top-level scope. Even if they are not exported, they are visible to the entire module. I am proposing the ability to define types with deeper scopes, such as a function's scope. This approach produces much more intentional code as it is clear where a type is used and for what it is used.

You may say that a better solution to "scope" types is by splitting a module into multiple modules and only defining the type in the necessary module. But should TypeScript, a language, be this opinionated?

[jcalz]

I suppose my example was a poor one

Could you edit the motivating example to include more motivation and fewer distractions?

I am proposing the ability to define types with deeper scopes, such as a function's scope.

Function-scoped types are already supported. Can you demonstrate otherwise? Or describe what about the current support is insufficient?

[RyanCavanaugh]

I am proposing the ability to define types with deeper scopes, such as a function's scope

Which you can, so what is this about? I don't see anything new, at all, being proposed here.