1    private@
2    
3    do
4        let f = { (x : u32) (y : u32) -> x + y }
5        let g : u32 * u32 -> u32 = { x y -> x + y }
6        let h = { ((u32, u32) x y) -> x + y }
7    
8    do
9        let f = { x y -> x + y }<u32 * u32 -> u32>
10       let g = { x, y -> x + y }<(u32, u32) -> u32>
11   
12   do
13       let f = { x y -> x + y }<u32, u32>
14       let g = { x, y -> x + y }<(u32, u32)>
15   
16   do
17       let f<T> where T : Number =
18           let a = 1
19           let f_outer (b : T) = a + b
20           let f_closure = { c -> let f_inner (d : T) = d * f_outer c
21                                  a + f_inner c }
22           f_closure 10
23   
24       assert f<i32> == 111
25   
26   type A =
27       val u = 1
28       val f = { x -> u + x }
29   
30   do
31       let a = A.new
32       assert a.f 7 == 8
33   
34   do
35       let f (g : i32 -> Unit) = g 10
36       f { assert _ == 10 }
37   
38   do
39       let add (x : i32) (y : i32) = x + y
40   
41       let r = add (1 |> { _ * 2 })
42                   (2 |> { x -> assert x == 2
43                                x * 3 })
44       assert r == 8
45   
46   do
47       let f =
48           let u = 2
49           { x -> u + x }
50   
51       assert f 5 == 7
52   
53   do
54       let f : fn i32 -> i32 = { x -> x * 2 }
55       let g : fn i32 -> i32 = { _ * 2 }
56   
57       assert f 9 == 18
58       assert g 9 == 18
59