Data Type
            
            
              rust
              
              
            
          
          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:
- 
Scalar Data Types: - Integers:
- Default type is i32, which is a 32-bit signed integer.
- Example of explicit type declaration: let y: i64 = 123456789;.
 
- Default type is 
- Floats:
- Default type is f64, which is a 64-bit floating-point number.
- Example of explicit type declaration: let w: f32 = 2.718;.
 
- Default type is 
- Characters:
- Characters are specified using single quotes and represent Unicode scalar values.
- Example: let c = 'z';andlet heart_eyed_cat = '😻';.
 
- Booleans:
- Boolean values can be trueorfalse.
- Example: let t = true;andlet f: bool = false;.
 
- Boolean values can be 
 
- Integers:
- 
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];.
 
 
- Tuples: