Handling input values in Rust - Step-by-Step Execution

Concept Flow - Handling input values

Start Program

↓

Prompt User for Input

↓

Read Input as String

↓

Trim Input

↓

Parse Input to Desired Type

↓

Use Value

↓

End Program

The program asks the user for input, reads it as a string, trims whitespace, tries to convert it to the needed type, and either uses the value or shows an error.

Execution Sample

Rust

use std::io;

fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let num: i32 = input.trim().parse().unwrap();
    println!("You typed: {}", num);
}

This code reads a line from the user, converts it to an integer, and prints it.

Execution Table

Step	Action	Input/Value	Result/State	Output
1	Initialize empty string 'input'	""	input = ""
2	Read line from user	"42\n"	input = "42\n"
3	Trim input	"42\n"	trimmed = "42"
4	Parse trimmed input to i32	"42"	num = 42
5	Print output	num = 42		You typed: 42
6	Program ends

💡 Program ends after printing the parsed integer.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
input	""	"42\n"	"42\n"	"42\n"	"42\n"
trimmed	N/A	N/A	"42"	"42"	"42"
num	N/A	N/A	N/A	42	42

Key Moments - 2 Insights

Why do we need to trim the input before parsing?

Because the input includes a newline character from pressing Enter, trimming removes it so parsing to a number works correctly (see Step 3 in execution_table).

What happens if the user types something that is not a number?

The parse() call will fail and cause the program to panic because unwrap() expects success. Handling errors would require different code (not shown here).

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'input' after reading the line?

A "42"

B "42\n"

C "\n42"

D ""

💡 Hint

Check Step 2 in the execution_table where input is assigned after reading.

At which step does the program convert the string to an integer?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for the step where parse() is called in the execution_table.

If the user input was " 7 \n", what would be the trimmed value?

A "7"

B " 7 "

C "7\n"

D " 7 \n"

💡 Hint

Trimming removes spaces and newline characters as shown in Step 3.

Concept Snapshot

Handling input values in Rust:
- Use String::new() to create input buffer
- Read input with io::stdin().read_line(&mut input)
- Trim input to remove whitespace/newlines
- Parse trimmed string to desired type (e.g., i32)
- Use unwrap() for simple error handling (panics on failure)
- Print or use the parsed value

Full Transcript

This example shows how Rust programs handle user input. First, an empty string variable is created to store input. The program reads a line from the user, which includes the newline character from pressing Enter. To convert this input to a number, the program trims whitespace and newlines. Then it parses the trimmed string into an integer. If parsing succeeds, the program prints the number. If parsing fails, the program panics because unwrap() is used. This step-by-step flow helps beginners see how input is processed safely and converted to usable data.

Practice

1. What does the Rust function io::stdin().read_line(&mut input) do in a program?

easy

A. It clears the input buffer.

B. It writes a line of text to the screen.

C. It reads a line of text from the user and stores it in the variable input.

D. It converts a string to a number.

Solution

1. Step 1: Understand the function purpose

   io::stdin().read_line(&mut input) reads user input from the keyboard as a string.

2. Step 2: Recognize the role of input

   The input is stored in the mutable variable input passed by reference.

3. Final Answer:

   It reads a line of text from the user and stores it in the variable input. -> Option C

4. Quick Check:

   read_line reads user input [OK]

Hint: read_line reads user input into a variable [OK]

Common Mistakes:

• Thinking read_line writes output
• Confusing input reading with clearing buffer
• Assuming it converts types automatically

2. Which of the following Rust code snippets correctly reads a line of input and trims whitespace?

easy

A. let input = io::stdin().read_line().trim();

B. let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim();

C. io::stdin().read_line(input); let input = input.trim();

D. let mut input = String::new(); io::stdin().read_line(input); input.trim();

Solution

1. Step 1: Check correct usage of read_line

   It requires a mutable String reference: read_line(&mut input).

2. Step 2: Confirm trimming is done on the input string

   Calling input.trim() removes whitespace correctly.

3. Final Answer:

   let mut input = String::new(); io::stdin().read_line(&mut input).expect("Failed"); let input = input.trim(); -> Option B

4. Quick Check:

   read_line needs &mut String and trim() cleans input [OK]

Hint: Use &mut String and call trim() after read_line [OK]

Common Mistakes:

• Forgetting &mut before input
• Calling trim() on read_line() result
• Not creating a mutable String first

3. What will be the output of this Rust code if the user inputs 42?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let num: i32 = input.trim().parse().expect("Not a number");
    println!("Number plus 10 is {}", num + 10);
}

medium

A. Number plus 10 is 52

B. Number plus 10 is 42

C. Not a number

D. Failed

Solution

1. Step 1: Read and parse input

   The input string "42" is trimmed and parsed to integer 42 successfully.

2. Step 2: Add 10 and print

   42 + 10 equals 52, so the output prints "Number plus 10 is 52".

3. Final Answer:

   Number plus 10 is 52 -> Option A

4. Quick Check:

   42 + 10 = 52 [OK]

Hint: Trim and parse input before math operations [OK]

Common Mistakes:

• Not trimming input before parse
• Parsing input as wrong type
• Ignoring parse errors

4. Identify the error in this Rust code snippet that reads an integer from input:

let mut input = String::new();
io::stdin().read_line(&mut input).expect("Failed");
let num: i32 = input.parse().expect("Not a number");
println!("Number: {}", num);

medium

A. parse() called without trimming input

B. Missing &mut before input in read_line

C. input is not mutable

D. println! macro syntax error

Solution

1. Step 1: Check read_line usage

   read_line correctly uses &mut input and input is mutable.

2. Step 2: Identify parse error cause

   parse() is called on input without trimming, so newline remains causing parse failure.

3. Final Answer:

   parse() called without trimming input -> Option A

4. Quick Check:

   Always trim input before parse() [OK]

Hint: Always trim input string before parsing to number [OK]

Common Mistakes:

• Forgetting to trim input before parse
• Assuming read_line returns trimmed string
• Misusing &mut in read_line

5. You want to read multiple numbers from user input separated by spaces and store them in a vector of integers. Which Rust code correctly does this?

use std::io;
fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed");
    let numbers: Vec<i32> = input.trim().split_whitespace()
        .map(|x| x.parse().expect("Not a number"))
        .collect();
    println!("Numbers: {:?}", numbers);
}

hard

A. read_line() cannot read multiple numbers at once.

B. Fails because split_whitespace() does not split strings.

C. parse() should be called before split_whitespace().

D. Correctly reads and parses space-separated numbers into a vector.

Solution

1. Step 1: Read input line and trim

   Input is read as a string and trimmed to remove trailing whitespace.

2. Step 2: Split and parse each number

   split_whitespace() splits input by spaces, map parses each piece to i32, collect gathers into vector.

3. Final Answer:

   Correctly reads and parses space-separated numbers into a vector. -> Option D

4. Quick Check:

   split_whitespace + map(parse) + collect = vector [OK]

Hint: Use split_whitespace, map parse, then collect to vector [OK]

Common Mistakes:

• Parsing before splitting input
• Using wrong iterator methods
• Assuming read_line reads multiple inputs separately