initial lab 01

lectures/01/src/numbers.rs

@@ -0,0 +1,63 @@
+// numbers an be imported,
+// but functions need to be marked public with pub
+pub fn run() {
+    println!("NUMBERS");
+
+    let x = 123; // numbers default to i32
+    println!("{x}");
+    // println!("{}", x + 100); // this panics if this line is enabled
+    println!("{}", x + 1i8); // x must be an i8
+
+    // variables are immutable by default, use mut to be mutable
+    let mut x = 2;
+    println!("{x}");
+    x = 10;
+    println!("{x}");
+
+    // REFERENCES (borrowing)
+    let r = &x; // shared reference/immutable reference
+    // *r = 11; // not allowed - error
+    println!("{r}"); // println!() will always deref no matter how many refs, e.g.
+    println!("{}", &&&&&&x);
+
+    let r2 = &x;
+    println!("{r} {r2}"); // scope of r & r2 is to here
+
+    let s = &mut x; // mutable reference/exclusive reference
+    *s = 11; // allowed because s is mutable/exclusive
+    println!("{s}");
+
+    double(s); // or double(&mut x)
+
+    // Ojects at any time can have either:
+    // many shared references
+    // OR
+    // exactly 1 mutable reference
+    // e.g. DB can have many readers but only 1 writer
+    //      but not at the same time
+
+    // therefore:
+    // println!("{r}"); will cause `let s = &mut x;` to error
+    // because both r & s are in scope at the same time
+
+    /*
+       let mut x = 1;       // can be modified
+       let r1 = &mut x;     // can use r1 to modify x
+       let mut r2 = &x;     // can modify r2
+       let mut r3 = &mut x; // can modify r3 & x
+    */
+
+    // add float to int
+    // should default to f64 unless inferred as other,
+    // e.g. this will default to f32 since we add a f32
+    let f = 3.14;
+    println!("{}", f + 1 as f32); // cast 1 to f32
+
+    let x = 10;
+    println!("{}", x + &1);
+}
+
+// we need &mut to borrow original and mutate it
+fn double(x: &mut i32) {
+    *x *= 2;
+}