🦀 Introduction to the Rust Programming Language

Andrew J. Pounds, Ph.D.

1 What is Rust?

Rust is a systems programming language developed by Mozilla Research, with its first stable release in 2015. It was designed to be a safe, concurrent, and practical language that gives programmers control over low-level details while preventing common programming errors at compile time.

Rust consistently ranks as one of the most loved programming languages in developer surveys due to its unique combination of safety and performance. Key features include:

• Memory safety without garbage collection – The ownership system prevents memory leaks and data races at compile time
• Zero-cost abstractions – High-level features compile to efficient low-level code
• Strong typing with inference – Types are checked at compile time, but often inferred automatically
• Pattern matching – Powerful match expressions for handling different cases
• Modern tooling – Cargo provides package management, building, testing, and documentation
• Helpful compiler – Error messages explain problems and often suggest fixes

Rust source files use the .rs extension. We will use both the Rust compiler (rustc) for simple programs and Cargo for project management.

2 Your First Rust Program

Create a file called hello.rs with the following content:

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

Compiling with rustc

Open a terminal and navigate to the directory containing your file. Compile and run with:

rustc hello.rs
./hello

You should see Hello, World! printed to the console.

Using Cargo

For larger projects, use Cargo, Rust's build system and package manager:

# Create a new project
cargo new hello_cargo
cd hello_cargo

# Build and run
cargo run

Cargo creates a project structure with src/main.rs containing a hello world program.

Understanding the Code

Cargo Project Structure

When you run cargo new project_name, Cargo creates:

project_name/
├── Cargo.toml      # Project configuration and dependencies
└── src/
    └── main.rs     # Your main source file

The Cargo.toml file contains project metadata:

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

[dependencies]

3 Variable Types

Rust is a statically typed language with type inference. You must declare variables with let, but the compiler can often infer the type automatically.

Integer Types

Unsigned types are also available: u8, u16, u32, u64, u128, usize.

Floating-Point Types

Other Fundamental Types

Variable Declaration Examples

fn main() {
    // Type annotation (explicit)
    let age: i32 = 25;
    let gpa: f64 = 3.85;
    let name: &str = "Alice";
    let enrolled: bool = true;
    let grade: char = 'A';
    
    // Type inference (compiler figures out the type)
    let count = 100;        // inferred as i32
    let price = 19.99;      // inferred as f64
    let message = "Hello";  // inferred as &str
    
    // Output the values
    println!("Name: {}", name);
    println!("Age: {}", age);
    println!("GPA: {:.2}", gpa);
    println!("Enrolled: {}", enrolled);
    println!("Grade: {}", grade);
}

Mutability

By default, variables in Rust are immutable. To make a variable mutable, use mut:

fn main() {
    let x = 5;          // immutable
    // x = 6;           // ERROR: cannot assign twice to immutable variable
    
    let mut y = 5;      // mutable
    println!("y = {}", y);
    y = 6;              // OK: y is mutable
    println!("y = {}", y);
}

Constants

Use const for values that never change and must be known at compile time:

const MAX_POINTS: u32 = 100_000;
const PI: f64 = 3.14159265359;

fn main() {
    println!("Max points: {}", MAX_POINTS);
    println!("Pi: {}", PI);
}

Shadowing

Rust allows you to declare a new variable with the same name, which "shadows" the previous one:

fn main() {
    let x = 5;
    println!("x = {}", x);
    
    let x = x + 1;  // shadows previous x
    println!("x = {}", x);
    
    let x = x * 2;  // shadows again
    println!("x = {}", x);
    
    // Can even change type when shadowing
    let spaces = "   ";         // &str
    let spaces = spaces.len();  // usize (shadows with different type)
    println!("spaces = {}", spaces);
}

4 Console Output

Rust provides several macros for output. The ! indicates these are macros, not regular functions.

The println! and print! Macros

fn main() {
    // Basic output
    println!("Hello, World!");
    
    // Output without newline
    print!("This ");
    print!("is ");
    print!("on one line");
    println!();  // Just prints a newline
    
    // Output to stderr (for error messages)
    eprintln!("This is an error message");
}

