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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
(** ocaml language extensions
(http://caml.inria.fr/pub/docs/manual-ocaml/manual021.html)
*)
(* other integer literals *)
let i = 12l
+ 0l
let i = 12L
+ 0l
let i = 12n
+ 0n
(* range patterns *)
let f = function
| 'a'..'z' ->
e1
| 'A'..'Z'
| '0'..'9' ->
e2
(* local modules *)
let f =
let module M =
F(struct end)
in
M.f x
(* recursive modules *)
module rec M : S =
struct
;;
end
and M1 : S1 =
struct
;;
end
(* private types *)
type t = private
X of string
| Y
type t = private
{ f1:t1;
f2: t2 }
type t =
private t'
(* local opens *)
let _ =
let open
F(X)
in
()
(* record shortcuts *)
let _ =
let x = 1 and y = 2
in
{ x;
y
}
let f = function
| { x;
y;
_
} ->
()
(* locally abstract types *)
let f = fun
(type t)
(x: t)
->
()
let f
(type t)
(x: t)
=
()
(* first-class modules *)
type m =
(module M.Sig
with type t = 'b)
* unit
let x =
let m =
(module M : M.Sig
with type t = 'b)
in
let module M =
(val m :
M.sig
with type t = 'b)
in
M
(* module type of *)
module type S = sig
include module type of M
end
(* signature substitution *)
module type S = sig
include
M0 with type t := t
val x : unit
end
(* class overriding *)
class cl = object
inherit!
cl
val! v = v
method! m = m
end
(* GADTs *)
type _ t =
A: int t
| B: 'a t * 'b t -> ('a*'b) t
|
