Rust Basics.txt

Rust Basics


Project Setup
------------------

For Rust projects, a workspace is a container project which holds other projects. The benefit of the workspace structure is that it enables us to manage multiple projects as one unit. It also helps to store all related projects seamlessly within a single git repo.

cargo new --bin <project-name> // creates a new empty top level binary application
cargo new <subproject-name> // creates a subproject within a workspace 

// Cargo.toml - Top Level
// specifies the relationship between the subprojects 

[workspace]
members = [
    "tcpserver", "tcpclient", "http", "httpserver"
]


cargo run // runs program and outputs all statements in the code
cargp run -p tcpserver // runs the subproject/package tcpserver
carge run --release // runs program and ignores debug asserstions
cargo run --verbose // see what cargo passes to rustc



Variables
-------------

In Rust, by default variables are immutable

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
   }
   
To let the compiler know that I want a variable to be mutable I must preface it with "mut"

fn main() {
    let mut x = 5;
    println!("The value of x is: {}", x);
    x = 6;
    println!("The value of x is: {}", x);
}



Integers
-----------


Strings and String Slices (&str)
-----------------------------------------
- by default all variables in Rust are immutable
- once a value is set to a name, I cannot change that value

Tuples 
---------

Vectors
---------

Enums
---------

Hashmaps
---------------



Functions
--------------

defined in snake_case (e.g. fn another_function) not camelcase like in Javascript

types must be defined within parameter sets:

fn another_function(x: i32) {
    println!("The value of x is: {}", x);
}

return types are defined with the -> syntax:

fn plus_one(x: i32) -> i32 {
    x + 1
}

functions can return multiple values within a single tuple:

fn plus_one(x: i32) -> (method, version, resource) {
    x + 1
}


Structs (Classes)
----------------------

Structs let you create custom types that are meaningful for your domain. By using structs, you can keep associated pieces of data connected to each other and name each piece to make your code clear. Methods let you specify the behavior that instances of your structs have, and associated functions let you namespace functionality that is particular to your struct without having an instance available.

// define the struct and it's fields/properties (like a class)
struct User {
    username: String,
    email: String,
    sign_in_count: u64,
    active: bool,
}

// create an instance of a struct
    let user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };
    
    
    
    // update a field in an instance of a struct (if it's mutable)
      let mut user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("anotheremail@example.com"); // update
    
  Note that the entire instance must be mutable; Rust doesn’t allow us to mark only certain fields as mutable; this is unlike java and c# where I can define what's public versus what is private
  
  
 Adding Behavior to Structs -- Implementations
 ------------------------------------------------------------------ 
  
  Adding methods to structs unleashes the full power of object oriented programing. Functions are not defined within the scope of the struct, but rather outside. This enables functions to be "associated" with a custom data type. This lose coupling of the data type from it's underlying behavior is quite powerful. In other languages (java, c#) with classes, we see methods (behavior) defined together with their properties (Composition).
  

struct Rectangle {
    width: u32,
    height: u32,
}
 
 // associating a method to the Rectangle struct; impl means "implementation"
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area() // no semi-colon implies a return statement
    );
}


[Creating New Instances of Custom Data Types]

- in Rust there is no concept of a default constructor; it is best to define a "new" impl to handle this for you

struct Person {
 name: String,
 age: u8
}

impl Person {
  fn new(name: String, age: u8) -> Self {
      
      Self {  // implicitly returning a new Person (Self) struct
          name: name
          age: age
      }
  }
}

[Understanding Self and &self]

- Associated functions do not take &self as a paramater and are called with double-colons ::
- Methods take &self (an instance of the data type) and are called with . notation. These are typically used to conduct internal operations on the custom data type itself

// Associated Function (&self not used as a parameter)
impl Question {
    fn new(id: QuestionId, title: String, content: String, tags: Option<Vec<String>>) -> Self {
        Question {
            id,
            title,
            content,
            tags
        }
    }
    // Method (takes &self as a parameter)
     fn update_title(&self, id: QuestionId, new_title: String) -> Self {
        self.update_question (id, new_title) 
        }
}



Bundling Common Functionality -- Traits
 ----------------------------------------------------
 
#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!("rect1 is {:?}", rect1); 
}

 Putting the specifier {:?} or {:#?} inside the curly brackets tells println! we want to use an output format called Debug. The Debug trait enables us to print our struct in a way that is useful for developers so we can see its value while we’re debugging our code.

Rust has provided a number of traits for us to use with the derive annotation that can add useful behavior to our custom types.



Wrapping & Unwrapping 
--------------------------------



References & Borrowing (& syntax)
----------------------------------------------

The "&" allows me to reference a value without taking ownership of it. When we "borrow" in this fashion, the value that we are borrowing is immutable and therefore cannot be changed

BEFORE:

fn main() {
    let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); // len() returns the length of a String

    (s, length)
}


AFTER:

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1); // using a reference

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {  // a reference to a "string" in parameter set
    s.len()
}

In order to make a reference mutable (changeable) we simply preface with "mut":

fn main() {
    let mut s = String::from("hello");

    change(&mut s); // add &mut 
}

fn change(some_string: &mut String) { // add &mut; this is a mutable reference
    some_string.push_str(", world");
}