singularity

singularity 🔎

• Chapter 3: Common Programming Concepts
  • Variables and Mutability
    • Constants
  • Data Types
    • Scalar Types [int, float, char, bool]
    • Compound Types [tuple, array]
  • Control Flow
    • loop
    • Loop labels
    • while
    • for

Chapter 3: Common Programming Concepts

Variables and Mutability

Constants

• Constants are valid for the entire time a program runs, within the scope in which they were declared.

• const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

Data Types

• Rust is a statically typed language

• compiler can usually infer what type we want to use based on the value and how we use it.

• In cases when many types are possible, such as when we converted a String to a numeric type using parse in [02-guessing-game], we must add a type annotation

  • let guess: u32 = "42".parse().expect("Not a number!");

Scalar Types [int, float, char, bool]

• Integer Overflow

  • debug builds check for it

  • release builds wrap around

  • for explicit checking see wrapping_*, checked_*, overflowing_*, saturating_* families of methods

• Unicode scalar values range from U+0000 to U+D7FF and U+E000 to U+10FFFF inclusive

Compound Types [tuple, array]

• We create a tuple by writing a comma-separated list of values inside parentheses

let tup: (i32, f64, u8) = (500, 6.4, 1);

• To get the individual values out of a tuple, we can use pattern matching to destructure a tuple value

let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("The value of y is: {y}");

• We can also access a tuple element directly by using a period (.) followed by the index of the value we want to access.

let x: (i32, f64, u8) = (500, 6.4, 1);
let five_hundred = x.0;
let six_point_four = x.1;
let one = x.2;

Control Flow

loop

• One of the uses of a loop is to retry an operation you know might fail,
  • such as checking whether a thread has completed its job
  • to pass the result of that operation out of the loop to the rest of your code

let result = loop {
  counter += 1;
  if counter == 10 {
    break counter * 2;
  }
};

Loop labels

• If you have loops within loops, break and continue apply to the innermost loop at that point.

• You can optionally specify a loop label on a loop that you can then use with break or continue

• Loop labels must begin with a single quote. Here’s an example with two nested loops:

  • first break that doesn’t specify a label will exit the inner loop only.
  • The break 'counting_up; statement will exit the outer loop

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;
        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }

            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }
        count += 1;
    }
    println!("End count = {count}");
}

Loop labels

• When continue is encountered, the current iteration is terminated, returning control to the loop head, typically continuing with the next iteration.

while

while number != 0 {
  println!("{number}!");
  number -= 1;
}

for

let a = [10, 20, 30, 40, 50];
for element in a {
  println!("the value is: {element}");
}

for number in (1..4).rev() {
  println!("{number}!");
}