IS 4010: Application Development with Artificial Intelligence

Week 11: Structuring code and data in Rust

Brandon M. Greenwell

Session 1: organizing code and custom types

This week builds on the Week 10 ownership model. Move from one source file to modules and from primitive values to types that encode the lab’s domain rules.

From small scripts to real programs

• So far, we’ve written small Rust programs in a single main.rs file
• Real applications need organization: separate files, logical grouping, reusable components
• Rust’s module system controls structure, paths, and visibility
• Today we learn how modules organize a growing Rust project

Transition from a single source file to a small multi-module program. Keep the examples close to the supplied lab structure.

The Rust module system hierarchy

Three levels of organization:

1. Packages - A Cargo feature that builds, tests, and shares crates
2. Crates - A tree of modules that produces a library or executable
3. Modules - Let you control organization, scope, and privacy

Think of it like: Package = project, Crate = building, Modules = rooms

The hierarchy confuses newcomers. Use the building analogy: package is the whole project, crate is a library or binary, modules are logical divisions. We’ll focus on modules today since that’s what students will use most.

Creating modules with mod

// src/main.rs

mod math {  // Define a module named 'math'

    pub fn add(a: i32, b: i32) -> i32 {  // 'pub' makes this visible outside the module
        a + b  // Return the sum
    }

    fn subtract(a: i32, b: i32) -> i32 {  // No 'pub' = private to this module only
        a - b  // Return the difference
    }
}

fn main() {
    println!("2 + 3 = {}", math::add(2, 3));  // ✅ Works! add() is public
    // println!("5 - 2 = {}", math::subtract(5, 2));  // ❌ ERROR: subtract() is private!
}

Try it in Rust Playground

Show module definition with mod. Explain pub keyword - everything is private by default. Show the path syntax with ::. Have students try calling math::subtract() in the Playground to see the error. Then have them change subtract to pub and see it work. This simple example teaches the core concept clearly.

Privacy in Rust: default private

• Everything is private by default in Rust modules
• Use pub keyword to make items public
• Privacy rules:
  • Parent modules can’t see into child private items
  • Child modules can see everything in parent modules
  • Sibling modules can see each other’s public items
• This is defensive design - explicit about your public API

Contrast with Python where everything is public by convention. Rust enforces privacy at compile time. This prevents accidental dependencies on internal implementation details. It’s about intentional design.

Quick rule of thumb: when do you need pub?

✅ Use pub when accessed from:

• A parent module
• A sibling’s child module
• Outside the crate

Example: Public API functions, structs used by other modules

❌ No pub needed when accessed from:

• The same module
• Its child modules

Example: Helper functions, internal implementation details

This is the practical guidance students need. Most confusion comes from not understanding the scope. Key insight: child modules have access to parent’s private items (unusual compared to other languages), but parents don’t have access to children’s private items (this is normal). When in doubt, try compiling without pub first - the compiler will tell you if you need it!

Example: pub visibility in action

mod calculator {  // Parent module

    fn validate_inputs(a: i32, b: i32) -> bool {  // ❌ No pub - internal helper only
        b != 0  // Make sure we're not dividing by zero
    }

    pub mod operations {  // ✅ pub - main() needs to access this module

        pub fn divide(a: i32, b: i32) -> i32 {  // ✅ pub - public API function
            if super::validate_inputs(a, b) {  // ✅ Child can access parent's private!
                a / b  // Do the division
            } else {
                0  // Return 0 for invalid inputs (simplified error handling)
            }
        }

        fn log_operation(msg: &str) {  // ❌ Private - internal to operations only
            println!("LOG: {}", msg);  // Internal logging
        }
    }
}

fn main() {
    println!("10 / 2 = {}", calculator::operations::divide(10, 2));  // ✅ Works! Both pub
    // calculator::validate_inputs(10, 2);  // ❌ Error! validate_inputs is private
    // calculator::operations::log_operation("test");  // ❌ Error! log_operation is private
}

Try it in Rust Playground