Formatting with Placeholders

Use {} as placeholders for values:

fn main() {
    let name = "Alice";
    let age = 25;
    let gpa = 3.85;
    
    // Basic placeholders
    println!("Name: {}", name);
    println!("Age: {}", age);
    println!("GPA: {}", gpa);
    
    // Multiple values
    println!("{} is {} years old", name, age);
    
    // Positional arguments
    println!("{0} is {1}. {0} studies hard.", name, age);
    
    // Named arguments
    println!("{student} has a {score} GPA", student = name, score = gpa);
}

Formatting Numbers

fn main() {
    let pi = 3.14159265359;
    let big_number = 1234567;
    let percentage = 0.856;
    
    // Decimal places
    println!("Pi: {:.2}", pi);           // 2 decimal places
    println!("Pi: {:.4}", pi);           // 4 decimal places
    
    // Width and alignment
    println!("[{:10}]", 42);             // right-aligned, width 10
    println!("[{:<10}]", 42);            // left-aligned, width 10
    println!("[{:^10}]", 42);            // center-aligned, width 10
    println!("[{:0>10}]", 42);           // zero-padded, width 10
    
    // Combined width and precision
    println!("Value: {:8.2}", pi);       // width 8, 2 decimal places
    
    // Different bases
    println!("Decimal: {}", 255);
    println!("Binary: {:b}", 255);
    println!("Octal: {:o}", 255);
    println!("Hex (lower): {:x}", 255);
    println!("Hex (upper): {:X}", 255);
}

Formatting Strings

fn main() {
    let name = "Alice";
    
    // Width for strings
    println!("[{:15}]", name);           // right-padded to 15 chars
    println!("[{:>15}]", name);          // right-aligned
    println!("[{:^15}]", name);          // centered
    
    // Truncation
    println!("[{:.3}]", "Hello");        // truncate to 3 chars
}

fn main() {
    let numbers = [1, 2, 3, 4, 5];
    
    println!("Debug: {:?}", numbers);
    println!("Pretty debug: {:#?}", numbers);
}

5 Console Input

Reading input in Rust requires the std::io module. Input is always read as a String and must be parsed to other types.

Basic Input Reading

use std::io;

fn main() {
    println!("What is your name?");
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    // trim() removes the trailing newline
    let name = input.trim();
    
    println!("Hello, {}!", name);
}

Reading Numbers

To read numbers, parse the string input:

use std::io;

fn main() {
    println!("Enter your age:");
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    let age: i32 = input.trim().parse().expect("Please enter a valid number");
    
    println!("You are {} years old.", age);
    println!("Next year you will be {}.", age + 1);
}

Handling Parse Errors

Use match to handle invalid input gracefully:

use std::io;

fn main() {
    println!("Enter a number:");
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    let number: i32 = match input.trim().parse() {
        Ok(n) => n,
        Err(_) => {
            println!("That's not a valid number!");
            return;
        }
    };
    
    println!("You entered: {}", number);
}

Creating a Helper Function for Input

Since input reading is verbose, create a reusable function:

use std::io::{self, Write};

fn read_line(prompt: &str) -> String {
    print!("{}", prompt);
    io::stdout().flush().unwrap();  // Ensure prompt is displayed
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    input.trim().to_string()
}

fn read_i32(prompt: &str) -> i32 {
    loop {
        let input = read_line(prompt);
        match input.parse() {
            Ok(n) => return n,
            Err(_) => println!("Invalid number. Please try again."),
        }
    }
}

fn read_f64(prompt: &str) -> f64 {
    loop {
        let input = read_line(prompt);
        match input.parse() {
            Ok(n) => return n,
            Err(_) => println!("Invalid number. Please try again."),
        }
    }
}

fn main() {
    let name = read_line("Enter your name: ");
    let age = read_i32("Enter your age: ");
    let gpa = read_f64("Enter your GPA: ");
    
    println!();
    println!("Name: {}", name);
    println!("Age: {}", age);
    println!("GPA: {:.2}", gpa);
}

