updated repo structure

Author: hitesh-bhatnagar

.github/workflows/ci.yml

@@ -2,32 +2,30 @@ name: Rust CI
 
 on:
   push:
-    branches: [ main ]
   pull_request:
-    branches: [ main ]
-
-env:
-  CARGO_TERM_COLOR: always
 
 jobs:
   build:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Checkout repository
+      - name: Checkout code
         uses: actions/checkout@v4
 
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
 
-      - name: Build
-        run: cargo build --verbose
-
-      - name: Run tests
-        run: cargo test --verbose
-
       - name: Check formatting
-        run: cargo fmt --all -- --check
+        run: cargo fmt -- --check
 
       - name: Run Clippy
-        run: cargo clippy --all-targets
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Check project
+        run: cargo check --workspace
+
+      - name: Check examples
+        run: cargo check --examples
+
+      - name: Run tests
+        run: cargo test --workspace

examples/error_handling.rs

@@ -0,0 +1 @@
+

examples/functions.rs

@@ -1,15 +1,16 @@
 // use std::io;
 use std::io::{self, Write};
 
-fn add(x: i32, y: i32) -> i32{
-    x+y         // NOTE : In rust no ; means return 
+fn add(x: i32, y: i32) -> i32 {
+    x + y // NOTE : In rust no ; means return
 }
 
-fn prod(x: i32, y: i32) -> i32{
-    return x*y; // can work as well
+fn prod(x: i32, y: i32) -> i32 {
+    return x * y; // can work as well
 }
 
-fn grade (score : u32) -> &'static str{ // refers to a reference where the borrowed data is valid for the entire duration of the running program
+fn grade(score: u32) -> &'static str {
+    // refers to a reference where the borrowed data is valid for the entire duration of the running program
     match score {
         90..=100 => "A",
         80..=89 => "B",
@@ -19,60 +20,59 @@ fn grade (score : u32) -> &'static str{ // refers to a reference where the borro
     }
 }
 
-fn main() -> io::Result<()>{            // this is for safety so that program do not panic
+fn main() -> io::Result<()> {
+    // this is for safety so that program do not panic
     println!("add(5,3) = {}", add(5, 3));
     println!("prod(5,3) = {}", prod(5, 3));
     println!("grade(95) = {}", grade(95));
-    
+
     // Conditional expression
     let number = 67;
-    
-    if number > 5{
+
+    if number > 5 {
         println!("{} is greater than 5", number);
-    }else{
+    } else {
         println!("{} is less than 5 ", number);
     }
-    
+
     // In Rust you can assign if/else value to a variable
-    let message = if number > 5{"big"} else {"small"};
+    let message = if number > 5 { "big" } else { "small" };
     println!("Number is {}", message);
-    
+
     // Loops
     let mut count = 0;
     let result = loop {
         count += 1;
-        if count == 5{
-            break count*2;
+        if count == 5 {
+            break count * 2;
         }
     };
-    
+
     println!("Loop result = {}", result);
-    
+
     count = 0;
-    while count <5{
+    while count < 5 {
         count += 1;
-        
     }
     println!("While loop result = {}", count);
-    
+
     count = 0;
     for i in 0..=5 {
         count += i;
     }
     println!("For loop result = {}", count);
-    
+
     // MATCH
-    
+
     let cmd = "echo";
     match cmd {
         "quit" => println!("Exiting"),
         "help" => println!("help"),
         "echo" => println!("Hello world"),
         _ => println!("Unknown cmd"),
-        
     }
-    
-//  MATCH can be used inside a variable     
+
+    //  MATCH can be used inside a variable
     let code = 404;
     let meaning = match code {
         200 => "OK",
@@ -81,30 +81,30 @@ fn main() -> io::Result<()>{            // this is for safety so that program do
         _ => "Unknown",
     };
     println!("HTTP {} : {}", code, meaning);
-    
+
     println!("Score 95 = grade {}", grade(95));
     println!("Score 83 = grade {}", grade(83));
     println!("Score 60 = grade {}", grade(60));
-    
-    
+
     // PART 5 : Reading user input
     println!("Type a command (echo / help / exit");
-    
+
     let mut input = String::new();
-    io::stdout().flush()?;  // ensures the prompt apprears before the program waits for input
+    io::stdout().flush()?; // ensures the prompt apprears before the program waits for input
     io::stdin().read_line(&mut input)?;
-    
-    input= input.trim().to_string();
-    
-    if input.is_empty(){
+
+    input = input.trim().to_string();
+
+    if input.is_empty() {
         println!("Please enter a command");
     } else {
-        match input.as_str() {      // when matching against 'input' use as_str() to ensure the type is correct
+        match input.as_str() {
+            // when matching against 'input' use as_str() to ensure the type is correct
             "echo" => println!("Hello world "),
             "help" => println!("Available commands : echo, help, exit"),
             "quit" => println!("Exiting ..."),
             other => println!("Unknown Command: {}", other),
         }
     }
     Ok(())
-}
+}

examples/struct_enums.rs

@@ -0,0 +1 @@
+

examples/variables.rs

@@ -1,56 +1,52 @@
 fn main() {
-    
     // PART 1 : Immutable vs Mutable Variables
     let x = 5;
     let mut y = 10;
-    y = 20 ;
-    
+    y = 20;
+
     println!("x = {} ", x);
     println!("y = {} ", y);
-    
+
     // PART 2 : Data Types
-    
+
     let age: u32 = 25; // unsigned 32-bit integer -- can't be negative
     let count: i32 = 100; // signed 32=bit integer -- can be negative or positive
     let big: i64 = 1_000_000; // underscores make numbers readable
     let pi: f64 = 3.14159; // float
     let flag: bool = true; // boolean
     let letter: char = 'A'; // character
     let name: &str = "Hitesh Bhatnagar"; // fixed text known at compile time
-    
+
     let greeting: String = String::from("Hello, Universe"); // owned text - flexible
-    
-    // PART 3: Shadowing 
-    
+
+    // PART 3: Shadowing
+
     // shadowing allows redeclare a variable with the same name
     // Each let x creates a BRAND NEW VARIABLE
     let x = 5;
-    let x = x*2; // new x created, old x is deleted
-    let x = x+3; // another new x
-    
+    let x = x * 2; // new x created, old x is deleted
+    let x = x + 3; // another new x
+
     println!("Shadowed x  = {}", x); // 13
-    
+
     let spaces = "   "; // &str type
-    let spaces = spaces.len(); // now usize ( a number ) -- totally fine 
+    let spaces = spaces.len(); // now usize ( a number ) -- totally fine
     println!("spaces = {}", spaces); // 3
-    
-    // PART 4: mut V/S Shadowing 
-    
+
+    // PART 4: mut V/S Shadowing
+
     let mut score = 0;
     score = 20;
     println!(" score = {}", score);
-    
+
     // Shadowing => Creates new variable, can change VALUE & TYPE
     let status = "inactive";
     println!("status = {}", status);
     let status = true; // changes type from &str to bool
     println!("status = {}", status);
-    
+
     // PART5 : Constants
-    
+
     const EULER_NUMBER: f32 = 2.71828;
-    println!("Max euler_num= {}", EULER_NUMBER );
-    
-    
-    
-}
+    println!("Max euler_num= {}", EULER_NUMBER);
+}

src/main.rs

@@ -1,6 +1,6 @@
-fn main(){
+fn main() {
     /*
      * Run examples for each topic to learn and see the results.
      */
     println!("Happy Learning :)")
-}
+}