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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// run-pass
pub fn main() {
let f = 1_usize as *const String;
println!("{:?}", f as isize);
println!("{:?}", f as usize);
println!("{:?}", f as i8);
println!("{:?}", f as i16);
println!("{:?}", f as i32);
println!("{:?}", f as i64);
println!("{:?}", f as u8);
println!("{:?}", f as u16);
println!("{:?}", f as u32);
println!("{:?}", f as u64);
println!("{:?}", 1 as isize);
println!("{:?}", 1 as usize);
println!("{:?}", 1 as *const String);
println!("{:?}", 1 as i8);
println!("{:?}", 1 as i16);
println!("{:?}", 1 as i32);
println!("{:?}", 1 as i64);
println!("{:?}", 1 as u8);
println!("{:?}", 1 as u16);
println!("{:?}", 1 as u32);
println!("{:?}", 1 as u64);
println!("{:?}", 1 as f32);
println!("{:?}", 1 as f64);
println!("{:?}", 1_usize as isize);
println!("{:?}", 1_usize as usize);
println!("{:?}", 1_usize as *const String);
println!("{:?}", 1_usize as i8);
println!("{:?}", 1_usize as i16);
println!("{:?}", 1_usize as i32);
println!("{:?}", 1_usize as i64);
println!("{:?}", 1_usize as u8);
println!("{:?}", 1_usize as u16);
println!("{:?}", 1_usize as u32);
println!("{:?}", 1_usize as u64);
println!("{:?}", 1_usize as f32);
println!("{:?}", 1_usize as f64);
println!("{:?}", 1i8 as isize);
println!("{:?}", 1i8 as usize);
println!("{:?}", 1i8 as *const String);
println!("{:?}", 1i8 as i8);
println!("{:?}", 1i8 as i16);
println!("{:?}", 1i8 as i32);
println!("{:?}", 1i8 as i64);
println!("{:?}", 1i8 as u8);
println!("{:?}", 1i8 as u16);
println!("{:?}", 1i8 as u32);
println!("{:?}", 1i8 as u64);
println!("{:?}", 1i8 as f32);
println!("{:?}", 1i8 as f64);
println!("{:?}", 1u8 as isize);
println!("{:?}", 1u8 as usize);
println!("{:?}", 1u8 as *const String);
println!("{:?}", 1u8 as i8);
println!("{:?}", 1u8 as i16);
println!("{:?}", 1u8 as i32);
println!("{:?}", 1u8 as i64);
println!("{:?}", 1u8 as u8);
println!("{:?}", 1u8 as u16);
println!("{:?}", 1u8 as u32);
println!("{:?}", 1u8 as u64);
println!("{:?}", 1u8 as f32);
println!("{:?}", 1u8 as f64);
println!("{:?}", 1i16 as isize);
println!("{:?}", 1i16 as usize);
println!("{:?}", 1i16 as *const String);
println!("{:?}", 1i16 as i8);
println!("{:?}", 1i16 as i16);
println!("{:?}", 1i16 as i32);
println!("{:?}", 1i16 as i64);
println!("{:?}", 1i16 as u8);
println!("{:?}", 1i16 as u16);
println!("{:?}", 1i16 as u32);
println!("{:?}", 1i16 as u64);
println!("{:?}", 1i16 as f32);
println!("{:?}", 1i16 as f64);
println!("{:?}", 1u16 as isize);
println!("{:?}", 1u16 as usize);
println!("{:?}", 1u16 as *const String);
println!("{:?}", 1u16 as i8);
println!("{:?}", 1u16 as i16);
println!("{:?}", 1u16 as i32);
println!("{:?}", 1u16 as i64);
println!("{:?}", 1u16 as u8);
println!("{:?}", 1u16 as u16);
println!("{:?}", 1u16 as u32);
println!("{:?}", 1u16 as u64);
println!("{:?}", 1u16 as f32);
println!("{:?}", 1u16 as f64);
println!("{:?}", 1i32 as isize);
println!("{:?}", 1i32 as usize);
println!("{:?}", 1i32 as *const String);
println!("{:?}", 1i32 as i8);
println!("{:?}", 1i32 as i16);
println!("{:?}", 1i32 as i32);
println!("{:?}", 1i32 as i64);
println!("{:?}", 1i32 as u8);
println!("{:?}", 1i32 as u16);
println!("{:?}", 1i32 as u32);
println!("{:?}", 1i32 as u64);
println!("{:?}", 1i32 as f32);
println!("{:?}", 1i32 as f64);
println!("{:?}", 1u32 as isize);
println!("{:?}", 1u32 as usize);
println!("{:?}", 1u32 as *const String);
println!("{:?}", 1u32 as i8);
println!("{:?}", 1u32 as i16);
println!("{:?}", 1u32 as i32);
println!("{:?}", 1u32 as i64);
println!("{:?}", 1u32 as u8);
println!("{:?}", 1u32 as u16);
println!("{:?}", 1u32 as u32);
println!("{:?}", 1u32 as u64);
println!("{:?}", 1u32 as f32);
println!("{:?}", 1u32 as f64);
println!("{:?}", 1i64 as isize);
println!("{:?}", 1i64 as usize);
println!("{:?}", 1i64 as *const String);
println!("{:?}", 1i64 as i8);
println!("{:?}", 1i64 as i16);
println!("{:?}", 1i64 as i32);
println!("{:?}", 1i64 as i64);
println!("{:?}", 1i64 as u8);
println!("{:?}", 1i64 as u16);
println!("{:?}", 1i64 as u32);
println!("{:?}", 1i64 as u64);
println!("{:?}", 1i64 as f32);
println!("{:?}", 1i64 as f64);
println!("{:?}", 1u64 as isize);
println!("{:?}", 1u64 as usize);
println!("{:?}", 1u64 as *const String);
println!("{:?}", 1u64 as i8);
println!("{:?}", 1u64 as i16);
println!("{:?}", 1u64 as i32);
println!("{:?}", 1u64 as i64);
println!("{:?}", 1u64 as u8);
println!("{:?}", 1u64 as u16);
println!("{:?}", 1u64 as u32);
println!("{:?}", 1u64 as u64);
println!("{:?}", 1u64 as f32);
println!("{:?}", 1u64 as f64);
println!("{:?}", 1u64 as isize);
println!("{:?}", 1u64 as usize);
println!("{:?}", 1u64 as *const String);
println!("{:?}", 1u64 as i8);
println!("{:?}", 1u64 as i16);
println!("{:?}", 1u64 as i32);
println!("{:?}", 1u64 as i64);
println!("{:?}", 1u64 as u8);
println!("{:?}", 1u64 as u16);
println!("{:?}", 1u64 as u32);
println!("{:?}", 1u64 as u64);
println!("{:?}", 1u64 as f32);
println!("{:?}", 1u64 as f64);
println!("{:?}", true as isize);
println!("{:?}", true as usize);
println!("{:?}", true as i8);
println!("{:?}", true as i16);
println!("{:?}", true as i32);
println!("{:?}", true as i64);
println!("{:?}", true as u8);
println!("{:?}", true as u16);
println!("{:?}", true as u32);
println!("{:?}", true as u64);
println!("{:?}", 1f32 as isize);
println!("{:?}", 1f32 as usize);
println!("{:?}", 1f32 as i8);
println!("{:?}", 1f32 as i16);
println!("{:?}", 1f32 as i32);
println!("{:?}", 1f32 as i64);
println!("{:?}", 1f32 as u8);
println!("{:?}", 1f32 as u16);
println!("{:?}", 1f32 as u32);
println!("{:?}", 1f32 as u64);
println!("{:?}", 1f32 as f32);
println!("{:?}", 1f32 as f64);
println!("{:?}", 1f64 as isize);
println!("{:?}", 1f64 as usize);
println!("{:?}", 1f64 as i8);
println!("{:?}", 1f64 as i16);
println!("{:?}", 1f64 as i32);
println!("{:?}", 1f64 as i64);
println!("{:?}", 1f64 as u8);
println!("{:?}", 1f64 as u16);
println!("{:?}", 1f64 as u32);
println!("{:?}", 1f64 as u64);
println!("{:?}", 1f64 as f32);
println!("{:?}", 1f64 as f64);
}
|