Show this code working in the Playground. Then have students uncomment the error lines one at a time to see the errors. Key point: divide() is in a CHILD module (operations) but can call parent’s validate_inputs() with super::. This asymmetry confuses students - child can see parent’s private, but parent can’t see child’s private. Spend time on this concept. The example is deliberately simple (returning 0 for errors) to focus on the visibility rules, not error handling.

The use keyword: bringing paths into scope

mod math {  // Parent module

    pub mod operations {  // Public submodule
        pub fn add(a: i32, b: i32) -> i32 {  // Public function
            a + b  // Return the sum
        }

        pub fn multiply(a: i32, b: i32) -> i32 {  // Public function
            a * b  // Return the product
        }
    }
}

// Bring the operations module into scope with 'use'
use math::operations;

fn main() {
    println!("2 + 3 = {}", operations::add(2, 3));  // ✅ Shorter! Just operations::add
    println!("2 * 3 = {}", operations::multiply(2, 3));  // Instead of math::operations::multiply
    // Without 'use', we'd need: math::operations::add(2, 3)
}

Try it in Rust Playground

‘use’ is like Python’s import or Java’s import. It creates shortcuts. Note the idiomatic pattern: bring the parent module into scope (operations), not the function itself. This makes it clear where functions come from. Have students try ‘use math::operations::add;’ to see the difference - it’s less clear and goes against Rust conventions.

Separating modules into files

Project structure:

src/
├── main.rs
├── math.rs
└── math/
    ├── operations.rs
    └── constants.rs

In main.rs:

mod math;  // Tells Rust to look for math.rs (no braces = load from file)

use math::operations;  // Import the operations submodule

fn main() {
    println!("{}", operations::add(2, 3));  // Use the add function
}

In math.rs:

// src/math.rs
// This file declares what submodules exist under 'math'
pub mod operations;  // Makes operations public and tells Rust to load math/operations.rs
pub mod constants;   // Makes constants public and tells Rust to load math/constants.rs

In math/operations.rs:

// src/math/operations.rs
// This file contains the actual implementation of math operations
pub fn add(a: i32, b: i32) -> i32 {  // Public function
    a + b  // Return sum
}

pub fn multiply(a: i32, b: i32) -> i32 {  // Public function
    a * b  // Return product
}

In math/constants.rs:

// src/math/constants.rs
// This file defines mathematical constants
pub const PI: f64 = 3.14159;  // Approximation of pi
pub const E: f64 = 2.71828;   // Approximation of Euler's number

Real projects split modules into separate files. The ‘mod’ declaration without braces tells Rust to load from a file. This is how professional Rust code is organized. The file system mirrors the module tree. The math.rs file declares the submodules (operations and constants). Students can try this in VS Code - create these files and run cargo build to see it work.

AI copilot technique: module organization

When organizing code into modules, ask your AI assistant:

Effective prompts: - “How should I organize this Rust project into modules? [describe project]” - “What should be public vs private in this module? [paste code]” - “Explain the difference between ‘use’ and ‘mod’ in Rust” - “Help me split this large main.rs into separate modules”

Pro tip: Ask AI to explain the module tree structure - visualizations help!

Module organization is a design skill. AI can suggest logical groupings and explain privacy trade-offs, but students should be able to justify the resulting structure. Understanding those boundaries makes code easier to maintain.

Defining custom data with struct

• A struct (structure) groups related data into a single, meaningful type
• Like Python classes but data only (methods come separately)
• Three kinds:
  1. Named-field structs - most common
  2. Tuple structs - fields accessed by position
  3. Unit structs - no fields (rare)

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

Structs are how you model domain concepts in Rust. Coming from Python, think of them as the data part of a class. The separation of data and behavior is intentional - Rust favors composition.

Creating struct instances

struct User {
    username: String,
    email: String,
    active: bool,
}

fn main() {
    let user1 = User {
        email: String::from("ada@example.com"),
        username: String::from("ada_lovelace"),
        active: true,
    };

    println!("Username: {}", user1.username);

    // Make mutable to change fields
    let mut user2 = User {
        email: String::from("grace@example.com"),
        username: String::from("grace_hopper"),
        active: true,
    };
    user2.email = String::from("new_email@example.com");
}

