Rust Cheat Sheet

{
  // 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

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

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

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.

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.

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;
}

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:?}");
}

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);
}

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
}

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
}

fn print\_message(){
  println!("Hello, QuickRef.ME!");
}
fn main(){
  //Invoking a function in Rust.
  print\_message();
}

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}"};
}

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

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

The infinite loop indicated.

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

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

let nested\_conditions = 89;
if nested_conditions == 89 {
    let just\_a\_value = 98;
    if just_a_value >= 97 {
        println!("Greater than 97");
    }
}

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!")
    }
  };
}

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");
}

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");
}

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

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

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

| !c | c is false (NOT) |

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

| 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 

| 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

| 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

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

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

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

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

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

Calculates the capacity of the string in bytes.

// 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}");

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

let some\_vector = vec![1,2,3,4,5]; 

A vector is declared using the vec! macro.

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:?}");

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

Use the mut keyword to make it mutable.

     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]];

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

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

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

let first\_letter\_of\_alphabet = 'a';
let explicit\_char: char = 'F';
let implicit\_char = '8';
let emoji = "\u{1f600}";   // => 😀

let true\_val: bool = true;
let false\_val: bool = false;
let just\_a\_bool = true;
let is\_true = 8 < 5;  // => false

let mut sixty\_bit\_float: f64 = 89.90;
let thirty\_two\_bit\_float: f32 = 7.90;
let just\_a\_float = 69.69;

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

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

See: Functions

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

See: Comment

// 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;

// 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");

// 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}!");

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

#Compiling and Running

$ rustc Hello\_World.rs
$ ./Hello\_World
Hello, World!