#Getting Started

#Hello_World.rs

fn main() {
    println!("Hello, World!");
  }
  

#Compiling and Running

$ rustc Hello_World.rs
  $ ./Hello_World
  Hello, World!
  

#Primitive types

bool Boolean (true / false)
char character
f32, f64 32-bits, 64-bits floats
i64, i32, i16, i8 signed 16- ... integers
u64, u32, u16, u8 unsigned 16-bits, ... integers
isize pointer-sized signed integers
usize pointer-sized unsigned integers

See: Rust Types

#Formatting

// Single Placeholder
  println!("{}", 1);
  
  // Multiple Placeholder
  println!("{} {}", 1, 3);
  
  // Positional Arguments
  println!("{0} is {1} {2}, also {0} is a {3} programming language", "Rust", "cool", "language", "safe");
  
  // Named Arguments
  println!("{country} is a diverse nation with unity.", country = "India");
  
  // Placeholder traits :b for binary, :0x is for hex and :o is octal
  println!("Let us print 76 is binary which is {:b} , and hex equivalent is {:0x} and octal equivalent is {:o}", 76, 76, 76);
  
  // Debug Trait
  println!("Print whatever we want to here using debug trait {:?}", (76, 'A', 90));
  
  // New Format Strings in 1.58
  let x = "world";
  println!("Hello {x}!");
  

#Printing Styles

// Prints the output
  print!("Hello World\n");
  
  // Appends a new line after printing
  println!("Appending a new line");
  
  // Prints as an error
  eprint!("This is an error\n");
  
  // Prints as an error with new line
  eprintln!("This is an error with new line");
  

#Variables

// Initializing and declaring a variable
  let some_variable = "This_is_a_variable";
  
  // Making a variable mutable
  let mut mutable_variable = "Mutable";
  
  // Assigning multiple variables
  let (name, age) = ("ElementalX", 20);
  
  // (Global) constant
  const SCREAMING_SNAKE_CASE:i64 = 9;
  

#Comments

// Line Comments
  /*.............Block Comments */
  /// Outer doc comments
  //! Inner doc comments
  

See: Comment

#Functions

fn test(){
    println!("This is a function!");
  }
  
  fn main(){
    test();
  }
  

See: Functions

#Rust Types

#Integer

let mut a: u32 = 8;
  let b: u64 = 877;
  let c: i64 = 8999;
  let d = -90;
  

#Floating-Point

let mut sixty_bit_float: f64 = 89.90;
  let thirty_two_bit_float: f32 = 7.90;
  let just_a_float = 69.69;
  

#Boolean

let true_val: bool = true;
  let false_val: bool = false;
  let just_a_bool = true;
  let is_true = 8 < 5;  // => false
  

#Character

let first_letter_of_alphabet = 'a';
  let explicit_char: char = 'F';
  let implicit_char = '8';
  let emoji = "\u{1f600}";   // => 😀
  

#String Literal

let community_name = "AXIAL";
  let no_of_members: &str = "ten";
  
  println!("The name of the community is {community_name} and it has {no_of_members} members");
  

See: Strings

#Arrays

┌─────┬─────┬─────┬─────┬─────┬─────┐
  | 92  | 97  | 98  | 99  | 98  | 94  |
  └─────┴─────┴─────┴─────┴─────┴─────┘
     0     1     2     3     4     5
  

let array: [i64; 6] = [92,97,98,99,98,94];
  

#Multi-Dimensional Array

     j0   j1   j2   j3   j4   j5
     ┌────┬────┬────┬────┬────┬────┐
  i0 | 1  | 2  | 3  | 4  | 5  | 6  |
     ├────┼────┼────┼────┼────┼────┤
  i1 | 6  | 5  | 4  | 3  | 2  | 1  |
     └────┴────┴────┴────┴────┴────┘
  

let array: [[i64; 6] ;2] = [
              [1,2,3,4,5,6],
              [6,5,4,3,2,1]];
  

#Mutable Array

let mut array: [i32 ; 3] = [2,6,10];
  
  array[1] = 4;
  array[2] = 6;
  

Use the mut keyword to make it mutable.

#Slices

let mut array: [ i64; 4] = [1,2,3,4];
  let mut slices: &[i64] = &array[0..3] // Lower range is inclusive and upper range is exclusive
  
  println!("The elements of the slices are : {slices:?}");
  

#Vectors

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

A vector is declared using the vec! macro.

#Tuples

let tuple = (1, 'A' , "Cool", 78, true);
  

#Rust Strings

#String Literal

let cs:&str = "cheat sheet";
  
  // => Share cheat sheet for developers
  println!("Share {cs} for developers");
  