Try it in Rust Playground

Live demo: Create a struct instance. Show that the binding must be mutable to change a field. Rust does not apply mutability to individual fields of an otherwise immutable binding.

Adding behavior with impl blocks

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Method (takes &self)
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // Associated function (no self) - like a static method
    fn square(size: u32) -> Rectangle {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let rect = Rectangle { width: 30, height: 50 };
    println!("Area: {}", rect.area());

    let sq = Rectangle::square(10);
}

Try it in Rust Playground

impl blocks add methods to structs. Methods take self (or &self or &mut self). Associated functions don’t take self - they’re like constructors or static methods. You can have multiple impl blocks for organization.

Modeling choices with enum

• An enum (enumeration) represents a value that can be one of several variants
• Each variant can carry different data, making Rust enums useful for modeling alternatives
• Each variant can hold different types of data
• Useful when one value must be exactly one of several named variants

enum Shape {  // Define an enum to represent different geometric shapes
    Circle(f64),              // Circle variant holds radius
    Rectangle(f64, f64),      // Rectangle holds width and height
    Triangle(f64, f64),       // Triangle holds base and height
}

// Create instances of different shapes
let circle = Shape::Circle(5.0);                    // Circle with radius 5.0
let rectangle = Shape::Rectangle(4.0, 6.0);         // Rectangle 4.0 × 6.0
let triangle = Shape::Triangle(3.0, 8.0);           // Triangle with base 3.0, height 8.0

Try it in Rust Playground

Rust enums are algebraic data types: each variant can hold different data. Circle needs one dimension, while Rectangle and Triangle need two. This representation keeps the alternatives in one type and differs from C-style enums, which are named integer constants.

Computer science terminology: Rust enums are “sum types” or “tagged unions” from functional programming. They encode different states and their associated data within a single type, which the compiler checks exhaustively. The Shape example clearly shows this - each variant is mutually exclusive (a shape is a circle OR rectangle OR triangle, never multiple at once).

Pattern matching with match

enum Shape {  // Define different geometric shapes
    Circle(f64),              // Circle holds radius
    Rectangle(f64, f64),      // Rectangle holds width and height
    Triangle(f64, f64),       // Triangle holds base and height
}

fn area(shape: Shape) -> f64 {  // Calculate area for any shape
    match shape {  // Pattern match on the shape variant
        Shape::Circle(r) => {  // Extract radius from Circle
            println!("Calculating area of circle with radius {}", r);
            3.14159 * r * r  // Formula: πr²
        }
        Shape::Rectangle(w, h) => {  // Extract width and height
            w * h  // Formula: width × height
        }
        Shape::Triangle(b, h) => {  // Extract base and height
            0.5 * b * h  // Formula: ½ × base × height
        }
    }  // ✅ Compiler ensures we handle ALL variants!
}

fn main() {
    let circle = Shape::Circle(5.0);  // Create a circle with radius 5.0
    println!("Area: {:.2} square units", area(circle));  // Output: 78.54

    let rect = Shape::Rectangle(4.0, 6.0);  // Create a 4×6 rectangle
    println!("Area: {:.2} square units", area(rect));  // Output: 24.00
}

Try it in Rust Playground

For the live demo, remove one match arm and inspect the exhaustiveness error. Pattern matching extracts each variant’s data for its formula. Adding a variant can reveal match expressions that need updating, unless they use a wildcard arm.

AI copilot technique: designing with structs and enums

When modeling data, ask your AI assistant:

Effective prompts: - “Should I use a struct or enum for this? [describe data]” - “Help me model a [domain concept] in Rust with structs and enums” - “What fields should this struct have? [describe requirements]” - “Show me how to use match to handle all cases of this enum”

Example: “I need to model a blog post that can be Draft, Published, or Archived. Each state has different data. How should I structure this in Rust?”

