Differences

This shows you the differences between two versions of the page.

--- devlogs:8_5_2022 [2022/05/08 15:21]
root
+++ devlogs:8_5_2022 [2023/10/19 15:25] (current)
@@ Line 70: / Line 70: @@
 </code>
-~~ DISCUSS | Gosy ~~
+Spent most of the day hanging out with some real life people..... it was fun.
+But to come back to the whole thing of solving the rustlings movesemantics2
+  - Make `fill_vec` borrow its argument instead of taking ownership of it, and then copy the data within the function in order to return an owned Vec<i32>
+  - Make `fill_vec` *mutably* borrow its argument (which will need to be mutable), modify it directly, then not return anything. Then you can get rid of `vec1` entirely
+== For number #2 ==
+We just pass the refrences of the vector (//borrowing//). And than use the clone() method of the vec to clone it into the local variable within the function. This way it can be used in the printline statement as it has not been moved.
+<code rust>
+fn main() {
+    let vec0 = Vec::new();
+    let mut vec1 = fill_vec(&vec0);
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+    vec1.push(88);
+    println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+fn fill_vec(vec: &Vec<i32>) -> Vec<i32> {
+    let mut vec = vec.clone();
+    vec.push(22);
+    vec.push(44);
+    vec.push(66);
+    vec
+}
+</code>
+== #3 ==
+For number 3 we can get rid of vec1. We will just take vec0 have it be mutable and then change it within the function. This requires us to make vec0 mutable and pass it by reference so that the ownership does not get moved.
+<code rust>
+fn main() {
+    let mut vec0 = Vec::new(); //Make mutable
+    fill_vec(&mut vec0); //Pass mutable ref
+    // Do not change the following line!
+    println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+    //vec1.push(88);
+    //println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+}
+fn fill_vec(vec:&mut Vec<i32>){ //Take a mutable ref
+    //let vec = vec; dont need this anymore
+    vec.push(22); //Modify the ever loving shit out of this array!
+    vec.push(44);
+    vec.push(66);
+}
+</code>
+== Wow tuples! ==
+Tuples are kinda like arrays but they can hold different types of data.
+<code rust>
+let i = (2.0,"alex",false); // () are how you initialize tuples.
+</code>
+but like whadoo?? how do you use it?
+<code rust>
+fn main() {
+let i = (2,"alex",false);
+let (num,name,truth) = i; // Deconstruct it using let
+let anotherNum = i.0; //Lol yeah you can access it like that too
+let anotherString = String::from(i.1);
+match i {
+ (2,"alex",false) => println!("WOW what a specific toople"),
+ //IF first is 0 and then Destructure the second and third elements
+ (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z),
+ (1, ..)  => println!("First is `1` and the rest doesn't matter"),
+ //`..` can be used to ignore the rest of the tuple
+ _      => println!("It doesn't matter what they are"),
+ // `_` means don't bind the value to a variable
+    }
+}
+</code>
+that is all.
+~~DISCUSSION | Gosy ~~

Ultra Letter Linker

User Tools

Site Tools

Differences

Page Tools