Learn Rust

Question 1

Garbage Collection

Answer 1

None - frees up memory automatically

Question 2

Cargo

Answer 2

cargo new demoName
cargo build
cargo build --release
cargo run --release
cargo watch -x run

Question 3

Scalar Types: integer, floating point numbers, boolean, , characters

Answer 3

large whole number, floating point = decimals, boolean: true/false; characters:

Question 4

tuple type

Answer 4

(5, 5.0, “chris”). let (x, y, z) = tuple | x = 5

Question 5

fn hello_world(name: &str) {
    println!("hello {}", name);
}

Answer 5

need & to know length of string else it wont compile

Question 6

i8

Answer 6

8 bit integer

Question 7

::

Answer 7

bind method to call that library

Question 8

u64

Answer 8

unsigned integer, number cant be negative

Question 9

float

Answer 9

f32 floating number 6.7 with decimal

Question 10

if else statement

Answer 10

if n < 30 {} else {} | ==; !=; ;

Question 11

enum

Answer 11

enum Name {variance} eg {Up, Down}. let test:Name = Name::Up

Question 12

constants

Answer 12

const Name: u8 = 20; name and type. for n in 1..Name {}

Question 13

tuples

Answer 13

bunch of variables in 1 place. let tup1 = (20, “test”, 21.1);

Question 14

code block

Answer 14

fn main(){
   let x = 10; 
   {inside here can access outside x
   }
   outside here cant access inside {}
}

Question 15

shadowing

Answer 15

let mut x = 10;
{ let x = 15; }
x is 10 here. Inside code block is isolated.

Question 16

references

Answer 16

another way to refer to a variable. eg domenic is also dom. 
let mut x = 10; let xr = &x; cant change xr though.
eg let dom = &mut x; 
*dom += 1; can now change dom.
{eg let dom = &mut x; 
*dom += 1; can now change dom.}

Question 17

structs

Answer 17

group similar info in same place
struct Color {
  red: u8, 
  green: u8,
  blue: u8
}
fn main(){
let bg = Color {red: 255, green: 70, blue: 15};

Question 18

tuple struct

Answer 18

struct Color(u8, u8, u8);
fn main(){
let red = Color(255, 0, 0);
println!("{}", red.0, red.1, red.2);

Question 19

Pass by reference

Answer 19

struct Color {red: u8, green: u8, blue: u8}
fn main(){let blue = Color{red: 0, green: 0, blue: 255};
  print_color(&blue);
}
fn print_color(c: &Color){
println!("Color - R:{} G:{}, B{}", c.red, c.green, c.blue);}
& means reference to it

Question 20

Impl Keyword

Answer 20

struct Rectangle {width: u32, height: u32}
impl Rectangle {
  fn print_description(&self) // &self gives access to itself
  println!("Rectangle: {} x {}}, self.width, self.height); }
  fn is_square(&self) -> bool {self.width == self.height }
}
fn main(){ let my_rect = Rectangle {width: 10, height: 5};
  my_rect.print_description(); // no need to pass in anything as its done automatically in &self
  println!("Retangle is a squre: {}", my_rect.is_square());
}

Question 21

String

Answer 21

fn main(){
  let my_string = String::from("This is a string"); // variable my_string has data type String
}

Question 22

Traits

Answer 22

Something like an object, struct etc can do
struct Person {name: String, age: u8}
impl ToString for Person {
  fn to_string(&self) -> String {
    return format!("My name is {} and I am {}.}, self.name, self.age);
fn main(){
  let dom = Person {name: String::from("Domenic"), age: 21};
  println!("{}", dom.to_string()); }

Question 23

Vector

Answer 23

let my_vector = vec![1, 2, 3, 4];

Question 24

Defining Traits

Answer 24

trail certain set of rules/requirements, for that object/struct must have in order to have that name of the trait
struct Person {name: String, age: u8}
trait HasVoiceBox {
  // speak
  fn speak(&self); // if you have a voice box, you can speak
  // Check if can speak
  fn can_speak(&self) -> bool; }
// implement this trait on Person struct
impl HasVoiceBox for Person {
  fn speak(&self) {
    println!("Hello my name is {}", self.name);
  }
  fn can_speak(&self) -> bool{ if self.age > 0 {return true;} retnr false; }
  }
}
fn main(){
  let person = Person{name: String::from("Bob"), age: 41 }
  println!("Can {} speak? {}", person.name, person.can_speak()); 
  person.speak();
}

Question 25

Switch Statement - Pattern Matching

Answer 25

fn main(){
  let number = 2;
  match number {
    1 => println!("It is one"),
    2 => println!("There is 2"),
    10 || 11 => println!("or function"),
    2...20 => println!("2 to 20"),
    "Chris" => println!("Can match strings too"),
    _ => println!("It doesnt match") // last case _
}

Question 26

Modules (mod keyword)

Answer 26

mod decode {
  fn chicken(){println!("Chicken");}
  pub fn print_message(){
    chicken();    
    println!("Hows it going");}
  pub mod water {
    pub fn print_message(){println!("Im water");}
}
fn main(){
  dcode::print_message(); 
  dcode::water::print_message(); 
}

Question 27

Option (Enum)

Answer 27

fn main(){
let name = String::from(“Domenic”);
println!(“Character at index 8: {}”, match name.chars().nth(8) {
Some(c) => c.to_String(),
None => “No character at index 8!”.to_string()
}); }
OR
fn main() {
println!(“Occupation is {}”, match get_occupation(“Domenic”){
Some(o) => o,
None => “No occupation found” }); }
fn get_occupation(name: &str) -> Option { // name is type string, returns an option Enum of type string
match name {
“Domenic” => Some(“Software Developer”),
“Michael” => Some(“Dentist”),
_ => None } }

Question 28

Enum Methods

Answer 28

enum Day {Monday, Tues}
impl Day {
  fn is_weekday(&self) -> bool {
    match self { &Day::Saturday | &Day::Sunday => return false // 1 pipe |
                         _ => return true }}}
fn main(){ let d = Day::Tuesday;
  println!("Is d a weeday? {}", d.is_weekday()); }