Data modeling is a design skill. AI can compare struct and enum trade-offs and show idiomatic patterns. Ask for the reasoning with the code, then evaluate whether each variant represents the domain accurately.

Session 2: error handling and collections

Second session builds on structs/enums. Now we use two special enums (Option and Result) and work with dynamic collections. Emphasize that these aren’t “advanced” - they’re everyday Rust. Tie to ownership from last week.

The problem with null

• In Python, Java, C++, variables can be None/null
• This causes billions of dollars in bugs: Tony Hoare calls it his “billion-dollar mistake”
• The problem: you can forget to check for null, causing crashes
• Rust’s solution: no null - instead, use Option<T>

Null reference errors are among the most common bugs. Tony Hoare invented null and regrets it. Rust eliminates this entire category of bugs by making “might not exist” explicit in the type system.

Option<T>: handling optional values

enum Option<T> {
    Some(T),
    None,
}

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some(String::from("Alice"))
    } else {
        None
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("Found: {}", name),
        None => println!("User not found"),
    }

    // Shorthand with if let
    if let Some(name) = find_user(2) {
        println!("Found: {}", name);
    } else {
        println!("User not found");
    }
}

Try it in Rust Playground

Live demo: Show Option in action. Accessing the contained value requires considering whether it is Some or None; compare match with if let when only one pattern needs special handling.

Result<T, E>: recoverable errors

enum Result<T, E> {
    Ok(T),
    Err(E),
}

use std::fs::File;
use std::io::ErrorKind;

fn open_config() -> Result<File, std::io::Error> {
    File::open("config.txt")
}

fn main() {
    match open_config() {
        Ok(file) => println!("Opened file successfully"),
        Err(error) => match error.kind() {
            ErrorKind::NotFound => println!("File not found!"),
            other => println!("Error opening file: {:?}", other),
        },
    }
}

Try it in Rust Playground

Result is for operations that can fail. Like Option, the type system forces you to handle errors. No more forgotten try/catch! You can nest matches to handle specific error types. This is much safer than exceptions.

The ? operator: error propagation

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut file = File::open("username.txt")?; // propagates error if Err
    let mut username = String::new();
    file.read_to_string(&mut username)?;        // propagates error if Err
    Ok(username)                                  // ✅ returns Ok if success
}

// Without ? operator, this would be:
// match File::open("username.txt") {
//     Ok(mut file) => match file.read_to_string(&mut username) {
//         Ok(_) => Ok(username),
//         Err(e) => Err(e),
//     },
//     Err(e) => Err(e),
// }

The ? operator is syntactic sugar for error propagation. If Result is Err, it returns early with that error. If Ok, it unwraps the value and continues. This makes error handling code much cleaner. It’s like try/catch but explicit in types.

Important constraint: Remind students that the ? operator can only be used inside a function that returns a Result or an Option. The compiler will give an error if you try to use it in a function like main that doesn’t return one of these types (unless you change main’s return type to Result<(), E>).

AI copilot technique: error-handling patterns

When handling errors, ask your AI assistant:

Effective prompts: - “When should I use Option vs Result in Rust?” - “Help me handle this error idiomatically: [paste code]” - “Explain the ? operator and when I can use it” - “Convert this match error handling to use ? operator”

Pro tip: Ask AI to show both verbose (match) and concise (? operator) versions to understand what’s happening under the hood.

Error-handling patterns take practice. AI can show idiomatic approaches and explain trade-offs. Students should understand both match and the ? operator: ? provides concise propagation for compatible error types.

Common collections: Vec<T>

• Vec<T> (vector) is a growable array - like Python’s list
• Stores values of the same type
• Allocated on the heap (flexible size)
• Most common collection in Rust

fn main() {
    // Creating vectors
    let mut v: Vec<i32> = Vec::new();
    let mut v2 = vec![1, 2, 3]; // vec! macro for initial values

    // Adding elements
    v.push(5);
    v.push(6);

    // Accessing elements
    let third = &v2[2];         // Panics if out of bounds
    let maybe_third = v2.get(2); // Returns Option<&T>

    // Iterating
    for i in &v2 {
        println!("{}", i);
    }
}

