Repository: TypeScript
Issue: Suggestion: Use typeof of declaration to define its type
Labels: Suggestion,Awaiting More Feedback

## Search Terms

- infer variable declaration
- typeof declaration
- using typeof on current expression
- apply modifier to declaration 
- generic declarations 

<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->

## Suggestion

<!-- A summary of what you'd like to see added or changed -->
I would like to use current declaration type for modifying type of variable, I'm creating, e.g.:
```typescript
const foo: Readonly<typeof var> = {
  bar: 'baz',
}
```
Maybe, there is a better syntax, that I couldn't think of.
## Use Cases

<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->

Typescript infer rather narrow type from variable declaration by default, which is a good thing. Sometimes we want to widen it, so it can fit into our interfaces. Mostly, it can be done by simply declaring a variable of certain type. But sometimes, it's useful to create some object along the way and somehow extend it's inferred type(some libraries can export very complicated generic types, so explicitly writing them could be a pain)

My specific use case was caused by reselect library, when I tried to reuse some selectors.

```typescript
// typeof selectors is (selector1ReturnType | selector2ReturnType | selector3ReturnType)[]
const selectors = [
  state => someSelector1(state),
  state => someSelector2(state),
  state => someSelector3(state),
]
```
But this array of selectors couldn't be used in `createSelector` function, cause it is expecting a tuple of selectors, to correctly infer type of arguments of selector function. I tried to use `as const` on my declaration, but it leaded to another error, cause createSelector expects a mutable tuple(it's only a type thing, not that it really mutates the selectors, but I'm afraid, this is a really common case in all library typings, not to mark it's arguments as readonly). I also found [a solution](https://gist.github.com/jcalz/381562d282ebaa9b41217d1b31e2c211) for creating tuples with function, but I don't like the fact, that static typings require some(even tiny) runtime overhead, also the solution is not generic.
For now, I ended up with something like this, using `Writable` type from [this](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html) docs:
```typescript
const selectorsConst = [
  state => someSelector1(state),
  state => someSelector2(state),
  state => someSelector3(state),
] as const
const selectors: Writable<typeof selectorsConst> = selectorsConst as any
```
But this solution is not pretty also. I wanted it to look like this:
```typescript
const selectorsConst: Writable<typeof var> = [
  state => someSelector1(state),
  state => someSelector2(state),
  state => someSelector3(state),
] as const
```
Or even something like this(but this is out of scope of this issue):
```typescript
const selectorsConst: Tuple<typeof var> = [
  state => someSelector1(state),
  state => someSelector2(state),
  state => someSelector3(state),
]
```
## Examples

<!-- Show how this would be used and what the behavior would be -->
Making a Readonly, Partial, Writable, etc. object:
```typescript
const foo: Partial<typeof var> = {
  bar: {
    baz: 'value',
  },
}
foo.bar.baz = 'new value' // Error: Object is possibly 'undefined'
```
Unifying object values types:
```typescript
interface MyClass {
  bar?: string;
  baz?: string;
}
const foo: {
  [key in keyof typeof var]: MyClass;
} = {
  firstEntry: { bar: 'bar' },
  secondEntry: { baz: 'baz' },
}
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).