#String Object

// Creating an empty string object
  let my_string = String::new;
  
  // Converting to a string object
  let S_string = a_string.to_string()
  
  // Creating an initialized string object
  let lang = String::from("Rust");  
  println!("First language is {lang}");
  

#.capacity()

let rand = String::from("Random String");
  rand.capacity()  // => 13
  

Calculates the capacity of the string in bytes.

#.contains()

let name = String::from("ElementalX");
  name.contains("Element") // => true
  

Checks if the substring is contained inside the original string or not.

#Pushing a single character

let mut half_text = String::from("Hal");
  half_text.push('f');    // => Half
  

#Pushing an entire String

let mut hi = String::from("Hey there...");
  hi.push_str("How are you doing??");
  
  // => Hey there...How are you doing??
  println!("{hi}");
  

#Rust Operators

#Comparison Operators

e == f e is equal to f
e != f e is NOT equal to f
e < f e is less than f
e > f e is greater f
e <= f e is less than or equal to f
e >= f e is greater or equal to f

let (e, f) = (1, 100);
  
  let greater = f > e;        // => true
  let less = f < e;           // => false
  let greater_equal = f >= e; // => true
  let less_equal = e <= f;    // => true
  let equal_to = e == f;      // => false
  let not_equal_to = e != f;  // => true
  

#Arithmetic Operators

a + b a is added to b
a - b b is subtracted from a
a / b a is divided by b
a % b Gets remainder of a by dividing with b
a * b a is multiplied with b

let (a, b) = (4, 5);
  
  let sum: i32 = a + b;            // => 9
  let subtractions: i32 = a - b;   // => -1
  let multiplication: i32 = a * b; // => 20
  let division: i32 = a / b;       // => 0
  let modulus: i32 = a % b;        // => 4
  

#Bitwise Operators

Operator Description
g & h Binary AND
g | h Binary OR
g ^ h Binary XOR
g ~ h Binary one's complement
g << h Binary shift left
g >> h Binary shift right

let (g, h) = (0x1, 0x2);
  
  let bitwise_and = g & h;  // => 0
  let bitwise_or = g | h;   // => 3
  let bitwise_xor = g ^ h;  // => 3
  let right_shift = g >> 2; // => 0
  let left_shift = h << 4;  // => 32 
  

#Logical Operators

Example Meaning
c && d Both are true (AND)
c || d Either is true (OR)
!c c is false (NOT)

let (c, d) = (true, false);
  
  let and = c && d;  // => false
  let or  = c || d;  // => true
  let not = !c;      // => false
  

#Compound Assignment Operator

let mut k = 9;
  let mut l = k;
  

Operator Description
k += l Add a value and assign, then k=9
k -= l Substrate a value and assign, then k=18
k /= l Divide a value and assign, then k=9
k *= l Multiply a value and assign, then k=81
k |= l Bitwise OR and assign, then k=89

#Rust Flow Control

#If Expression

let case1: i32 = 81;
  let case2: i32 = 82;
  
  if case1 < case2 {
    println!("case1 is greater than case2");
  }
  

#If...Else Expression

let case3 = 8;
  let case4 = 9;
  
  if case3 >= case4 {
    println!("case3 is better than case4");
  } else {
    println!("case4 is greater than case3");
  }
  

#If...Else...if...Else Expression

let foo = 12;
  let bar = 13;
  
  if foo == bar {
    println!("foo is equal to bar");
  } else if foo < bar {
    println!("foo less than bar");
  } else if foo != bar {
    println!("foo is not equal to bar");
  } else {
    println!("Nothing");
  }
  

#If...Let Expression

let mut arr1:[i64 ; 3] = [1,2,3];
  if let[1,2,_] = arr1{
      println!("Works with array");
  }
  
  let mut arr2:[&str; 2] = ["one", "two"];
  if let["Apple", _] = arr2{
      println!("Works with str array too");
  }
  

let tuple_1 = ("India", 7, 90, 90.432);
  if let(_, 7, 9, 78.99) = tuple_1{
      println!("Works with tuples too");
  }
  
  let tuple_2 = ( 9, 7, 89, 12, "Okay");
  if let(9, 7,89, 12, blank) = tuple_2 {
      println!("Everything {blank} mate?");
  }
  
  let tuple_3 = (89, 90, "Yes");
  if let(9, 89, "Yes") = tuple_3{
      println!("Pattern did match");
  }
  else {
      println!("Pattern did not match");
  }
  

#Match Expression