Try it in Rust Playground

Live demo: Show Vec creation, push, indexing, and iteration. Explain that indexing panics when out of bounds while .get() returns Option. Show why an active immutable borrow prevents mutation through that vector binding.

Performance note: When a Vec grows beyond its capacity, it may allocate a larger buffer and move its elements. If measurements show repeated growth matters and the approximate size is known, Vec::with_capacity can reduce reallocations.

Strings in Rust: String and &str

• Rust has two main string types (not one!):
• String - Owned, growable, heap-allocated (like Vec<u8>)
• &str - String slice, borrowed, immutable view
• All strings are UTF-8 encoded

fn main() {
    // String - owned
    let mut s = String::from("hello");
    s.push_str(" world"); // Can modify

    // &str - borrowed string slice
    let slice: &str = &s[0..5]; // "hello"

    // String literals are &str
    let literal = "I'm a &str";

    // Converting
    let s2: String = literal.to_string();
    let slice2: &str = &s2;
}

Try it in Rust Playground

String vs &str confuses everyone. String is owned data, &str is a view into string data. Think: String is like Vec, &str is like &[u8]. String literals in code are &str with ’static lifetime. This follows ownership from Week 10.

API design: When a function only needs to read text, accepting &str is often more flexible than taking ownership of a String. Callers can pass a string slice or borrow a String without an unnecessary ownership transfer.

HashMap<K, V>: key-value storage

use std::collections::HashMap;

