From 3a8281a2a500439a8dab07f40b0d24da7e3095a4 Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Wed, 10 Jun 2020 18:16:27 -0400 Subject: [PATCH] Added files for chapter 2 --- 2.Primitives/1-LiteralsAndOperators.rs | 28 +++++++++++ 2.Primitives/2-Tuples.rs | 67 ++++++++++++++++++++++++++ 2.Primitives/3-ArraysAndSlices.rs | 39 +++++++++++++++ 3 files changed, 134 insertions(+) create mode 100644 2.Primitives/1-LiteralsAndOperators.rs create mode 100644 2.Primitives/2-Tuples.rs create mode 100644 2.Primitives/3-ArraysAndSlices.rs diff --git a/2.Primitives/1-LiteralsAndOperators.rs b/2.Primitives/1-LiteralsAndOperators.rs new file mode 100644 index 0000000..e4905ab --- /dev/null +++ b/2.Primitives/1-LiteralsAndOperators.rs @@ -0,0 +1,28 @@ +/* +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. +*/ + +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); +} diff --git a/2.Primitives/2-Tuples.rs b/2.Primitives/2-Tuples.rs new file mode 100644 index 0000000..11bfa2b --- /dev/null +++ b/2.Primitives/2-Tuples.rs @@ -0,0 +1,67 @@ +use std::fmt; //Import 'fmt' + + +//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); +impl fmt::Display for Matrix{ + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result{ + write!(f, "( {} {} )\n( {} {} )", self.0, self.1, self.2, self.3) + } +} +fn transpose(matrix: Matrix) -> Matrix{ + #[allow(non_snake_case)] + let newMatrix = Matrix(matrix.0, matrix.2, matrix.1, matrix.3); + return newMatrix; +} + +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)); + + //To create one element tuples, the comma is required to tell them apart from a literal surrounded by parentheses + println!("one element tuple: {:?}", (5u32,)); + println!("just an integer: {:?}", (5u32)); + + //tuples can be destructured to create bindings + let tuple = (1, "hello", 4.5, true); + + let (a, b, c, d) = tuple; + println!("{:?}, {:?}, {:?}, {:?}", a, b, c, d); + + let matrix = Matrix(1.1, 1.2, 2.1, 2.2); + println!("Debug:\n{:?}", matrix); + println!("Matrix:\n{}", matrix); + println!("Transpose:\n{}", transpose(matrix)); +} diff --git a/2.Primitives/3-ArraysAndSlices.rs b/2.Primitives/3-ArraysAndSlices.rs new file mode 100644 index 0000000..a329e2a --- /dev/null +++ b/2.Primitives/3-ArraysAndSlices.rs @@ -0,0 +1,39 @@ +use std::mem; + +// This function borrows a slice +fn analyze_slice(slice: &[i32]){ + println!("first element of the slice: {}", slice[0]); + println!("the slice has {} elements", slice.len()); +} + +fn main(){ + //Fixed-size array (type signature is superfluous) + let xs: [i32; 5] = [1, 2, 3, 4, 5]; + + //All elements can be initialized to the same value + let ys: [i32; 500] = [0; 500]; + + //Indexing starts at 0 + println!("first element of the array: {}", xs[0]); + println!("second element of the array: {}", xs[1]); + + //`len` returns the size of the array + println!("array size: {}", xs.len()); + + //Arrays are stack allocated + println!("array occupies {} bytes", mem::size_of_val(&xs)); + + //Arrays can be automatically borrowed as slices + println!("borrow the whole array as a slice"); + analyze_slice(&xs); + + //Slices can point to a section of an array + //They are of the form [starting_index..ending_index] + //starting_index is the first position in the slice + //ending_index is one more than the last position in the slice + println!("borrow a section of the array as a slice"); + analyze_slice(&ys[1 .. 4]); + + //Out of bound indexing causes compile error + //println!("{}", xs[5]); +}