let day_of_week = 2;
    match day_of_week {
      1 => {
        println!("Its Monday my dudes");
      },
      2 => {
        println!("It's Tuesday my dudes");
      },
      3 => {
        println!("It's Wednesday my dudes");
      },
      4 => {
        println!("It's Thursday my dudes");
      },
      5 => {
        println!("It's Friday my dudes");
      },
      6 => {
        println!("It's Saturday my dudes");
      },
      7 => {
        println!("It's Sunday my dudes");
      },
      _ => {
        println!("Default!")
      }
    };
  }
  

#Nested...If Expression

let nested_conditions = 89;
  if nested_conditions == 89 {
      let just_a_value = 98;
      if just_a_value >= 97 {
          println!("Greater than 97");
      }
  }
  

#For Loop

for mut i in 0..15 {
    i-=1;
    println!("The value of i is : {i}");
  }
  

#While Loop

let mut check =  0;
  while check < 11{
    println!("Check is : {check}");
    check+=1;
    println!("After incrementing: {check}");
  
    if check == 10{
      break; // stop while
    }
  }
  

#Loop keyword

loop {
    println!("hello world forever!");
  }
  

The infinite loop indicated.

#Break Statement

let mut i = 1;
  loop {
    println!("i is {i}");
    if i > 100 {
      break;
    }
    i *= 2;
  }
  

#Continue Statement

for (v, c) in (0..10+1).enumerate(){
    println!("The {c} number loop");
    if v == 9{
      println!("Here we go continue?");
      continue;
    }
    println!{"The value of v is : {v}"};
  }
  

#Rust Functions

#Basic function


  fn print_message(){
    println!("Hello, CareerInEdu!");
  }
  
  fn main(){
    //Invoking a function in Rust.
    print_message();
  }
  

#Pass by Value

fn main()
  {
    let x:u32 = 10;
    let y:u32 = 20;
    
    // => 200
    println!("Calc: {}", cal_rect(x, y));
  }
  fn cal_rect(x:u32, y:u32) -> u32
  {
    x * y
  }
  

#Pass by Reference

fn main(){
    let mut by_ref = 3;      // => 3
    power_of_three(&mut by_ref);
    println!("{by_ref}");  // => 9
  }
  
  fn power_of_three(by_ref: &mut i32){
    // de-referencing is important
    *by_ref = *by_ref * *by_ref;
    println!("{by_ref}");  // => 9
  }
  

#Returns

fn main(){
    let (mut radius, mut pi) = (3.0, 3.14);
    let(area, _perimeter) = calculate (
        &mut radius,
        &mut pi
    );
    println!("The area and the perimeter of the circle are: {area} & {_perimeter}");
  }
  
  fn calculate(radius : &mut f64, pi: &mut f64) -> (f64, f64){
    let perimeter = 2.0 * *pi * *radius;
    let area = *pi * *radius * *radius;
    return (area, perimeter);
  }
  

#Arrays as Arguments

fn main(){
    let mut array: [i32 ; 5] = [1,2,3,4,6];
    print_arrays(array);
    println!("The elements: {array:?}");
  }
  
  fn print_arrays(mut array:[i32; 5]) {
    array[0] = 89;
    array[1] = 90;
    array[2] = 91;
    array[3] = 92;
    array[4] = 93;
    println!("The elements: {array:?}");
  }
  

#Returning Arrays


  fn main(){
    let mut arr:[i32; 5] = [2,4,6,8,10];
    multiply(arr);
    println!("The array is : {:?}", multiply(arr));
  }
  
  fn multiply (mut arr: [i32 ; 5]) -> [i32 ; 5]{
    arr[2] = 90;
    for mut i in 0..5 {
        arr[i] = arr[i] * arr[2];
    }
    return arr;
  }
  

#Misc

#Type Casting

let a_int = 90; // int
  // int to float
  let mut type_cast = (a_int as f64);
  

let orginal: char = 'I';
  // char to int => 73
  let type_casted: i64 = orginal as i64;
  

To perform type-casting in Rust one must use the as keyword.

#Borrowing

let mut foo = 4;
  let mut borrowed_foo = &foo;
  println!("{borrowed_foo}");
  

let mut bar = 3;
  let mut mutable_borrowed_bar = &mut bar;
  println!("{mutable_borrowed_bar}");
  

Here borrowed value borrows the value from value one using & operator.

#De-referencing

let mut borrow = 10;
  let deref = &mut borrow;
  
  println!("{}", *deref);
  

De-referencing in rust can be done using the * operator

#Variable Scope

{
    // The scope limited to this braces
    let a_number = 1;
  }
  println!("{a_number}");
  

This will produce error as the scope of the variable a_number ends at the braces

#Also see