rust basic [2]

Author: yogithesymbian

readme.md

@@ -0,0 +1,62 @@
+# RUST BASIC Powered By AI
+
+Welcome to the **Rust Basics** repository, a collection of foundational Rust programming topics. This project is designed to help learners get started with Rust by exploring key concepts such as variables, data types, control flow, and more.
+
+## Overview
+
+Rust is a systems programming language that emphasizes performance, safety, and concurrency. This repository will guide you through some of the most important and basic features of the language.
+
+## Topics Covered
+
+Here is an organized list of topics with a brief description for each:
+
+| Topic                    | Description                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------------ |
+| **Hello World**          | A simple "Hello, World!" program to get started with Rust.                                 |
+| **Cargo**                | Learn how to use Cargo, the Rust package manager and build system.                         |
+| **Unit Test**            | Writing and running unit tests to ensure code correctness.                                 |
+| **Variable**             | Understanding variable declarations, mutability, and scoping.                              |
+| **Comment**              | Using comments in Rust code for clarity and documentation.                                 |
+| **Data Type**            | Exploring the basic data types available in Rust (e.g., integers, floats, booleans, etc.). |
+| **Number**               | Working with numeric types, including integer and floating-point numbers.                  |
+| **Numeric Operations**   | Performing basic arithmetic operations like addition, subtraction, and multiplication.     |
+| **Boolean**              | Understanding boolean values and their role in logic and conditions.                       |
+| **Comparison Operators** | Using comparison operators (e.g., `==`, `!=`, `<`, `>`) to compare values.                 |
+| **Boolean Operators**    | Using logical boolean operators (AND, OR, NOT) to combine boolean values.                  |
+| **Char**                 | Working with characters and understanding the char data type.                              |
+| **Array**                | Introduction to arrays in Rust and how to work with them.                                  |
+| **Constant**             | Defining and using constants in Rust to store fixed values.                                |
+| **Variable Scope**       | Understanding the scope of variables and how they affect code behavior.                    |
+
+## How to Run the Code
+
+To run the examples in this repository:
+
+1. Clone the repository to your local machine:
+
+   ```bash
+   git clone https://github.com/yogithesymbian/rust_basic.git
+   cd rust_basic
+   ```
+
+2. Make sure you have Rust installed on your machine. If not, you can install it from [Rust's official site](https://www.rust-lang.org/learn/get-started).
+
+3. Each topic is separated into a `src` file (e.g., `src/hello_world.rs`, `src/cargo.rs`). You can compile and run the code in any of these files with Cargo:
+
+   ```bash
+   cargo run --example hello_world
+   ```
+
+   Replace `hello_world` with the name of any example you want to run.
+
+## Contributing
+
+Feel free to fork the repository, make changes, and create pull requests to contribute new examples, improve documentation, or fix bugs.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+Thank you for exploring Rust with this basic guide! 🎉

src/array.rs

@@ -0,0 +1,12 @@
+pub fn main() {
+    // Fixed-size array with 5 elements of type i32
+    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
+
+    println!("First element: {}", numbers[0]);
+    println!("Second element: {}", numbers[1]);
+
+    // Iterating over the array
+    for number in numbers.iter() {
+        println!("Array element: {}", number);
+    }
+}

src/char.rs

@@ -0,0 +1,15 @@
+pub fn main() {
+    let char1: char = 'R';
+    let char2: char = 'u';
+    let char3: char = 's';
+    let char4: char = 't';
+
+    println!("Character 1: {}", char1);
+    println!("Character 2: {}", char2);
+    println!("Character 3: {}", char3);
+    println!("Character 4: {}", char4);
+
+    // Combining characters into a string
+    let word = format!("{}{}{}{}", char1, char2, char3, char4);
+    println!("Word formed: {}", word);
+}

src/constant.rs

@@ -0,0 +1,6 @@
+// Define a constant
+const MAX_POINTS: u32 = 100_000;
+
+pub fn main() {
+    println!("The maximum points are: {}", MAX_POINTS);
+}

src/main.rs

@@ -1,7 +1,11 @@
+mod array;
+mod char;
+mod constant;
 mod data_types;
 mod numbers;
 mod operator_boolean;
 mod operators_comparison;
+mod variable_scope;
 mod variables;
 
 fn main() {
@@ -17,4 +21,12 @@ fn main() {
     operators_comparison::main();
     println!("\n=========boolean_operator=========");
     operator_boolean::main();
+    println!("\n=========char=========");
+    char::main();
+    println!("\n=========array=========");
+    array::main();
+    println!("\n=========constant=========");
+    constant::main();
+    println!("\n=========variable scope=========");
+    variable_scope::main();
 }

src/variable_scope.rs

@@ -0,0 +1,14 @@
+pub fn main() {
+    let x: i32 = 5; // x is valid within the main function's scope
+    println!("x inside main: {}", x);
+
+    {
+        let y: i32 = 10; // y is valid inside this inner scope
+        println!("y inside inner scope: {}", y);
+    }
+
+    // println!("y outside inner scope: {}", y); // This will cause a compile-time error
+
+    // x is still accessible here
+    println!("x outside inner scope: {}", x);
+}