6 Assignment Statements and Operators

Assignment

In Rust, = is for assignment and == is for equality comparison:

fn main() {
    let mut x = 10;     // initial assignment
    println!("x = {}", x);
    
    x = 20;             // reassignment (requires mut)
    println!("x = {}", x);
    
    x = x + 5;          // compound expression
    println!("x = {}", x);
}

Arithmetic Operators

Compound Assignment Operators

fn main() {
    let mut x = 10;
    
    x += 5;    // x = x + 5
    println!("After += 5: {}", x);
    
    x -= 3;    // x = x - 3
    println!("After -= 3: {}", x);
    
    x *= 2;    // x = x * 2
    println!("After *= 2: {}", x);
    
    x /= 4;    // x = x / 4
    println!("After /= 4: {}", x);
    
    x %= 3;    // x = x % 3
    println!("After %= 3: {}", x);
}

Comparison Operators

Logical Operators

fn main() {
    let age = 25;
    let has_license = true;
    
    // Comparison operators
    println!("age == 25: {}", age == 25);
    println!("age != 30: {}", age != 30);
    println!("age > 18: {}", age > 18);
    
    // Logical operators
    println!("Can drive: {}", age >= 16 && has_license);
    println!("Is teenager: {}", age >= 13 && age <= 19);
    println!("NOT has_license: {}", !has_license);
}

Type Casting

Use as to convert between numeric types:

fn main() {
    let x: i32 = 10;
    let y: f64 = 3.0;
    
    // Convert i32 to f64 for floating-point division
    let result = x as f64 / y;
    println!("10 / 3.0 = {:.4}", result);
    
    // Convert f64 to i32 (truncates)
    let pi = 3.14159;
    let truncated = pi as i32;
    println!("{} as i32 = {}", pi, truncated);
    
    // Convert between integer sizes
    let small: i8 = 42;
    let big: i64 = small as i64;
    println!("i8 {} as i64 = {}", small, big);
}

7 Control Structures

Rust provides several constructs for controlling program flow based on conditions.

The if Expression

The basic if statement tests a condition and executes code accordingly:

fn main() {
    let number = 7;
    
    if number > 5 {
        println!("{} is greater than 5", number);
    }
}

if-else

fn main() {
    let number = 3;
    
    if number > 5 {
        println!("{} is greater than 5", number);
    } else {
        println!("{} is not greater than 5", number);
    }
}

if-else if-else

fn main() {
    let score = 85;
    
    if score >= 90 {
        println!("Grade: A");
    } else if score >= 80 {
        println!("Grade: B");
    } else if score >= 70 {
        println!("Grade: C");
    } else if score >= 60 {
        println!("Grade: D");
    } else {
        println!("Grade: F");
    }
}

if as an Expression

In Rust, if is an expression that returns a value:

fn main() {
    let condition = true;
    
    // if can return a value
    let number = if condition { 5 } else { 6 };
    
    println!("The number is: {}", number);
    
    // More complex example
    let score = 85;
    let grade = if score >= 90 {
        'A'
    } else if score >= 80 {
        'B'
    } else if score >= 70 {
        'C'
    } else if score >= 60 {
        'D'
    } else {
        'F'
    };
    
    println!("Grade: {}", grade);
}

The match Expression

The match expression is a powerful control flow construct for pattern matching:

fn main() {
    let number = 3;
    
    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        4 => println!("Four"),
        5 => println!("Five"),
        _ => println!("Something else"),  // _ is the catch-all pattern
    }
}

match with Multiple Patterns and Ranges

fn main() {
    let score = 85;
    
    let grade = match score {
        90..=100 => 'A',      // Range from 90 to 100 (inclusive)
        80..=89 => 'B',
        70..=79 => 'C',
        60..=69 => 'D',
        0..=59 => 'F',
        _ => '?',             // Invalid score
    };
    
    println!("Score: {}, Grade: {}", score, grade);
    
    // Multiple patterns with |
    let day = 6;
    let day_type = match day {
        1 | 2 | 3 | 4 | 5 => "Weekday",
        6 | 7 => "Weekend",
        _ => "Invalid day",
    };
    
    println!("Day {} is a {}", day, day_type);
}

