Introduction to Rust - Lesson 2

Comments are notes in your source code that the compiler ignores — they are written for humans, not the computer. Rust supports three styles of comments: single-line comments with //, block comments with /* ... */, and documentation comments with ///. Comments help you explain what your code does, why you made certain decisions, and how to use your functions. They are invaluable when you revisit your own code months later or when other people need to understand your work. Block comments can span multiple lines, making them useful for temporarily disabling larger sections of code or writing longer explanations. Documentation comments (///) are special because Rust can generate HTML documentation from them using the rustdoctool. As a beginner, you should practice adding comments to your programs — it will make you a clearer thinker and a better communicator.

fn main() {
    // I am a comment
    println!("Hello");
}

• The two forward slashes // start a single-line comment in Rust.
• Everything after // on the same line is ignored by the compiler.
• Comments are written for people to read, not for the computer to execute.
• The println!("Hello") statement runs normally because the comment above it does not affect execution.
• The output is Hello— the comment produces no output.

fn main() {
    /* println!("A");
       println!("B"); */
    println!("Hi");
}

• /* starts a block comment and */ ends it.
• Block comments can span multiple lines, making them a good choice for longer explanations.
• Code inside a block comment is ignored, so println!("A") and println!("B") do not run.
• Block comments are also useful for temporarily disabling a chunk of code during debugging.
• The only line that executes is println!("Hi"), so the output is Hi.

fn main() {
    println!("A"); // prints letter A
    println!("B"); // prints letter B
}

• A comment can appear on the same line as code — these are called inline comments.
• The comment // prints letter A describes what the preceding line does.
• Inline comments help clarify the purpose of a specific line without cluttering the next line.
• The code still runs normally: both println! calls execute.
• The output is A on one line and B on the next line.

fn main() {
    // println!("Hidden");
    println!("Visible");
}

• Placing // at the start of a line of code is called commenting out that line.
• // println!("Hidden"); prevents the println! from running.
• Commenting out code is a common technique during debugging to isolate problems.
• Only println!("Visible") executes, so the output is Visible.
• To restore the commented line, remove the // prefix.

/// Prints a friendly greeting
fn greet() {
    println!("Hello!");
}
fn main() {
    greet();
}

• Three forward slashes /// create a documentation comment (also called a doc comment).
• Doc comments appear immediately before the item they describe, such as a function or struct.
• Rust’s rustdoc tool can read /// comments and generate HTML documentation.
• Like other comment styles, doc comments are ignored during compilation.
• The greet() function runs normally and prints Hello!.

fn main() {
    // Single line
    /* Block */
    println!("Done");
}

• You can freely mix single-line comments // and block comments /* */ in the same program.
• Both comment styles are completely ignored at runtime — they exist only in the source code.
• The comment // Single line occupies one line, and /* Block */ appears on its own line.
• Neither comment produces any output or affects the program’s behavior.
• The only output is Done from the println! call.