main function and entry point in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the main entry point of a Rust program.

Rust

fn [1]() {
    println!("Hello, world!");
}

Drag options to blanks, or click blank then click option'

Amain

Bstart

Crun

Dbegin

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name other than 'main' for the entry point.

Forgetting to define a function at all.

The main function is the entry point of every Rust program.

2fill in blank

medium

Complete the code to print a message inside the main function.

Rust

fn main() {
    [1]!("Welcome to Rust!");
}

Drag options to blanks, or click blank then click option'

Aecho

Bprintln

Cprint

Dwrite

Attempts:

3 left

💡 Hint

Common Mistakes

Using print which does not add a newline.

Using functions that do not exist in Rust.

The println! macro prints text to the console with a newline.

3fill in blank

hard

Fix the error in the main function declaration.

Rust

fn [1](args: Vec<String>) {
    println!("Arguments count: {}", args.len());
}

Drag options to blanks, or click blank then click option'

Astart

Brun

Centry

Dmain

Attempts:

3 left

💡 Hint

Common Mistakes

Adding parameters to the main function.

Using a different function name for the entry point.

The Rust entry point main function cannot have parameters like args.

4fill in blank

hard

Fill both blanks to create a main function that returns a result.

Rust

fn main() -> [1] {
    println!("Program started");
    [2]
}

Drag options to blanks, or click blank then click option'

AResult<(), Box<dyn std::error::Error>>

Bi32

COk(())

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Returning an integer when a Result is expected.

Not returning anything from a function with a return type.

Rust's main can return a Result to handle errors gracefully. Returning Ok(()) means success.

5fill in blank

hard

Fill the blanks to create a main function that reads command line arguments and prints the first one.

Rust

fn main() {
    let args: Vec<String> = std::env::[1]().collect();
    if args.len() > 1 {
        println!("First argument: {}", args[[2]]);
    } else {
        println!("No arguments provided.");
    }
}

Drag options to blanks, or click blank then click option'

Aargs

B1

C0

Denv

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong function to get arguments.

Accessing the wrong index for the first user argument.

std::env::args() returns an iterator over command line arguments. The first argument is at index 1 because index 0 is the program name.

Practice

1. What is the role of the main function in a Rust program?

easy

A. It compiles the Rust code into machine code.

B. It is the entry point where the program starts running.

C. It stores all the program's variables.

D. It handles user input automatically.

Solution

1. Step 1: Understand the purpose of main

   The main function is special in Rust because it is where the program begins execution.

2. Step 2: Identify the correct role

   Unlike storing variables or compiling code, main runs the first instructions when the program starts.

3. Final Answer:

   It is the entry point where the program starts running. -> Option B

4. Quick Check:

   Entry point = main function = C [OK]

Hint: Remember: Rust programs always start at main() [OK]

Common Mistakes:

• Thinking main stores variables
• Confusing main with compiler role
• Assuming main handles input automatically

2. Which of the following is the correct syntax to declare the main function in Rust?

easy

A. fn main() {}

B. function main() {}

C. def main() {}

D. main() => {}

Solution

1. Step 1: Recall Rust function syntax

   Rust functions start with fn, followed by the name and parentheses.

2. Step 2: Match syntax to main function

   The correct way to declare main is fn main() {}. Other options use syntax from other languages.

3. Final Answer:

   fn main() {} -> Option A

4. Quick Check:

   Rust functions start with fn = D [OK]

Hint: Rust functions always start with fn keyword [OK]

Common Mistakes:

• Using function or def instead of fn
• Missing parentheses after main
• Using arrow syntax not valid in Rust

3. What will be the output of this Rust program?

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

medium

A. Hello, world!

B. println!("Hello, world!");

C. Error: missing semicolon

D. No output

Solution

1. Step 1: Understand println! macro

   The println! macro prints the text inside quotes to the screen followed by a newline.

2. Step 2: Check the program output

   This program calls println!("Hello, world!"); inside main, so it prints Hello, world! exactly.

3. Final Answer:

   Hello, world! -> Option A

4. Quick Check:

   println! prints text = Hello, world! [OK]

Hint: println! prints text exactly as shown [OK]

Common Mistakes:

• Thinking println! prints code literally
• Assuming missing semicolon error
• Expecting no output without return

4. Identify the error in this Rust program:

fn main() {
    println!("Welcome to Rust")
}

medium

A. main function cannot be empty

B. main function must return a value

C. println! macro is misspelled

D. Missing semicolon after println! macro call

Solution

1. Step 1: Check syntax of println! call

   In Rust, statements must end with a semicolon. The println! call is missing a semicolon.

2. Step 2: Verify other options

   Main does not need to return a value, println! is spelled correctly, and main is not empty.

3. Final Answer:

   Missing semicolon after println! macro call -> Option D

4. Quick Check:

   Statements end with ; = A [OK]

Hint: Always end statements with a semicolon in Rust [OK]

Common Mistakes:

• Forgetting semicolon after println!
• Thinking main must return a value
• Assuming spelling error in println!

5. You want to write a Rust program that prints "Start", then "End". Which main function correctly does this?

hard

A. fn main() {
print!("Start");
print!("End");
}

B. fn main() {
println!("Start")
println!("End")
}

C. fn main() {
println!("Start");
println!("End");
}

D. fn main() {
println!("Start");
println!("End")
}

Solution

1. Step 1: Check for correct syntax and output

   fn main() { println!("Start"); println!("End"); } uses println! with semicolons, printing each string on its own line.

2. Step 2: Identify errors in other options

   The version using print! does not add new lines; options missing semicolons cause syntax errors.

3. Final Answer:

   fn main() { println!("Start"); println!("End"); } -> Option C

4. Quick Check:

   Use println! with semicolons for separate lines = B [OK]

Hint: Use println! with semicolons for separate lines [OK]

Common Mistakes:

• Using print! instead of println!
• Missing semicolons after println! calls
• Expecting print! to add new lines