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
|
fn simple() -> i32 {
let y = 10;
let f = |x| x + y;
f(2)
}
fn crazy_closure() -> (i32, i32, i32) {
fn inner<T: Copy>(t: T) -> (i32, T, T) {
struct NonCopy;
let x = NonCopy;
let a = 2;
let b = 40;
let f = move |y, z, asdf| {
drop(x);
(a + b + y + z, asdf, t)
};
f(a, b, t)
}
inner(10)
}
fn closure_arg_adjustment_problem() -> i64 {
fn once<F: FnOnce(i64)>(f: F) {
f(2);
}
let mut y = 1;
{
let f = |x| y += x;
once(f);
}
y
}
fn fn_once_closure_with_multiple_args() -> i64 {
fn once<F: FnOnce(i64, i64) -> i64>(f: F) -> i64 {
f(2, 3)
}
let y = 1;
{
let f = |x, z| x + y + z;
once(f)
}
}
fn boxed_fn_once(f: Box<dyn FnOnce() -> i32>) -> i32 {
f()
}
fn box_dyn() {
let x: Box<dyn Fn(i32) -> i32> = Box::new(|x| x * 2);
assert_eq!(x(21), 42);
let mut i = 5;
{
let mut x: Box<dyn FnMut()> = Box::new(|| i *= 2);
x();
x();
}
assert_eq!(i, 20);
}
fn fn_item_as_closure_trait_object() {
fn foo() {}
let f: &dyn Fn() = &foo;
f();
}
fn fn_item_with_args_as_closure_trait_object() {
fn foo(i: i32) {
assert_eq!(i, 42);
}
let f: &dyn Fn(i32) = &foo;
f(42);
}
fn fn_item_with_multiple_args_as_closure_trait_object() {
fn foo(i: i32, j: i32) {
assert_eq!(i, 42);
assert_eq!(j, 55);
}
fn bar(i: i32, j: i32, k: f32) {
assert_eq!(i, 42);
assert_eq!(j, 55);
assert_eq!(k, 3.14159)
}
let f: &dyn Fn(i32, i32) = &foo;
f(42, 55);
let f: &dyn Fn(i32, i32, f32) = &bar;
f(42, 55, 3.14159);
}
fn fn_ptr_as_closure_trait_object() {
fn foo() {}
fn bar(u: u32) {
assert_eq!(u, 42);
}
fn baa(u: u32, f: f32) {
assert_eq!(u, 42);
assert_eq!(f, 3.141);
}
let f: &dyn Fn() = &(foo as fn());
f();
let f: &dyn Fn(u32) = &(bar as fn(u32));
f(42);
let f: &dyn Fn(u32, f32) = &(baa as fn(u32, f32));
f(42, 3.141);
}
fn main() {
assert_eq!(simple(), 12);
assert_eq!(crazy_closure(), (84, 10, 10));
assert_eq!(closure_arg_adjustment_problem(), 3);
assert_eq!(fn_once_closure_with_multiple_args(), 6);
assert_eq!(
boxed_fn_once(Box::new({
let x = 13;
move || x
})),
13,
);
box_dyn();
fn_item_as_closure_trait_object();
fn_item_with_args_as_closure_trait_object();
fn_item_with_multiple_args_as_closure_trait_object();
fn_ptr_as_closure_trait_object();
}
|
