Primitive type implementation

[wangyanxing]

Primitive Type Implementation

We have been working on adding support for primitive types in TypeScript as part of a research project at the San Francisco State University. This issue documents our efforts and we would like to solicit feedback from the community. The following fork of the TypeScript repo contains a complete reference implementation of our proposal:

https://github.com/wangyanxing/TypeScript

The following Google Doc contains a formal specification of the syntax and semantics of primitive types in TypeScript:

https://docs.google.com/a/puder.org/document/d/120hs8AJ0-WGwHbvV7D3XOJ2b18ZceBvYjOlDcR1Dn_A/edit?usp=sharing

We have activated the commenting feature for the Google Doc. The following gives a quick overview of the changes we have made to the TypeScript language.

There are ten new primitive types in our implementation:
int, uint, i8, u8, i16, u16, i32, u32, float, double.

The value ranges of these types are documented in the Google Doc.

Here are some examples:

Variables and Arithmetic

The following code:

var var1 : u8 = 256;
var var2 : i8 = 200;
var var3 : u16 = 600000;
var var4 : i16 = 100000;
var var5 : int = 3.14;
var var6 : uint = var3 * 10000;
var var7 : double = 0.123456789;
var var8 : float = var7;
var var9 : u8[] = [var4,var5,var6];
var var10 : int = 3 / 4;
var var11 : int = 1 + 2;
var var12 : int = var5 + 2;

would emit:

var var1 = 256 & 255;
var var2 = (200 & 255) << 24 >> 24;
var var3 = 600000 & 65535;
var var4 = (100000 & 65535) << 16 >> 16;
var var5 = 3.14 | 0;
var var6 = var3 * 10000 >>> 0;
var var7 = 0.123456789;
var var8 = Math.fround(var7);
var var9 = [var4 & 255, var5 & 255, var6 & 255];
var var10 = 3 / 4 | 0;
var var11 = 1 + 2 | 0;
var var12 = var5 + 2 | 0;

Note: some platforms like node.js doesn’t support Math.fround() function. Our version of the TypeScript compiler would emit a compatibility version of that function in the generated code.

Functions

The following code:

function fun(x : i32) : u8 {
    x++;
    return x;
}
fun(255.9); // the function will return 0

would emit:

function fun(x) {
    x = x | 0;
    var _$0;
    (_$0 = x, x = x + 1 | 0, _$0);
    return x & 255;
}
fun(255.9);

The following code:

var func1 = (x:int) : u8 => { return x * 2; }
var func2 =function(x:int, y:int): u8 { return x+y };
func1(200.4);
func2(255.7, 1.9);

would emit:

var func1 = function (x) {
    x = x | 0;
    return x * 2 & 255;
};
var func2 = function (x, y) {
    y = y | 0;
    x = x | 0;
    return x + y & 255;
};
func1(200.4);
func2(255.7, 1.9);

The following code:

function fun_opt_arg(x? : int) : int {
    return x;
}

would raise an error since we forbid primitive type variables to be optional arguments:

error TS8001: Primitive type declaration 'x' cannot be optional.

Generics

The following code:

class GenericNumber<T> {
    add: (x: T, y: T) => T;
}

var geni8 = new GenericNumber<i8>();
geni8.add = function(x:i8, y:i8):i8 { return x + y; };

var genu8 = new GenericNumber<u8>();
genu8.add = function(x:u8, y:u8):u8 { return x + y; };

geni8.add(1.9, 2.9); // it will return 3
genu8.add(255, 1); // it will return 0

would emit:

var GenericNumber = (function () {
    function GenericNumber() {
    }
    return GenericNumber;
})();
var geni8 = new GenericNumber();
geni8.add = function (x, y) {
    y = (y & 255) << 24 >> 24;
    x = (x & 255) << 24 >> 24;
    return (x + y & 255) << 24 >> 24;
};
var genu8 = new GenericNumber();
genu8.add = function (x, y) {
    y = y & 255;
    x = x & 255;
    return x + y & 255;
};
geni8.add(1.9, 2.9); // it will return 3
genu8.add(255, 1); // it will return 0

[ivogabe]

Looks good, I have a few suggestions:

