forked from babel/babel
-
Notifications
You must be signed in to change notification settings - Fork 0
/
actual.js
117 lines (117 loc) · 3.62 KB
/
actual.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
function foo(numVal: any) {}
function foo(numVal: number) {}
function foo(numVal: number, strVal: string) {}
function foo(numVal: number, untypedVal) {}
function foo(untypedVal, numVal: number) {}
function foo(nullableNum: ?number) {}
function foo(callback: () => void) {}
function foo(callback: () => number) {}
function foo(callback: (_: bool) => number) {}
function foo(callback: (_1: bool, _2: string) => number) {}
function foo(callback: (_1: bool, ...foo: Array<number>) => number) {}
function foo(): number{}
function foo():() => void {}
function foo():(_:bool) => number{}
function foo():(_?:bool) => number{}
function foo(): {} {}
function foo<T>() {}
function foo<T,S>() {}
function foo<T: F>() {}
a = function<T,S>() {};
a = { set fooProp(value: number) {} };
a = { set fooProp(value: number): void {} };
a = { get fooProp():number{} };
a = { id<T>(x: T): T {} };
a = { *id<T>(x: T): T {} };
a = { async id<T>(x: T): T {} };
a = { 123<T>(x: T): T {} };
class Foo {
set fooProp(value: number) {}
}
class Foo {
set fooProp(value: number): void {}
}
class Foo {
get fooProp(): number {}
}
var numVal: number;
var numVal: number = otherNumVal;
var a: { numVal: number };
var a: { numVal: number; };
var a: { numVal: number; [indexer: string]: number };
var a: ?{ numVal: number };
var a: { numVal: number; strVal: string }
var a: { subObj: {strVal: string} }
var a: { subObj: ?{strVal: string} }
var a: { param1: number; param2: string }
var a: { param1: number; param2?: string }
var a: { [a: number]: string; [b: number]: string; };
var a: { add(x: number, ...y: Array<string>): void };
var a: { subtract: (x: number, ...y: Array<string>) => void };
var a: { id<T>(x: T): T; };
var a:Array<number> = [1, 2, 3]
a = class Foo<T> {}
a = class Foo<T> extends Bar<T> {}
class Foo<T> {}
class Foo<T> extends Bar<T> {}
class Foo<T> extends mixin(Bar) {}
class Foo<T> {
bar<U>():number { return 42; }
}
class Foo {
"bar"<T>() {}
}
function foo(requiredParam, optParam?) {}
class Foo {
prop1: string;
prop2: number;
}
class Foo {
static prop1: string;
prop2: number;
}
var x: number | string = 4;
class Array { concat(items:number | string) {}; }
var x: () => number | () => string = fn;
var x: typeof Y = Y;
var x: typeof Y | number = Y;
var {x}: {x: string; } = { x: "hello" };
var {x}: {x: string } = { x: "hello" };
var [x]: Array<string> = [ "hello" ];
function foo({x}: { x: string; }) {}
function foo([x]: Array<string>) {}
function foo(...rest: Array<number>) {}
(function (...rest: Array<number>) {});
((...rest: Array<number>) => rest);
var a: Map<string, Array<string> >
var a: Map<string, Array<string>>
var a: number[]
var a: ?string[]
var a: Promise<bool>[]
var a:(...rest:Array<number>) => number
var identity: <T>(x: T) => T
var identity: <T>(x: T, ...y:T[]) => T
import type foo from "bar";
import type { foo, bar } from "baz";
import type { foo as bar } from "baz";
import type from "foo";
import type, { foo } from "bar";
import type * as namespace from "bar";
export type { foo };
export type { foo } from "bar";
export interface foo { p: number };
export interface foo<T> { p: T };
var a: ?Array<?string>;
var a: {| numVal: number |};
var a: {| numVal: number; |};
var a: {| numVal: number; [indexer: string]: number |};
var a: ?{| numVal: number |};
var a: {| numVal: number; strVal: string |}
var a: {| subObj: {strVal: string} |}
var a: {| subObj: ?{strVal: string} |}
var a: {| param1: number; param2: string |}
var a: {| param1: number; param2?: string |}
var a: {| [a: number]: string; [b: number]: string; |};
var a: {| add(x: number, ...y: Array<string>): void |};
var a: {| subtract: (x: number, ...y: Array<string>) => void |};
var a: {| id<T>(x: T): T; |};