match with Strings

fn main() {
    let command = "quit";
    
    match command {
        "start" => println!("Starting..."),
        "stop" => println!("Stopping..."),
        "pause" => println!("Pausing..."),
        "quit" | "exit" => println!("Goodbye!"),
        _ => println!("Unknown command: {}", command),
    }
}

match with Guards

You can add conditions to match arms with if guards:

fn main() {
    let number = 4;
    
    match number {
        n if n < 0 => println!("{} is negative", n),
        n if n == 0 => println!("zero"),
        n if n % 2 == 0 => println!("{} is positive and even", n),
        n => println!("{} is positive and odd", n),
    }
}

Nested Conditions

fn main() {
    let age = 25;
    let has_id = true;
    
    if age >= 18 {
        if has_id {
            println!("Entry permitted.");
        } else {
            println!("ID required for entry.");
        }
    } else {
        println!("Must be 18 or older.");
    }
}

8 Loops

Rust provides three types of loops: loop, while, and for.

The loop Statement (Infinite Loop)

The loop keyword creates an infinite loop. Use break to exit:

fn main() {
    let mut counter = 0;
    
    loop {
        counter += 1;
        println!("Counter: {}", counter);
        
        if counter >= 5 {
            break;
        }
    }
    
    println!("Loop finished!");
}

Returning Values from loop

The loop expression can return a value with break:

fn main() {
    let mut counter = 0;
    
    let result = loop {
        counter += 1;
        
        if counter == 10 {
            break counter * 2;  // Return counter * 2
        }
    };
    
    println!("The result is: {}", result);
}

The while Loop

The while loop continues while a condition is true:

fn main() {
    let mut number = 5;
    
    while number > 0 {
        println!("{}!", number);
        number -= 1;
    }
    
    println!("Liftoff!");
}

The for Loop

The for loop iterates over collections or ranges:

fn main() {
    // Iterating over a range (1 to 5, exclusive of 6)
    println!("Counting 1 to 5:");
    for i in 1..6 {
        println!("  {}", i);
    }
    
    // Inclusive range (1 to 5, inclusive)
    println!("\nUsing inclusive range:");
    for i in 1..=5 {
        println!("  {}", i);
    }
}

Iterating Over Arrays

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    
    // Iterate over elements
    println!("Elements:");
    for num in numbers {
        println!("  {}", num);
    }
    
    // Iterate with index using enumerate()
    println!("\nWith indices:");
    for (index, num) in numbers.iter().enumerate() {
        println!("  numbers[{}] = {}", index, num);
    }
}

Reverse Iteration

fn main() {
    println!("Countdown:");
    for i in (1..=5).rev() {
        println!("  {}", i);
    }
    println!("  Liftoff!");
}

Loop Control: break and continue

fn main() {
    // break - exit the loop early
    println!("Using break:");
    for i in 1..10 {
        if i == 5 {
            println!("  Breaking at {}", i);
            break;
        }
        println!("  {}", i);
    }
    
    // continue - skip to next iteration
    println!("\nUsing continue (skip even numbers):");
    for i in 1..=10 {
        if i % 2 == 0 {
            continue;  // Skip even numbers
        }
        println!("  {}", i);
    }
}

Labeled Loops

Use labels to break or continue outer loops from nested loops:

fn main() {
    'outer: for i in 1..=3 {
        println!("Outer loop: i = {}", i);
        
        for j in 1..=3 {
            println!("  Inner loop: j = {}", j);
            
            if i == 2 && j == 2 {
                println!("  Breaking outer loop!");
                break 'outer;
            }
        }
    }
    
    println!("Done!");
}

Common Loop Patterns

