Suggestion: Range as Number type

[streamich]

When defining a type one can specify multiple numbers separated by |.

type TTerminalColors = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;

Allow to specify number types as ranges, instead of listing each number:

type TTerminalColors = 0..15;
type TRgbColorComponent = 0..255;
type TUInt = 0..4294967295;

Maybe use .. for integers and ... for floats.

interface Math {
  random(): 0...1
}

type RandomDice = 1..6;

const roll: RandomDice = Math.floor(Math.random() * 6);
// Error: -------------------------^ Maybe use Math.ceil()?

[panuhorsmalahti]

This idea can be expanded to characters, e.g. "b".."d" would be "b" | "c" | "d". It would be easier to specify character sets.

[goodmind]

I think this can be expanded and use syntax like and semantics like Haskell ranges.

Syntax	Desugared
type U = (e1..e3)	type U = | e1 | e1+1 | e1+2 | ...e3 | The union is never if e1 > e3
type U2 = (e1, e2..e3)	type U2 = | e1 | e1+i | e1+2i | ...e3 |, where the increment, i, is e2-e1. If the increment is positive or zero, the union terminates when the next element would be greater than e3; the union is never if e1 > e3. If the increment is negative, the union terminates when the next element would be less than e3; the union is never if e1 < e3.

[streamich]

@panuhorsmalahti What if you specify "bb".."dd"?

[aluanhaddad]

@streamich

Maybe use .. for integers and ... for floats.

I really like the idea of generating integral types like this, but I don't see how floating point values could work.

[streamich]

@aluanhaddad Say probability:

type TProbability = 0.0...1.0;

[aluanhaddad]

@streamich so that type has a theoretically infinite number of possible inhabitants?

[jcready]

@aluanhaddad actually it would be far from infinite in IEEE floating point. It would have 1,065,353,217 inhabitants by my calculations.

[fatcerberus]

0.0...1.0? JS uses IEEE double, that's 53 bits of dynamic range. If that were to be supported, ranges would have to be a first class type, desugaring that to a union would be beyond impractical.

[aluanhaddad]

@jcready indeed but, as @fatcerberus points out, realizing it as a union type would be prohibitively expansive.

What I was getting at, in a roundabout manner, was that this would introduce some notion of discrete vs. continuous types into the language.

[streamich]

realizing it as a union type would be prohibitively expansive.

@aluanhaddad Yes, but even specifying an unsigned integer as a union would be very expensive:

type TUInt = 0..4294967295;

[RyanCavanaugh]

This really needs some compelling use cases, because the implementation of unions today is completely unsuited to realizing unions this large. Something that would happen if you wrote something like this

type UInt = 0..4294967295;
var x: UInt = ......;
if (x !== 4) {
  x;
}

would be the instantiation of the union type 0 | 1 | 2 | 3 | 5 | 6 | 7 | ... .

[jcready]

Perhaps it could only work against number literals. Any non-literal number values would have to be explicitly refined with greater/less than comparisons before being considered to inhabit the range. Integer ranges would also require an additional Number.isInteger() check. This should eliminate the need to generate actual union types.