feat(arrived at types)

src/primitives.rs

@@ -0,0 +1,124 @@
+#![allow(dead_code)]
+
+fn reverse_tuple(pair: (i32, bool)) -> (bool, i32) {
+    let (int_param, bool_param) = pair;
+
+    (bool_param, int_param)
+}
+
+pub fn primitives_module() {
+    // Scalar types
+    // signed integers: i8, i16, i132, 164, i128
+    // signed integers: u8, u16, u132, u64, u128
+    // floating point: f32, f64
+    // char
+    // bool
+    // unit type (), only posible value is an empty tuple
+    ////
+    // Compound types
+    // Array [1,2,3]
+    // Tuples (1, true)
+
+    let logical = true; // not necesary to specify the type if initialized
+    let a_float: f64 = 1.0;
+    let rare_integer = 5i32; // suffix annotation, = integer of 32 bits with a value of 5
+    println!("{} {} {}", logical, a_float, rare_integer);
+
+    // All are inmutable by default
+    // mut keyword
+    let mut mutable_int = 12i32;
+    println!("int: {}", mutable_int);
+    mutable_int = 21;
+    println!("int mutated: {}", mutable_int);
+
+    let mutable_int = true; // variables can be overwritten with shadowing
+    println!("not an int anymore {}", mutable_int);
+
+    let thousand = 1_000;
+    println!(
+        "1_000 is a good way to express {} in order to make it readable",
+        thousand
+    );
+
+    let cientific = 7.6e-4;
+    println!(
+        "Cientific notation is also valid, as 7.6e-4 would be stored as {}",
+        cientific
+    );
+
+    println!(
+        "Remember that the type can be specified with the number, as 1u32 is {}",
+        1u32
+    );
+
+    let my_tuple = (1, "corcho", true);
+
+    println!(
+        "The second value of the tuple {:?} is {}",
+        my_tuple, my_tuple.1
+    );
+
+    let another_tuple = (1i32, false);
+    println!(
+        "A function can also receive and return tuples, such as reverse return {:?} on {:?}",
+        reverse_tuple(another_tuple),
+        another_tuple
+    );
+
+    #[derive(Debug)]
+    struct EmulatedMatrix(f32, f32, f32, f32);
+
+    let matrix = EmulatedMatrix(1.1, 1.4, 0.5, 7.3);
+    println!("Simulated: {:?}", matrix);
+    let EmulatedMatrix(a, b, c, d) = matrix;
+    println!("Data can also be destructured: {}, {}, {}, {}", a, b, c, d);
+
+    // EXERCISE 1: fmt::Display Matrix (make it easy, you dont know loops yet)
+    println!("EXERCISE 1: Print a matrix with the tuple struct:");
+    use std::fmt::{Display, Formatter, Result};
+
+    impl Display for EmulatedMatrix {
+        fn fmt(&self, f: &mut Formatter) -> Result {
+            write!(f, "({}, {})\n({} {})", &self.0, &self.1, &self.2, &self.3)
+        }
+    }
+
+    println!("{}", matrix);
+
+    // EXERCISE 2: transpose a EmulatedMatrix (make it easy, you dont know loops yet)
+    println!("EXERCISE 2: make a simple transpose function (later on we'll improve it with loops)");
+    fn transpose(m: EmulatedMatrix) -> EmulatedMatrix {
+        let EmulatedMatrix(a, b, c, d) = m;
+        return EmulatedMatrix(a, c, b, d);
+    }
+
+    println!("{}", transpose(matrix));
+
+    // Arrays
+    let mut onetofive: [i8; 5] = [1, 2, 3, 4, 5];
+    println!("The fourth element is {}", onetofive[3]);
+    let allthrees: [i32; 10] = [3; 10];
+    println!(
+        "All threes: {:?} have a size of {}",
+        allthrees,
+        allthrees.len()
+    );
+
+    use std::mem;
+    println!("All threes accupies {} bytes", mem::size_of_val(&allthrees));
+
+    // Sclice: pointer to a portion of an array
+    // '&' means borrowing
+    let onetothree = &mut onetofive[1..3];
+    println!("One to three slice {:?}", onetothree);
+    onetothree[1] = 7;
+    println!("onetofive slice {:?} after mutating onetothree", onetofive);
+
+    for i in 0..onetofive.len() + 1 {
+        // force a failure
+        match onetofive.get(i) {
+            Some(xval) => println!("{}: {}", i, xval),
+            None => println!("Slow down! {} is too far!", i),
+        }
+    }
+}