fn main() {
    // Sum numbers 1 to 10
    let mut sum = 0;
    for i in 1..=10 {
        sum += i;
    }
    println!("Sum of 1-10: {}", sum);
    
    // Find factorial
    let n = 5;
    let mut factorial = 1;
    for i in 1..=n {
        factorial *= i;
    }
    println!("{}! = {}", n, factorial);
    
    // Count iterations
    let mut count = 0;
    for _ in 0..100 {  // _ ignores the loop variable
        count += 1;
    }
    println!("Counted to: {}", count);
}

Input Validation Loop

use std::io::{self, Write};

fn main() {
    let number: i32;
    
    loop {
        print!("Enter a positive number: ");
        io::stdout().flush().unwrap();
        
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Failed to read");
        
        match input.trim().parse() {
            Ok(n) if n > 0 => {
                number = n;
                break;
            }
            Ok(_) => println!("Please enter a POSITIVE number."),
            Err(_) => println!("Invalid input. Please enter a number."),
        }
    }
    
    println!("You entered: {}", number);
}

9 Functions

Functions in Rust are declared with the fn keyword. They allow you to organize code into reusable blocks.

Basic Function Syntax

fn greet() {
    println!("Hello, World!");
}

fn main() {
    greet();  // Call the function
    greet();  // Call it again
}

Functions with Parameters

fn greet_person(name: &str) {
    println!("Hello, {}!", name);
}

fn print_sum(a: i32, b: i32) {
    println!("{} + {} = {}", a, b, a + b);
}

fn main() {
    greet_person("Alice");
    greet_person("Bob");
    
    print_sum(5, 3);
    print_sum(10, 20);
}

Functions with Return Values

Use -> to specify the return type. The last expression without a semicolon is returned:

fn add(a: i32, b: i32) -> i32 {
    a + b  // No semicolon = return value
}

fn multiply(a: i32, b: i32) -> i32 {
    return a * b;  // Explicit return also works
}

fn is_even(n: i32) -> bool {
    n % 2 == 0
}

fn main() {
    let sum = add(5, 3);
    println!("5 + 3 = {}", sum);
    
    let product = multiply(4, 7);
    println!("4 * 7 = {}", product);
    
    println!("Is 10 even? {}", is_even(10));
    println!("Is 7 even? {}", is_even(7));
}

Functions with Multiple Returns (Tuples)

fn min_max(a: i32, b: i32) -> (i32, i32) {
    if a < b {
        (a, b)
    } else {
        (b, a)
    }
}

fn divide_with_remainder(dividend: i32, divisor: i32) -> (i32, i32) {
    let quotient = dividend / divisor;
    let remainder = dividend % divisor;
    (quotient, remainder)
}

fn main() {
    let (min, max) = min_max(10, 5);
    println!("Min: {}, Max: {}", min, max);
    
    let (quot, rem) = divide_with_remainder(17, 5);
    println!("17 / 5 = {} remainder {}", quot, rem);
}

Function Examples

// Calculate factorial
fn factorial(n: u64) -> u64 {
    if n <= 1 {
        1
    } else {
        n * factorial(n - 1)
    }
}

// Check if a number is prime
fn is_prime(n: u32) -> bool {
    if n < 2 {
        return false;
    }
    if n == 2 {
        return true;
    }
    if n % 2 == 0 {
        return false;
    }
    
    let mut i = 3;
    while i * i <= n {
        if n % i == 0 {
            return false;
        }
        i += 2;
    }
    true
}

// Calculate average of three numbers
fn average(a: f64, b: f64, c: f64) -> f64 {
    (a + b + c) / 3.0
}

fn main() {
    println!("5! = {}", factorial(5));
    println!("10! = {}", factorial(10));
    
    println!("Is 17 prime? {}", is_prime(17));
    println!("Is 18 prime? {}", is_prime(18));
    
    println!("Average of 85, 90, 78: {:.2}", average(85.0, 90.0, 78.0));
}

10 Arrays and Vectors

Rust has two main sequential collection types: fixed-size arrays and growable vectors.

Arrays (Fixed Size)

