Common Programming Concepts

Common programming concepts are the fundamental building blocks and ideas that are prevalent across most programming languages, regardless of their specific syntax or paradigm. Understanding these concepts is crucial for anyone learning to program, as they form the mental model for how programs work and how to solve problems computationally.

Here are some of the most fundamental concepts:

1. Variables and Data Types:
* Variables: Named storage locations that hold data. They allow programs to store, retrieve, and manipulate information. In many languages, including Rust, variables can be mutable (their value can change) or immutable (their value cannot change after being set).
* Data Types: Classify the kind of value a variable can hold. Common types include:
* Integers: Whole numbers (e.g., `5`, `-10`).
* Floating-Point Numbers: Numbers with decimal points (e.g., `3.14`, `-0.5`).
* Booleans: Represent truth values, either `true` or `false`.
* Characters: Single letters, symbols, or numbers (e.g., `'a'`, `'!'`).
* Strings: Sequences of characters (e.g., "Hello, World!").

2. Operators:
* Symbols that perform operations on values and variables.
* Arithmetic Operators: `+`, `-`, `*`, `/`, `%` (modulo).
* Comparison Operators: `==` (equals), `!=` (not equals), `>`, `<`, `>=`, `<=` (greater than, less than, etc.). These return boolean values.
* Logical Operators: `AND` (`&&`), `OR` (`||`), `NOT` (`!`). Used to combine or negate boolean expressions.

3. Control Flow:
* Determines the order in which statements are executed.
* Conditional Statements (`if-else`): Allow a program to make decisions. Code blocks are executed only if certain conditions are met.
* `if`: Executes a block if a condition is true.
* `else if`: Provides additional conditions to check if the preceding `if` or `else if` conditions were false.
* `else`: Executes a block if none of the preceding conditions were true.
* Looping Statements (`for`, `while`, `loop`):
* `for` loop: Iterates over a sequence (e.g., a range of numbers, elements in a collection).
* `while` loop: Continues to execute a block of code as long as a specified condition remains true.
* `loop` (in Rust, often "do-while" equivalent in other languages): An infinite loop that continues indefinitely until explicitly told to `break`.

4. Functions:
* Reusable blocks of code that perform a specific task. They promote modularity, making programs easier to read, test, and maintain.
* Can accept input values (parameters/arguments) and can return an output value.

5. Collections/Data Structures (Basic):
* Ways to organize and store multiple pieces of data.
* Arrays/Vectors: Ordered collections of elements of the same type (fixed-size arrays or dynamically sized vectors).
* Tuples: Fixed-size collections of values of different types.

Mastering these concepts provides a solid foundation for learning any new programming language and for building robust and efficient software.

// 1. Variables and Data Types
// Immutable variable (default in Rust)
let immutable_greeting: &str = "Hello, Rustacean!";
println!("Immutable Greeting: {}", immutable_greeting);

// Mutable variable (declared with `mut`)
let mut mutable_count: i32 = 10;
println!("Initial Mutable Count: {}", mutable_count);
mutable_count = 20; // Value can be changed
println!("Updated Mutable Count: {}", mutable_count);

// Different Data Types
let integer_number: i32 = 100;
let float_number: f64 = 3.14159;
let is_active: bool = true;
let character: char = 'A';
let long_string: String = String::from("This is a longer string."); // Owned string

println!("Integer: {}, Float: {}, Bool: {}, Char: {}, String: {}",
         integer_number, float_number, is_active, character, long_string);

// 2. Operators
let a = 10;
let b = 3;
println!("Arithmetic: {} + {} = {}", a, b, a + b);
println!("Comparison: {} > {} is {}", a, b, a > b);
println!("Logical: {} && {} is {}", is_active, (a > b), is_active && (a > b));

// 3. Control Flow

// Conditional Statement (if-else if-else)
let temperature = 25;
if temperature < 0 {
    println!("It's freezing!");
} else if temperature >= 0 && temperature < 15 {
    println!("It's a bit chilly.");
} else if temperature >= 15 && temperature < 30 {
    println!("It's pleasant.");
} else {
    println!("It's hot!");
}

// Loop: for loop (iterating over a range)
println!("Counting with for loop:");
for i in 1..=5 { // Inclusive range from 1 to 5
    println!("Number: {}", i);
}

// Loop: while loop
let mut counter = 0;
println!("Counting with while loop:");
while counter < 3 {
    println!("While counter: {}", counter);
    counter += 1;
}

// Loop: infinite loop with break
let mut break_counter = 0;
println!("Counting with loop (infinite with break):");
loop {
    println!("Loop counter: {}", break_counter);
    if break_counter == 2 {
        break; // Exit the loop
    }
    break_counter += 1;
}

// 4. Functions
// Define a function that adds two numbers
fn add_numbers(num1: i32, num2: i32) -> i32 {
    num1 + num2 // Rust functions implicitly return the last expression's value if no semicolon
}

let sum = add_numbers(5, 7);
println!("Sum of 5 and 7 is: {}", sum);

// Another function example
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

greet("Alice");

// 5. Collections (Basic)

// Vector (Rust's dynamic array)
let mut numbers_vec: Vec<i32> = vec![10, 20, 30, 40, 50];
println!("Vector elements: {:?}", numbers_vec); // Using {:?} for debug print
numbers_vec.push(60); // Add an element
println!("Vector after push: {:?}", numbers_vec);

// Accessing elements
if let Some(first_element) = numbers_vec.get(0) {
    println!("First element: {}", first_element);
}
// Tuples (fixed-size collection of different types)
let person_info: (&str, i32, bool) = ("Bob", 30, true);
println!("Person Info: Name: {}, Age: {}, Is Active: {}", person_info.0, person_info.1, person_info.2);