Rust Syntax and First Program

# CHAPTER 3

Rust Syntax and First Program #

1. Chapter Introduction #

2. Learning Objectives #

• Write and understand a basic Rust program.

• Understand the role of the main function.

• Differentiate between a regular function and a Macro (like println!).

• Write single-line and multi-line comments.

• Understand Rust's block scoping with curly braces {}.

3. The "Hello, World!" Program #

fn main() {
    println!("Hello, world!");
}

Let's break this down step-by-step:

#### A. The fn Keyword In Rust, fn stands for "function". It is used to declare a new function.

#### B. The main Function main is special. It is the entry point of every executable Rust program. When you run your program, the operating system looks for the main function and executes the code inside it first.

#### C. Curly Braces {} The curly braces {} define a "block" of code. Everything between the opening { and the closing } belongs to the main function.

#### D. The println! Macro println! prints text to the screen and adds a new line at the end. Notice the exclamation mark (!)? That means println! is a Macro, not a regular function. Macros in Rust are essentially code that writes more code for you during compilation. We will explore macros deeply later, but for now, remember: if you see a !, it's a macro!

#### E. The Semicolon ; Rust is an expression-based language, but it uses semicolons ; to end statements. Forgetting a semicolon is a common beginner mistake and will cause a compiler error.

4. Running the Program #

cargo run

*Output:*

Hello, world!

5. Comments in Rust #

Single-line comments start with //:

// This is a comment. It explains the code below.
fn main() {
    println!("Hello"); // This is an inline comment
}

Multi-line comments (block comments) use /* and */:

/* 
   This is a multi-line comment.
   It can span across several lines.
   Useful for temporarily disabling large chunks of code.
*/
fn main() {
    println!("Hello");
}

6. Formatting Strings #

fn main() {
    // Basic placeholder
    println!("My favorite number is {}", 42);
    
    // Multiple placeholders
    println!("My name is {} and I am {} years old", "Alice", 28);
    
    // Positional arguments (0-indexed)
    println!("{0} is a language, {1} is a language, but {0} is safer.", "Rust", "C++");
    
    // Named arguments
    println!("{subject} is {adjective}", subject="Rust", adjective="fast");
}

7. Mini Project: Simple Output App #

fn main() {
    // Print a header
    println!("======================");
    println!("   DEVELOPER PROFILE  ");
    println!("======================");
    
    // Print formatted data
    println!("Name: {}", "John Doe");
    println!("Role: {}", "Backend Engineer");
    println!("Language: {}", "Rust");
    
    /* 
       End of program.
       The OS will close the app now.
    */
}

8. Common Mistakes #

• Forgetting the ! on println: If you write println("Hello");, the compiler will complain that the function println does not exist. It must be println!("Hello");.

• Forgetting the semicolon ;: If you leave off the semicolon, the compiler might think the statement hasn't finished, leading to confusing errors on the next line.

• Using single quotes for strings: In Rust, "Hello" (double quotes) is a String. 'A' (single quotes) is a single Character. You cannot use single quotes for multiple letters!

9. Best Practices #

• Indentation: Standard Rust style uses 4 spaces for indentation. cargo fmt will automatically format this for you.

• Snake Case: Rust strongly prefers snakecase (lowercase with underscores) for function and variable names, not camelCase. (e.g., fn calculatetax() instead of fn calculateTax()).

10. Exercises #

1. 1. Write a program that uses a multi-line comment at the top to describe the file.

1. 2. Use println! to output your favorite movie, book, and food using {} placeholders.

1. 3. Try removing a semicolon and running cargo run to see what a Rust compiler error looks like.

11. MCQs with Answers #

12. Interview Questions #

• Q: What is the difference between a function and a macro in Rust?

• Q: Why does Rust use println! as a macro instead of a standard function? (Hint: standard functions in Rust cannot take a variable number of arguments, but macros can generate code to handle it).

13. FAQs #

• Why does the first compile take longer? The first time you run cargo run, Rust compiles the standard library and your code. Subsequent runs only recompile the parts you changed, which is much faster.

14. Summary #

15. Next Chapter Recommendation #