Arrays have a fixed size known at compile time:

fn main() {
    // Array with explicit type annotation
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    
    // Array with inferred type
    let grades = [85, 90, 78, 92, 88];
    
    // Array initialized with same value
    let zeros = [0; 10];  // 10 elements, all 0
    
    // Accessing elements
    println!("First number: {}", numbers[0]);
    println!("Third grade: {}", grades[2]);
    
    // Array length
    println!("Array length: {}", numbers.len());
    
    // Print all elements
    println!("All grades: {:?}", grades);
}

Iterating Over Arrays

fn main() {
    let numbers = [10, 20, 30, 40, 50];
    
    // Iterate over elements
    println!("Elements:");
    for num in numbers {
        println!("  {}", num);
    }
    
    // Iterate with index
    println!("\nWith indices:");
    for (i, num) in numbers.iter().enumerate() {
        println!("  numbers[{}] = {}", i, num);
    }
    
    // Calculate sum
    let mut sum = 0;
    for num in numbers {
        sum += num;
    }
    println!("\nSum: {}", sum);
}

Vectors (Dynamic Size)

Vectors can grow or shrink at runtime:

fn main() {
    // Create an empty vector
    let mut numbers: Vec<i32> = Vec::new();
    
    // Add elements
    numbers.push(10);
    numbers.push(20);
    numbers.push(30);
    
    println!("After pushing: {:?}", numbers);
    println!("Length: {}", numbers.len());
    
    // Create with initial values using vec! macro
    let mut grades = vec![85, 90, 78];
    grades.push(92);
    grades.push(88);
    
    println!("Grades: {:?}", grades);
    
    // Access elements
    println!("First grade: {}", grades[0]);
    
    // Safe access with get() - returns Option
    match grades.get(10) {
        Some(grade) => println!("Grade at 10: {}", grade),
        None => println!("No grade at index 10"),
    }
}

Common Vector Operations

fn main() {
    let mut nums = vec![3, 1, 4, 1, 5, 9, 2, 6];
    
    println!("Original: {:?}", nums);
    println!("Length: {}", nums.len());
    println!("Is empty: {}", nums.is_empty());
    
    // First and last elements
    println!("First: {:?}", nums.first());
    println!("Last: {:?}", nums.last());
    
    // Remove last element
    let popped = nums.pop();
    println!("Popped: {:?}", popped);
    println!("After pop: {:?}", nums);
    
    // Insert at position
    nums.insert(0, 100);
    println!("After insert at 0: {:?}", nums);
    
    // Remove at position
    nums.remove(0);
    println!("After remove at 0: {:?}", nums);
    
    // Check if contains value
    println!("Contains 4: {}", nums.contains(&4));
    
    // Clear all elements
    nums.clear();
    println!("After clear: {:?}", nums);
    println!("Is empty: {}", nums.is_empty());
}

Vector with Strings

fn main() {
    let mut names: Vec<String> = Vec::new();
    
    names.push(String::from("Alice"));
    names.push(String::from("Bob"));
    names.push(String::from("Charlie"));
    
    println!("Names: {:?}", names);
    
    // Iterate and print
    for name in &names {
        println!("Hello, {}!", name);
    }
    
    // Using vec! macro with strings
    let fruits = vec!["apple", "banana", "cherry"];
    for fruit in &fruits {
        println!("I like {}.", fruit);
    }
}

Calculating Statistics

fn main() {
    let scores = vec![85.0, 92.0, 78.0, 90.0, 88.0];
    
    // Sum using iterator
    let sum: f64 = scores.iter().sum();
    println!("Sum: {}", sum);
    
    // Average
    let average = sum / scores.len() as f64;
    println!("Average: {:.2}", average);
    
    // Find min and max
    let min = scores.iter().cloned().reduce(f64::min).unwrap();
    let max = scores.iter().cloned().reduce(f64::max).unwrap();
    println!("Min: {}, Max: {}", min, max);
    
    // Or using min_by/max_by for floats
    let min2 = scores.iter().cloned().fold(f64::INFINITY, f64::min);
    let max2 = scores.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
    println!("Min: {}, Max: {}", min2, max2);
}

