Rust by Example - страница 6
>
>mutable = true;
>// Variables can be overwritten with shadowing.
>let mutable = true;
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Integers 1, floats 1.2, characters 'a', strings "abc", booleans true and the unit type () can be expressed using literals.
Integers can, alternatively, be expressed using hexadecimal, octal or binary notation using these prefixes respectively: 0x, 0o or 0b.
Underscores can be inserted in numeric literals to improve readability, e.g. 1_000 is the same as 1000, and 0.000_001 is the same as 0.000001.
We need to tell the compiler the type of the literals we use. For now, we'll use the u32 suffix to indicate that the literal is an unsigned 32-bit integer, and the i32 suffix to indicate that it's a signed 32-bit integer.
The operators available and their precedence in Rust are similar to other C-like languages.
>fn main() {
>// Integer addition
>println!("1 + 2 = {}", 1u32 + 2);
>// Integer subtraction
>println!("1 - 2 = {}", 1i32 - 2);
>// TODO ^ Try changing `1i32` to `1u32` to see why the type is important
>// Short-circuiting boolean logic
>println!("true AND false is {}", true && false);
>println!("true OR false is {}", true || false);
>println!("NOT true is {}", !true);
>// Bitwise operations
>println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
>println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
>println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
>println!("1 << 5 is {}", 1u32 << 5);
>println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);
>// Use underscores to improve readability!
>println!("One million is written as {}", 1_000_000u32);
>}
>הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
>XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
A tuple is a collection of values of different types. Tuples are constructed using parentheses (), and each tuple itself is a value with type signature (T1, T2, ...), where T1, T2 are the types of its members. Functions can use tuples to return multiple values, as tuples can hold any number of values.
>// Tuples can be used as function arguments and as return values
>fn reverse(pair: (i32, bool)) -> (bool, i32) {
>// `let` can be used to bind the members of a tuple to variables
>let (integer, boolean) = pair;
>(boolean, integer)
>}
>// The following struct is for the activity.
>#[derive(Debug)]
>struct Matrix(f32, f32, f32, f32);
>fn main() {
>// A tuple with a bunch of different types
>let long_tuple = (1u8, 2u16, 3u32, 4u64,
>-1i8, -2i16, -3i32, -4i64,
>0.1f32, 0.2f64,
>'a', true);
>// Values can be extracted from the tuple using tuple indexing
>println!("long tuple first value: {}", long_tuple.0);
>println!("long tuple second value: {}", long_tuple.1);
>// Tuples can be tuple members
>let tuple_of_tuples = ((1u8, 2u16, 2u32), (4u64, -1i8), -2i16);
>// Tuples are printable
>println!("tuple of tuples: {:?}", tuple_of_tuples);
>// But long Tuples cannot be printed
>// let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
>// println!("too long tuple: {:?}", too_long_tuple);
>// TODO ^ Uncomment the above 2 lines to see the compiler error
>let pair = (1, true);
>println!("pair is {:?}", pair);
>println!("the reversed pair is {:?}", reverse(pair));