I think it should be disallowed to do an implicit dangerous type cast. i8 to int is safe, because we know that every number that fits in an i8 will also fit in an int. int to double is also safe. But a double to an int is not safe, because there are numbers that fit in a double but not in an int (like 8.5). C# disallows this. You need to do an explicit type cast.

I would also like to have a syntax for typecasts. Some proposals:

double d = 8.5;
int i;
i = int(d); // swift
i = (int) d; // C#
i = <int> d; // TypeScript casts

That would generate something like

i = d | 0;

Do you have a reason why you chose i8 instead of int8?

[wangyanxing]

Thanks for the comment. I've also read your proposal on issue #195 , your idea is very practical.

Since I'm a C++ programmer, I've accustomed to use such implicit type cast. Yeah it's really dangerous but sometimes useful. On the other hand, I got a lot of ideas from LLJS, they did implicit cast as well.

About i8, I use it just because it's short. Some old C++ programmers are very lazy to write more, like me. :)

[ivogabe]

I understand your laziness but when you're lazy you shouldn't use static typing. One of TypeScript's design goals is to "Statically identify constructs that are likely to be errors." Such casts are likely mistakes and can give unexpected behavior:

var x: int;
// Lots of code
x = 3.5;

The user might expect that x = 3.5, but x = 3.

Also, how does this work with unions? How does this compile:

var x: int | string;

x = 5;
x = "foo";

[joewood]

Interesting. Why not take this further and define the primitive types using custom ranges (subrange types), rather than a predefined set of types? Like Pascal, Ada, Modula-2 etc...
With typedef support the basic integer types from the spec could be defined, but using the subrange information more validation tests could be applied to the code at compile time.

[apuder]

The types are inspired by LLJS and can be mapped nicely to asm.js. Custom ranges are an interesting idea. As you pointed out, it would also require support for typedef that might open another can of worms. Lets see what other people have to say.

[saschanaz]

What would this emit?

var num = 512;
var u8array: u8[] = [];
u8array.push(num);

The current proposal seems to do nothing here. Would u8array.push(num % 255) be the result?

[wangyanxing]

@saschanaz

The document has been updated.

var num = 512;
var u8array: u8[] = [];
u8array.push(num);

will output:

var num = 512;
var u8array = [];
u8array.push(num & 255);

[wangyanxing]

@ivogabe
It seems type union is still a developing branch of TypeScript. We didn't take that much time to consider it. But the recent added tuple has been supported.
Thanks for reminder of type union, we are considering carefully. However, from my point of view, type union doesn't make sense for primitive types. For example:
If you have

var x: int | double;
x = 1.1; // what's the behavior of this statement?

int|string is ok but int|u8 or int|float is not a good idea because it's ambiguous.

[wangyanxing]

@ivogabe
For type casting, just forbid int to float is worth considering.
Currently my proposal is to introduce a "strict mode", if this flag has been turned on, type casting for primitive types will be forbidden.

Just a proposal.

[wangyanxing]

On the other hand, since our final goal is to support asm.js, a fixed-size array as well as the memory management based on such array is also under consideration. I'll update the document once the proposal has been decided.

[saschanaz]

The updated specification now forces the compiler to distinguish built-in functions from others, which can be dangerous when it miss one.

interface Array<T> {
    // New ES6 built-in method
    fill(value: T, start?: number, end?: number): void;
}
/*
if (Array.prototype.fill)
    Array.prototype.fill = ... (polyfill)
*/

var u8array: u8[] = new Array<u8>(5);
u8array.fill(1024); // What will our compiler do?

[wangyanxing]

yes it's right
so I don't distinguish built-in functions from others
just convert when every function call (with primitive type arguments).

(I'll update the document soon).

But actually I still need to convert the arguments inside the function if I plan to generate asm.js (ongoing).
asm.js specification needs such argument conversion in front of the function block, like.

function func(arg : int, ........) {
    "use asm";
    arg = arg | 0; // asm.js! convert again
}

func(x | 0, ........); // convert, it's general situation

The situation is subtle, maybe I'll do some detection when compiling. For example if generation asm.js flag is turned on, I'll do the conversion arg = arg | 0 inside the function.

Anyway, asm.js is a different story. If no asm.js codes generation, it's not necessary to convert arguments inside the function, only do it from caller side is enough.