Common Programming Concepts

Constant

• Constants may be set only to a constant expression, not the result of a value that could only be computed at runtime.

Shadowing

• The difference between mut and shadowing is that the shadowing is in fact creating a new variable when we use let keyword. So we can change the type of the value but reuse the same name.
  Ex. (shadowing)

let spaces = "    ";
let spaces =. spaces.len();

Ex. (mut; will cause compile-time error)

let spaces = "    ";
spaces = spaces.len();

Data Types

• Scalar

integers, floating-point, Booleans, and chars

• Integers

• Integer Literals

• Compound

  • Tuple
  • Array

• Tuple

  A general way of grouping together a number of values with a variety of types into one compound type with fixed length.

  fn main() { let tup: (i32, f64, u8) = (500, 6.4, 1); }
  
  fn main() {
     let tup = (500, 6.4, 1);
     let (x, y, z) = tup;
  }
  

• Array

  Array values are allocated on the stack, rather than the heap. Fixed number of elements

let a: [i32; 5] = [1, 2, 3, 4, 5];
let b: [3; 5]; // [3, 3, 3, 3, 3]

Function

The order of function definitions doesn't really matter. Say fuction1() calls function2(). As long as function2() can be "seen" by function1() within the scope, function2() definition can be written before or after fuction1()

functions can have `parameters, which are special variables that are part of a function's signature.

Technically, the concrete values for the parameters are called arguments

In function signatures, you must declare the type of each parameter

• Statements are instructions that perform some action and DO NOT RETURN a vaue
• Expressions evaluate to a resultant value

In Rust, the return value of the function is synonymous with the value of the final expression in the block of the body of a function.