Rust Learning Day2

Data Type

fn main() {
    // Scalar data types: integers, floats, characters, booleans
    // Default integer type is i32 (32-bit signed)
    // Default float type is f64 (64-bit)

    // Integers
    let x = 42; // i32 by default
    let y: i64 = 123456789; // Explicitly specifying i64
    println!("Integer x: {x}, Integer y: {y}");

    // Floats
    let z = 3.14; // f64 by default
    let w: f32 = 2.718; // Explicitly specifying f32
    println!("Float z: {z}, Float w: {w}");

    // Characters: use single quotes, and they represent Unicode scalar values
    let c = 'z';
    let heart_eyed_cat = '😻';
    println!("Character c: {c}, Emoji: {heart_eyed_cat}");

    // Booleans
    let t = true;
    let f: bool = false; // Explicitly specifying the type
    println!("Boolean t: {t}, Boolean f: {f}");

    // Compound data types: tuples and arrays
    // Tuples: fixed size, can contain elements of different types

    // Two ways to access tuple elements
    let tup: (i32, f64, i32) = (400, 6.5, 1);

    // Destructuring the tuple
    let (_, y, _) = tup;
    println!("The value of y in tuple is {y}");

    // Accessing tuple elements by index
    let first = tup.0;
    println!("The first value of tup is {first}");

    // Arrays: fixed size, all elements are of the same type
    // `a` contains five i32 elements
    let a = [1, 2, 3, 4, 5];

    // `b` contains six elements, all with the value 3
    let b = [3; 6];

    // Accessing array elements is similar to other programming languages
    let first = a[0];
    println!("The first value of a is {first}");
}

Explanation:

1. Scalar Data Types:

   • Integers:
     • Default type is i32, which is a 32-bit signed integer.
     • Example of explicit type declaration: let y: i64 = 123456789;.
   • Floats:
     • Default type is f64, which is a 64-bit floating-point number.
     • Example of explicit type declaration: let w: f32 = 2.718;.
   • Characters:
     • Characters are specified using single quotes and represent Unicode scalar values.
     • Example: let c = 'z'; and let heart_eyed_cat = '😻';.
   • Booleans:
     • Boolean values can be true or false.
     • Example: let t = true; and let f: bool = false;.

2. Compound Data Types:

   • Tuples:
     • Tuples have a fixed size and can contain elements of different types.
     • You can access elements by destructuring: let (_, y, _) = tup;.
     • Or by indexing: let first = tup.0;.
   • Arrays:
     • Arrays have a fixed size and all elements must be of the same type.
     • You can initialize arrays with specific values: let a = [1, 2, 3, 4, 5];.
     • Or with a repeated value: let b = [3; 6];.