Rust Tutorial Full Course

Here's a simple code snippet that demonstrates Rust syntax for declaring variables, working with different data types, and creating functions:

// Variable declaration and assignment
fn main() {
    let name="John"; // String type (immutable)
    let age: u32=25; // Unsigned 32-bit integer type

    // Printing variables
    println!("Name: {}", name);
    println!("Age: {}", age);

    // Working with different data types
    let is_student=true; // Boolean type (mutable)
    let weight: f64=68.5; // 64-bit floating-point type

    // Conditional statement
    if is_student {
        println!("Student");
    } else {
        println!("Not a student");
    }

    // Function declaration and usage
    let result=add_numbers(10, 20);
    println!("Result: {}", result);
}

// Function definition
fn add_numbers(a: i32, b: i32) -> i32 {
    a + b // Implicit return
}

fn main() { // Integer types let my_integer: i32=42; let my_unsigned_integer: u32=100; // Floating-point types let my_float: f64=3.14; // Boolean type let my_bool: bool=true; // Character type let my_char: char='A'; // String type let my_string: String=String::from("Hello, Rust!"); // Array type let my_array: [i32; 3] = [1, 2, 3]; // Tuple type let my_tuple: (i32, f64, bool) = (10, 3.14, true); // Printing values println!("Integer: {}", my_integer); println!("Unsigned Integer: {}", my_unsigned_integer); println!("Float: {}", my_float); println!("Boolean: {}", my_bool); println!("Character: {}", my_char); println!("String: {}", my_string); println!("Array: {:?}", my_array); println!("Tuple: {:?}", my_tuple); }

• Integer types (i32 and u32) represent signed and unsigned 32-bit integers, respectively.
• Floating-point type (f64) represents a 64-bit floating-point number.
• Boolean type (bool) represents true or false values.
• Character type (char) represents a single Unicode character.
• String type (String) represents a string of characters.
• Array type ([i32; 3]) represents a fixed-size collection of elements of the same type.
• Tuple type ((i32, f64, bool)) represents an ordered collection of elements of different types.