Expressions for string-literal types

[stevekane]

TypeScript Version: 2.2

Code

/*
 We need to create enumerated literal types for this domain that look like the following:
 semantic: 'POSITION_1'
 semantic: 'NORMAL_32'
 semantic: 'TEXCOORD_6'

 it would be nice to capture these string literals via type-level expressions at compile-time.
*/
// current approach
type Semantic
  = 'POSITION_0'
  | 'POSITION_1',
  // ...
  | 'NORMAL_0',
  // ...

// proposed shorthand via type-level compile-time expressions
type Semantic
  = 'POSITION_' + ( '1' | '2' | '3' | '4' )
  | 'NORMAL_' + ( '1' | '2' | '3' | '4' )

// "final-form" ?
type Semantic
  = [ ...Array(10).keys() ].map(k => 'POSITION_' + k)
  = [ ...Array(10).keys() ].map(k => 'NORMAL_' + k)

Expected behavior:
Evaluating standard ES6 during compile-time would really open up some expressiveness in defining types like these. This sort of compile-time expression evaluation is spiritually similar to the enum expressions that are available today.

Actual behavior:

[RyanCavanaugh]

It'd be interesting to hear about more use cases like this so we can better understand the problem space.

[mhegazy]

is not that the same as #6579?

[yortus]

Ryan Cavanaugh (@RyanCavanaugh) some more uses cases:

• augmenting keys during type mapping

• accurate typing for bluebird.promisifyAll (also requested/mentioned here and here).

Compile-time concatenation of string literal types would be sufficient to address both of these use cases.

[stevekane]

I agree w/ Mohamed Hegazy (@mhegazy) that the mentioned request and mine are spiritually if not identically similar. The use case is essentially expressions whose range is the type you are attempting to define. I believe that for any candidate value or type instance your expression is statically run against it to determine if it is in the set or not? I may be stating the obvious ( or obviously wrong ? ) but that's how I see them being similar.

[mhegazy]

I would say #6579 is more feasible, since anything in the type system needs to be statically analyzable. regexp's have a better chance of being statically analyzable than a full expression level syntax.

[stevekane]

As a step, sure, but having the power of typescript at compilation-time would really be a tremendous boon to flexibility.

[mhegazy]

types are used as inference source/target and it becomes hard once you add a dynamic behavior to them.