Formatting output in Rust - Step-by-Step Execution

Concept Flow - Formatting output

Start

↓

Prepare data

↓

Choose format string

↓

Apply formatting

↓

Print or store output

↓

End

This flow shows how Rust takes data, applies a format string, and produces formatted output.

Execution Sample

Rust

fn main() {
    let name = "Alice";
    let age = 30;
    println!("Name: {}, Age: {}", name, age);
}

This code prints a formatted string with a name and age using placeholders.

Execution Table

Step	Action	Format String	Values	Result
1	Start main function
2	Assign variable name			name = "Alice"
3	Assign variable age			age = 30
4	Call println! macro	Name: {}, Age: {}	name="Alice", age=30	Prints: Name: Alice, Age: 30
5	End main function

💡 Program ends after printing formatted output.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
name	uninitialized	"Alice"	"Alice"	"Alice"
age	uninitialized	uninitialized	30	30

Key Moments - 2 Insights

Why do we use curly braces {} in the format string?

Curly braces {} are placeholders that tell Rust where to insert the values, as shown in step 4 of the execution_table.

What happens if the number of placeholders doesn't match the number of values?

Rust will give a compile-time error because the println! macro expects the number of placeholders to match the number of values, as implied in step 4.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is printed?

A Name: Alice, Age: 30

B Name: {}, Age: {}

C Alice 30

D Name: name, Age: age

💡 Hint

Check the Result column in step 4 of the execution_table.

According to variable_tracker, what is the value of 'age' after step 3?

A uninitialized

B 30

C "Alice"

D 0

💡 Hint

Look at the 'age' row under 'After Step 3' in variable_tracker.

If we add another placeholder {} in the format string but do not add a value, what will happen?

A The program prints an extra empty space

B The program ignores the extra placeholder

C Rust gives a compile-time error

D The program crashes at runtime

💡 Hint

Refer to key_moments about placeholder and value count matching.

Concept Snapshot

Rust formatting output uses curly braces {} as placeholders.
Use println!("text {}, {}", val1, val2) to print formatted text.
The number of placeholders must match the number of values.
Rust checks this at compile time to avoid errors.
This helps create readable and dynamic output.

Full Transcript

This example shows how Rust formats output using the println! macro. First, variables name and age are assigned values. Then, the println! macro is called with a format string containing curly braces {} as placeholders. The values of name and age are inserted into these placeholders in order. The program prints the final string: "Name: Alice, Age: 30". If the number of placeholders and values do not match, Rust will give a compile-time error. This ensures safe and clear formatting of output.

Practice

1. What does the placeholder {} do in Rust's println! macro?

easy

A. It comments out the line in the code.

B. It inserts the value of a variable or expression into the string.

C. It creates a new variable inside the string.

D. It repeats the string multiple times.

Solution

1. Step 1: Understand the role of {} in formatting

   The {} acts as a placeholder where Rust inserts the value of a variable or expression inside a string.

2. Step 2: Recognize its use in println!

   When using println!("Hello, {}", name);, Rust replaces {} with the value of name.

3. Final Answer:

   It inserts the value of a variable or expression into the string. -> Option B

4. Quick Check:

   Placeholder {} = Insert value [OK]

Hint: Remember: {} means insert value here [OK]

Common Mistakes:

• Thinking {} creates variables
• Assuming {} repeats strings
• Confusing {} with comments

2. Which of the following is the correct syntax to format a floating-point number with 2 decimal places in Rust?

easy

A. println!("{:.2}", 3.14159);

B. println!("{2f}", 3.14159);

C. println!("{.2f}", 3.14159);

D. println!("{2}", 3.14159);

Solution

1. Step 1: Identify correct decimal formatting syntax

   Rust uses {:.2} inside println! to format a float with 2 decimal places.

2. Step 2: Check each option

   println!("{:.2}", 3.14159); uses {:.2}, which is correct. Others use invalid or incorrect syntax.

3. Final Answer:

   println!("{:.2}", 3.14159); -> Option A

4. Quick Check:

   Decimal places = {:.2} [OK]

Hint: Use {:.N} to set N decimal places [OK]

Common Mistakes:

• Using {2f} or {.2f} which is invalid in Rust
• Omitting the colon before precision
• Confusing with other language formats

3. What is the output of this Rust code?

let x = 255;
println!("Decimal: {}, Hex: {:x}, Binary: {:b}", x, x, x);

medium

A. Decimal: 255, Hex: FF, Binary: 11111111

B. Decimal: 255, Hex: ff, Binary: 1111111

C. Decimal: 255, Hex: 0xff, Binary: 11111111

D. Decimal: 255, Hex: ff, Binary: 11111111

Solution

1. Step 1: Understand formatting specifiers

   {} prints decimal, {:x} prints lowercase hex, {:b} prints binary.

2. Step 2: Convert 255 to hex and binary

   255 decimal is ff in hex (lowercase) and 11111111 in binary.

3. Final Answer:

   Decimal: 255, Hex: ff, Binary: 11111111 -> Option D

4. Quick Check:

   Hex lowercase = {:x}, Binary = {:b} [OK]

Hint: Use {:x} for hex lowercase, {:b} for binary [OK]

Common Mistakes:

• Expecting uppercase hex without :X
• Adding 0x prefix automatically
• Miscounting binary digits

4. Identify the error in this Rust code snippet:

let num = 42;
println!("Number: {2}", num);

medium

A. The println! macro requires a semicolon inside the string.

B. The variable num is not declared correctly.

C. The placeholder {2} refers to an argument index that does not exist.

D. Rust does not support numbered placeholders.

Solution

1. Step 1: Check placeholder indexing

   The placeholder {2} means use the third argument (index 2), but only one argument num is provided.

2. Step 2: Understand argument count mismatch

   Since only one argument exists, index 2 is out of range, causing a runtime error.

3. Final Answer:

   The placeholder {2} refers to an argument index that does not exist. -> Option C

4. Quick Check:

   Placeholder index must match argument count [OK]

Hint: Count arguments before using numbered placeholders [OK]

Common Mistakes:

• Using wrong index in placeholders
• Assuming Rust auto-corrects missing arguments
• Thinking semicolon needed inside string

5. You want to print a table of names and scores aligned in columns using Rust's formatting. Which code correctly aligns the names left in 10 spaces and scores right in 5 spaces?

let name = "Alice";
let score = 93;
// Which println! line is correct?

hard

A. println!("{:<10} | {:>5}", name, score);

B. println!("{:>10} | {:<5}", name, score);

C. println!("{:10} | {:5}", name, score);

D. println!("{:^10} | {:^5}", name, score);

Solution

1. Step 1: Understand alignment specifiers

   {:<10} aligns left in 10 spaces, {:>5} aligns right in 5 spaces.

2. Step 2: Match alignment to requirements

   Names should be left aligned, scores right aligned, so println!("{:<10} | {:>5}", name, score); matches perfectly.

3. Final Answer:

   println!("{:<10} | {:>5}", name, score); -> Option A

4. Quick Check:

   Left align = <, Right align = > [OK]

Hint: Use <: for left, >: for right alignment [OK]

Common Mistakes:

• Swapping alignment symbols
• Omitting width numbers
• Using center alignment when not needed