strongscript: concrete types for typescript
TRANSCRIPT
![Page 1: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/1.jpg)
StrongScript:concrete types for TypeScript
Jan VitekGregor Richards
and myself
1Monday 23 March 15
![Page 2: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/2.jpg)
StrongScript:...the language Andreas
has been dreaming about...
Jan VitekGregor Richards
and myself
2Monday 23 March 15
![Page 3: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/3.jpg)
Scripting languages are not statically typed
3Monday 23 March 15
![Page 4: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/4.jpg)
They are successful
4Monday 23 March 15
![Page 5: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/5.jpg)
Can we improve them?
5Monday 23 March 15
![Page 6: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/6.jpg)
optional type systems
Industry answer
Surprising properties: types do not affect execution types are unsound
Hack, Dart, TypeScript, …
Pragmatic benefits: IDE support
6Monday 23 March 15
![Page 7: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/7.jpg)
optional type systems
Industry answer
Surprising properties: types do not affect execution types are unsound
Hack, Dart, TypeScript, …
Pragmatic benefits: IDE support
20 m
illio
n lin
es o
f PH
P re
fact
ored
to u
se H
ack
at Fa
cebo
ok
6Monday 23 March 15
![Page 8: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/8.jpg)
optional type systems
Industry answer
Surprising properties: types do not affect execution types are unsound
Hack, Dart, TypeScript, …
Pragmatic benefits: IDE support
20 m
illio
n lin
es o
f PH
P re
fact
ored
to u
se H
ack
at Fa
cebo
ok
gradual type systems
Academia answer
Racket, StrongTalk, …
Types affect executionTypes are sound
Values are wrapped at dynamic/static boundaries:- statically-typed code can fail - runtime overhead
6Monday 23 March 15
![Page 9: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/9.jpg)
Why do I like types
2. In Java, at runtime x.f will always succeed if x is not null
3. In Java, x.f is compiled to a couple of machine instructions
1. Help with refactoring, IDE support, ...
7Monday 23 March 15
![Page 10: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/10.jpg)
Why do I like types
2. In Java, at runtime x.f will always succeed if x is not null
3. In Java, x.f is compiled to a couple of machine instructions
1. Help with refactoring, IDE support, ...
speed
safety
predictable execution time7Monday 23 March 15
![Page 11: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/11.jpg)
Why do I like types
2. In Java, at runtime x.f will always succeed if x is not null
3. In Java, x.f is compiled to a couple of machine instructions
both optional and gradual type system fall short
1. Help with refactoring, IDE support, ...
speed
safety
predictable execution time7Monday 23 March 15
![Page 12: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/12.jpg)
Allow programmers to chose:
lightweight type annotations should not introduce dynamic errors in well-tested dynamic programs
if programmers select more stringent checks, they should have the usual type-errors and improved performance properties.
Our plan
8Monday 23 March 15
![Page 13: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/13.jpg)
Background: TypeScript
9Monday 23 March 15
![Page 14: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/14.jpg)
TypeScript
• Types are hints to the programming environment, not to the code generator
• Enables some type-checking, support IDE features name completion, semi-automated refactorings
• Lack of type preservation seen as necessary tradeoff
• Support only a small subset of JavaScript idioms
• No attempt to provide guarantees on other dynamic behaviours classes, in
terfaces
and modules
10Monday 23 March 15
![Page 15: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/15.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
this code c
ompiles w
ith no w
arnings
11Monday 23 March 15
![Page 16: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/16.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
11Monday 23 March 15
![Page 17: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/17.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
interfaces declare properties and methodsextends has only documentation purposes
subtyping is structural
12Monday 23 March 15
![Page 18: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/18.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
both classes are subtype of the interfaces abovedist is overridden covariantly
13Monday 23 March 15
![Page 19: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/19.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
Implicit cast of Point to Pt, allowed by structural subtyping. pdist calls dist at static type Point, but is invoked with a CPoint: the compiler allows the call at runtime the access of p.color returns undefined.
14Monday 23 March 15
![Page 20: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/20.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
Any type can be converted implicitly to any. Any method can be invoked on an any reference. An any reference can be converted implicitly to any other type.
15Monday 23 March 15
![Page 21: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/21.jpg)
interface P { x: number; }interface T { y: number; }interface Pt extends P { y: number; dist(p: Pt); }
class Point { constructor (public x:number, public y:number){} dist(p: Point) { ... }}class CPoint extends Point { constructor (public color:String, x:number, y:number){ super(x,y); } dist(p: CPoint) { ...p.color... } }
var o:Pt = new Point(0,0);var c:CPoint = new CPoint("Red",1,1);function pdist(x:Point, y:Point) { x.dist(y); } pdist( c, o ); var q:any = new CPoint("Red",1,1); var c = q.dist( o );var b = o.dist( q );
function getc(x:CPoint) { return x.color }; getc( <CPoint>o );
An unchecked explicit cast.
16Monday 23 March 15
![Page 22: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/22.jpg)
Summary + plan
17Monday 23 March 15
![Page 23: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/23.jpg)
Them...
any Ctrace
preserving?
Gradualany,
W(any)C,
W(any)no
TypeScript any any yes
18Monday 23 March 15
![Page 24: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/24.jpg)
...and Us
any Ctrace
preserving? !C
Gradualany,
W(any)C,
W(any)no
TypeScript any any yes
StrongScript any anyat
optional types
C
enable efficient compilation
19Monday 23 March 15
![Page 25: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/25.jpg)
Programming with concrete types
20Monday 23 March 15
![Page 26: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/26.jpg)
StrongScript
1. Start from TypeScript
2. Add the !C type for each class name C
3. Three kinds of type annotations:
concrete types dynamic type optional types
denoted !C any C
typechecks as C any C
points to objects of type
C any any
21Monday 23 March 15
![Page 27: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/27.jpg)
var p:any = { x=3; z=4 }
var f:any = func (p) { if (p.x < 10) return 10 else return p.distance()}
f(p)
22Monday 23 March 15
![Page 28: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/28.jpg)
var p:any = { x=3; z=4 }
var f:any = func (p) { if (p.x < 10) return 10 else return p.distance()}
f(p)Evaluates to 10.
22Monday 23 March 15
![Page 29: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/29.jpg)
var p:any = { x=3; z=4 }
var f:any = func (p) { if (p.x < 10) return 10 else return p.distance()}
f(p)Evaluates to 10.
now the programmer documents his expectations about the argument of f...
22Monday 23 March 15
![Page 30: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/30.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.distance()}
23Monday 23 March 15
![Page 31: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/31.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.distance()}
Correct.
23Monday 23 March 15
![Page 32: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/32.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.distance()}
Correct.
Static type error.
23Monday 23 March 15
![Page 33: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/33.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.distance()}
Correct.
Static type error.
still flexible get local type checking, IDE completion, ...
23Monday 23 March 15
![Page 34: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/34.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.dist()}
var s:!Point = new Point(5,6); f(s);
24Monday 23 March 15
![Page 35: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/35.jpg)
class Point { constructor(public x, public y){} dist(p) { return ... } }
var p:Point = { x=3; z=4 }
var f:any = func (p:Point) { if (p.x < 10) return 10 else return p.dist()}
var s:!Point = new Point(5,6); f(s);
Correct.
Evaluates to 10.
f was typechecked against Point, so we can safely pass a real Point
24Monday 23 March 15
![Page 36: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/36.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o"
25Monday 23 March 15
![Page 37: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/37.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o"
DYNAMIC ERR: type mismatch
25Monday 23 March 15
![Page 38: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/38.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o"
DYNAMIC ERR: type mismatch
instances of classes protect themselves
25Monday 23 March 15
![Page 39: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/39.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o" t.dist({x=1;y=2});
var fact = func(x:!number) {return ...:!number} var u:TypedPoint = { dist = function(p) {...} } var n:!number = fact(u.dist(p))
26Monday 23 March 15
![Page 40: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/40.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o" t.dist({x=1;y=2});
var fact = func(x:!number) {return ...:!number} var u:TypedPoint = { dist = function(p) {...} } var n:!number = fact(u.dist(p))
Correct
26Monday 23 March 15
![Page 41: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/41.jpg)
class TypedPoint { constructor(public x:!number, public y:!number){} dist(p) { return ... :!number }} var t:!TypedPoint = new TypedPoint (1,2)(<any>t).x = "o" t.dist({x=1;y=2});
var fact = func(x:!number) {return ...:!number} var u:TypedPoint = { dist = function(p) {...} } var n:!number = fact(u.dist(p))
Correct
u.dist(p) has type !number 26Monday 23 March 15
![Page 42: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/42.jpg)
Guarantees
run-time errors arise only executing
dynamically or optionally typed code
adding an optional type annotation does not break
a correct dynamic program
a completely optionally typed program, can be strengthened
by replacing all option types with concrete types
27Monday 23 March 15
![Page 43: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/43.jpg)
Implementation and evaluation
28Monday 23 March 15
![Page 44: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/44.jpg)
StrongScript compilation strategy
StrongScript is compiled to plain JS code
Dynamic type-checking code is compiled into JS code
Intrinsics improve performance on supporting interpreters
29Monday 23 March 15
![Page 45: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/45.jpg)
Compiling classes
As in TypeScript, classes are compiled with the class pattern:
Also support for modules, as in TypeScript.
= 42;
30Monday 23 March 15
![Page 46: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/46.jpg)
Dynamic type checks
StrongScript inserts dynamic checks at downcasts:
• primitive types are checked with the typeof operator;
• classes are checked with the instanceof operator.
Contrast with TypeScript, which erases all type and performs no checks at run-time.
By definition, optional types require no checks. If optional blame tracking is enabled, values at optional types are wrapped and checked lazily.
31Monday 23 March 15
![Page 47: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/47.jpg)
Type protection for classes
Fields are hidden, an accessor allows read and write access mediated by a checking function.
Fields accessed in an object with a statically-declared type, the accessor is bypassed.
Each method in a class is generated as two methods: one to be used by typed clients, one to be used by untyped clients.
32Monday 23 March 15
![Page 48: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/48.jpg)
Target
StrongScript output is idiomatic JavaScript, extended with
• checks for static types
• intrinsics to explicitly specify the memory layout (can also guide boxing/unboxing)
supported by our extension of TruffleJS (V8 impl in progress)
speedup observed on benchmarks heavily using objects
33Monday 23 March 15
![Page 49: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/49.jpg)
optional type systems
Industry answer
Surprising properties: types do not affect execution types are unsound
Hack, Dart, TypeScript, …
Pragmatic benefits: IDE support
gradual type systems
Academia answer
Racket, SmallTalk, …
Types affect executionTypes are sound
Values are wrapped at dynamic/static boundaries:- statically-typed code can fail - runtime overhead
34Monday 23 March 15
![Page 50: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/50.jpg)
optional type systems
Industry answer
Surprising properties: types do not affect execution types are unsound
Hack, Dart, TypeScript, …
Pragmatic benefits: IDE support
gradual type systems
Academia answer
Racket, SmallTalk, …
Types affect executionTypes are sound
Values are wrapped at dynamic/static boundaries:- statically-typed code can fail - runtime overhead
StrongScript
Static types are preserved
Dynamism of JavaScript preserved
Optional types are trace preserving (enabling program evolution)
Efficient and predictable implementation for static types.
...implentation on top of V8 in progress...
34Monday 23 March 15
![Page 51: StrongScript: concrete types for TypeScript](https://reader034.vdocument.in/reader034/viewer/2022051521/586b65651a28abce7c8b5e74/html5/thumbnails/51.jpg)
35Monday 23 March 15