11 Complete Example: Prime Number Analyzer

This program demonstrates input, output, functions, control structures, and loops working together:

use std::io::{self, Write};

// Helper function to read a line of input
fn read_line(prompt: &str) -> String {
    print!("{}", prompt);
    io::stdout().flush().unwrap();
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    input.trim().to_string()
}

// Helper function to read an integer with validation
fn read_positive_int(prompt: &str, min_value: i32) -> i32 {
    loop {
        let input = read_line(prompt);
        match input.parse::<i32>() {
            Ok(n) if n >= min_value => return n,
            Ok(_) => println!("Please enter a number >= {}.", min_value),
            Err(_) => println!("Invalid input. Please enter a number."),
        }
    }
}

// Check if a number is prime
fn is_prime(n: i32) -> bool {
    if n < 2 {
        return false;
    }
    if n == 2 {
        return true;
    }
    if n % 2 == 0 {
        return false;
    }
    
    let mut i = 3;
    while i * i <= n {
        if n % i == 0 {
            return false;
        }
        i += 2;
    }
    true
}

// Find the smallest factor of n (assumes n > 1 and n is not prime)
fn smallest_factor(n: i32) -> i32 {
    if n % 2 == 0 {
        return 2;
    }
    
    let mut i = 3;
    while i * i <= n {
        if n % i == 0 {
            return i;
        }
        i += 2;
    }
    n  // n is prime, return itself
}

// Count prime numbers from 2 to n
fn count_primes_up_to(n: i32) -> i32 {
    let mut count = 0;
    for i in 2..=n {
        if is_prime(i) {
            count += 1;
        }
    }
    count
}

fn main() {
    println!("=== Prime Number Analyzer ===");
    println!();
    
    loop {
        // Get valid input
        let n = read_positive_int("Enter a positive integer (>= 2): ", 2);
        
        // Check if prime and display result
        if is_prime(n) {
            println!("{} is a prime number!", n);
        } else {
            let factor = smallest_factor(n);
            println!("{} is not prime. Its smallest factor is {}.", n, factor);
        }
        
        // Count primes up to n
        let prime_count = count_primes_up_to(n);
        println!("There are {} prime numbers from 2 to {}.", prime_count, n);
        
        // Ask to continue
        println!();
        let response = read_line("Check another number? (y/n): ");
        if response.to_lowercase() != "y" {
            break;
        }
        println!();
    }
    
    println!("Goodbye!");
}

Sample Run

Building and Running

Option 1: Using rustc

rustc prime_analyzer.rs
./prime_analyzer

Option 2: Using Cargo

cargo new prime_analyzer
cd prime_analyzer
# Replace src/main.rs with the code above
cargo run

use std::io::{self, Write};

// TODO: Create a helper function to read input
fn read_line(prompt: &str) -> String {
    print!("{}", prompt);
    io::stdout().flush().unwrap();
    
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");
    
    input.trim().to_string()
}

// TODO: Create a function to convert Fahrenheit to Celsius
fn fahrenheit_to_celsius(f: f64) -> f64 {
    // Formula: C = (F - 32) * 5/9
    _____
}

fn main() {
    println!("=== Temperature Converter ===");
    println!();
    
    loop {
        // TODO: Read temperature from user
        let input = read_line("Enter temperature in Fahrenheit: ");
        
        // TODO: Parse the input to f64
        let fahrenheit: f64 = match input.parse() {
            Ok(n) => n,
            Err(_) => {
                println!("Invalid number. Please try again.");
                continue;
            }
        };
        
        // TODO: Convert and display result
        let celsius = _____;
        println!("{}°F = {:.2}°C", fahrenheit, celsius);
        
        // TODO: Ask if user wants to continue
        println!();
        let response = read_line("Convert another? (y/n): ");
        if response.to_lowercase() != "y" {
            break;
        }
        println!();
    }
    
    println!("Goodbye!");
}