fn main() {
    // Creating
    let mut scores = HashMap::new();

    // Inserting
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // Accessing
    let team_name = String::from("Blue");
    let score = scores.get(&team_name);  // Returns Option<&V>

    match score {
        Some(&s) => println!("Score: {}", s),
        None => println!("Team not found"),
    }

    // Iterating
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

Try it in Rust Playground

Live demo: Show HashMap creation, insertion, and lookup. Note that .get() returns Option because a key might not exist. Inserting owned values normally moves them into the map.

Performance insight: Clarify that HashMap provides amortized O(1) (average constant time) performance for insertions and lookups, which is why it’s so fast. This is a key data structures concept.

Choosing the right collection

Vec<T> - Use when: - You need an ordered list - You want to access by index - You’ll add/remove from the end

String - Use when: - You need owned, growable text - Building strings dynamically

HashMap<K, V> - Use when: - You need key-value lookups - Order doesn’t matter - Fast access by key is important

Choosing collections is a design decision. Start with Vec for ordered sequences, HashMap for key-based lookups, and String for owned text. Rust also provides collections such as BTreeMap and HashSet. Ask: how will this program access and update the data?

Example: building a phone book

use std::collections::HashMap;

struct Contact {
    name: String,
    phone: String,
    email: Option<String>, // Email is optional
}

fn main() {
    let mut phone_book: HashMap<String, Contact> = HashMap::new();

    phone_book.insert(
        String::from("Alice"),
        Contact {
            name: String::from("Alice Smith"),
            phone: String::from("555-1234"),
            email: Some(String::from("alice@example.com")),
        }
    );

    // Look up by name
    if let Some(contact) = phone_book.get("Alice") {
        println!("Phone: {}", contact.phone);
        if let Some(email) = &contact.email {
            println!("Email: {}", email);
        }
    }
}

Try it in Rust Playground

This example ties everything together: struct for Contact, Option for optional email, HashMap for storage, if let for handling Options. This is how real Rust programs are structured. Show students this is production-quality code.

AI copilot technique: working with collections

When using collections, ask your AI assistant:

Effective prompts: - “Which Rust collection should I use for [describe use case]?” - “Help me convert this Python list comprehension to Rust: [paste code]” - “Show me how to iterate over a HashMap in Rust” - “How do I handle the Option returned by HashMap.get()?” - “What’s the difference between Vec::push and Vec::append?”

Example: “I have a list of user IDs and need fast lookup. Should I use Vec or HashMap?”

Collections have many methods. AI can help locate a method and compare trade-offs such as ordered traversal versus key-based lookup. Students should verify that the suggested collection matches the program’s access patterns.

Introducing Lab 11: structs, enums, and methods

Implement the supplied types in src/student.rs:

1. Student methods
   • Construction, credits, class standing, graduation eligibility, grades, and GPA
2. Grade and CourseGrade methods
   • Parse letter grades, convert GPA points, and calculate quality points
3. StudentDatabase methods
   • Store students in a HashMap, reject duplicate IDs, search, count, and summarize GPA

Do not change the supplied types or test module. Rename placeholder parameters by dropping their leading underscore.

Full instructions: week11/lab11.md

Connect each method to today’s structs, enums, impl blocks, Option, Result, and HashMap examples. The data model is supplied; students implement its behavior.

Where these Rust patterns appear

Examples to investigate:

• Discord - Structs for message data, enums for event types
• Dropbox - Result for error handling, HashMap for file tracking
• Cloudflare - Vec for request queues, modules for organization

Questions for review: - “How does Rust handle errors differently than exceptions?” - “When would you use an enum instead of inheritance?” - “Explain Option vs Result”

These patterns appear throughout Rust libraries and applications. Ask students to connect each one to a concrete benefit: explicit failure paths with Result, valid-state modeling with enums, and ownership-aware collections.

Preview: you have been using generics

Notice the angle brackets?

let mut numbers: Vec<i32> = Vec::new();
let result: Result<String, io::Error> = read_file();
let maybe_value: Option<&str> = map.get("key");
let mut scores: HashMap<String, i32> = HashMap::new();

What <T> means: - Vec<i32> = “a vector of i32 values” - Result<String, io::Error> = “success gives String, error gives io::Error” - Option<&str> = “maybe a &str, maybe nothing” - HashMap<String, i32> = “map from String keys to i32 values”

You’ve been using generic types all along!

Students have already used Vec<T>, Option<T>, and Result<T, E>. Point out that the type parameters inside angle brackets identify the concrete types involved; next week they will define their own generic types.

Next week: writing your own generics

Week 12 preview - Generics and Traits:

You’ll learn to: - Write generic functions that work with any type - Create generic structs like Stack<T> or Cache<K, V> - Define traits (Rust’s version of interfaces) - Implement traits like Display, Iterator, Clone - Use trait bounds to constrain generic types

Why it matters: - Write reusable code without duplication - Static dispatch can generate specialized code; dynamic dispatch remains available when needed - Trait bounds state which operations a generic implementation requires - Patterns used throughout Rust libraries and applications

Teaser: Lab 12 will have you build a generic Stack<T> that works with any type!

Connect familiar uses (Vec<T>, Option<T>, and Result<T, E>) to next week’s task of defining Stack<T> and its trait bounds.

Resources for going deeper

Official Rust documentation: - The Rust Book - Chapter 7: Modules - The Rust Book - Chapter 5: Structs - The Rust Book - Chapter 6: Enums and Pattern Matching - The Rust Book - Chapter 9: Error Handling - The Rust Book - Chapter 8: Collections

Interactive practice: - Rust by Example - Modules - Rust by Example - Error Handling - Rustlings - Structs Exercises

Treat the Rust Book chapters as primary references and Rustlings as optional practice. Route students to the chapter that matches the specific concept they need.

Questions?

Remember: - Modules organize code, structs/enums organize data - Option<T> eliminates null pointer errors - Result<T, E> makes error handling explicit - Collections (Vec, String, HashMap) follow ownership rules - Use AI to explore design patterns and learn idioms

Lab 11 workflow:

cargo test
cargo fmt
cargo clippy -- -D warnings
git add week11/
git commit -m "Complete Lab 11"
git push origin main

A green Week 11 badge represents the complete 10-point lab.

Office hours: Available on Microsoft Teams - reach out anytime!

End on an encouraging note. Today’s content is dense but practical. Every concept (modules, structs, enums, Result, collections) is used daily in production Rust. The lab lets them apply it all. Remind them that understanding ownership makes this week easier.