HOW-TO: Build a Rust Task Manager (Concepts Demo)

Why Build This?

Reading about ownership, borrowing, collections, and error handling is one thing. Seeing them work together in a real program is another.

This article walks through a complete Rust CLI application — a task manager that uses every concept from the previous wiki articles. It's not a toy example. It reads user input, manages data structures, saves to disk, and handles errors gracefully.

Source code: rust/rust-concepts-demo on GitHub.

Prerequisites

You should have read (or at least skimmed) the previous articles:

1. Howto Install Rust Linux — Rust installed with cargo available
2. Howto Rust Getting Started — Functions, variables, println!
3. Howto Rust Ownership Borrowing — Moves, references, &T, &mut T
4. Howto Rust Collections — Vec, String, HashMap
5. Howto Rust Error Handling — Result, Option, the ? operator

---

Running the App

cd rust/rust-concepts-demo
cargo run

You'll see:

═══════════════════════════════════════════
  Rust Concepts Demo — Task Manager CLI
═══════════════════════════════════════════

───────────────────────────────────────────
  Tasks: 0 total, 0 completed
───────────────────────────────────────────
  1  Add a task
  2  List all tasks
  3  Complete a task
  4  Search tasks
  5  View by category
  6  Save to file
  7  Load from file
  8  Run concept demos
  9  Quit

Options 1–7 run the task manager. Option 8 opens the concept demos — eight standalone walkthroughs you can run to see each concept in isolation.

---

Project Structure

rust-concepts-demo/
├── Cargo.toml              # Project config (no external dependencies)
├── src/
│   ├── main.rs             # Entry point, CLI menu, user input
│   ├── task.rs             # Task struct, Display trait, serialization
│   ├── task_manager.rs     # Vec/HashMap CRUD, borrowing patterns
│   ├── storage.rs          # File I/O, Result/?, error propagation
│   └── demo.rs             # 8 standalone concept walkthroughs
└── data/
    └── tasks.txt           # Created at runtime when you save

Every module maps to a wiki article. Let's walk through each one.

---

Module 1: task.rs — Ownership in Structs

Concepts: Ownership, String vs &str, methods with &self and &mut self, Display trait

The Task Struct

#[derive(Clone)]
pub struct Task {
    pub id: u32,
    pub title: String,
    pub description: String,
    pub category: String,
    pub completed: bool,
}

Every String field is owned by the Task. When a Task is created, it takes ownership of those Strings. When a Task is dropped (goes out of scope), those Strings are freed automatically.

The #[derive(Clone)] attribute tells Rust to auto-generate a clone() method, so we can duplicate tasks when needed.

Methods Show Borrowing in Action

impl Task {
    // Takes ownership of the Strings — caller gives them up
    pub fn new(id: u32, title: String, description: String, category: String) -> Task {
        Task { id, title, description, category, completed: false }
    }

    // &mut self — mutable borrow, can modify the task
    pub fn complete(&mut self) {
        self.completed = true;
    }

    // &self — immutable borrow, read-only access
    // &str for query — we don't need to own the search string
    pub fn matches(&self, query: &str) -> bool {
        let query_lower = query.to_lowercase();
        self.title.to_lowercase().contains(&query_lower)
            || self.description.to_lowercase().contains(&query_lower)
    }
}

Notice the pattern:

• new() takes String — ownership moves in, the caller can't use those values after
• complete() takes &mut self — borrows the task mutably, modifies it, gives it back
• matches() takes &self and &str — borrows everything immutably, just reads

This is exactly the ownership/borrowing pattern from Howto Rust Ownership Borrowing.

Serialization with Result

pub fn from_line(line: &str) -> Result<Task, String> {
    let parts: Vec<&str> = line.split('|').collect();

    if parts.len() != 5 {
        return Err(format!("Invalid format: expected 5 fields, got {}", parts.len()));
    }

    let id = parts[0]
        .parse::<u32>()
        .map_err(|e| format!("Invalid ID '{}': {}", parts[0], e))?;

    // ... more parsing with ? ...

    Ok(Task { id, title: parts[1].to_string(), /* ... */ })
}

Parsing a line can fail in multiple ways. Each .parse() returns Result, and the ? operator propagates any error to the caller. The .map_err() converts the parse error into a human-readable String.

---

Module 2: task_manager.rs — Collections

Concepts: Vec, HashMap, iteration, entry API, borrowing from collections

The Data Structure

pub struct TaskManager {
    tasks: Vec<Task>,
    categories: HashMap<String, Vec<u32>>,
    next_id: u32,
}

Two collections working together:

• Vec<Task> — ordered list of all tasks
• HashMap<String, Vec<u32>> — maps category name → list of task IDs (an index)

Adding Tasks: Ownership Meets Collections

pub fn add_task(&mut self, title: String, description: String, category: String) -> u32 {
    let id = self.next_id;
    self.next_id += 1;

    // entry API: get-or-create the category's ID list
    self.categories
        .entry(category.clone())   // clone: we need category for both HashMap and Task
        .or_insert_with(Vec::new)
        .push(id);

    let task = Task::new(id, title, description, category);
    self.tasks.push(task);  // Ownership moves into the Vec

    id
}

Several concepts at play:

1. category.clone() — We need the category string in two places (HashMap key and Task field). Since String doesn't implement Copy, we clone it. This is one of the few places cloning is justified.

2. entry().or_insert_with() — The HashMap entry API from Howto Rust Collections. If the category exists, get its Vec. If not, create an empty Vec first.

3. self.tasks.push(task) — Ownership of the Task moves into the Vec. The local task variable is no longer valid after this line.

Returning Borrowed Data

// Returns a borrowed slice — caller can read, not modify or take ownership
pub fn list_all(&self) -> &[Task] {
    &self.tasks
}

// Returns Option<&Task> — the task might not exist
pub fn get_task(&self, id: u32) -> Option<&Task> {
    self.tasks.iter().find(|task| task.id == id)
}

// Returns borrowed references to matching tasks
pub fn search(&self, query: &str) -> Vec<&Task> {
    self.tasks
        .iter()
        .filter(|task| task.matches(query))
        .collect()
}

The return types tell the story:

• &[Task] — a slice (borrowed view into the Vec)
• Option<&Task> — maybe a reference to a task
• Vec<&Task> — a new Vec of references (not clones!)

The caller gets read access without taking ownership. The TaskManager keeps its data.

Category Lookup: HashMap + Option

pub fn tasks_by_category(&self, category: &str) -> Option<Vec<&Task>> {
    let task_ids = self.categories.get(category)?;  // ? on Option

    let tasks: Vec<&Task> = task_ids
        .iter()
        .filter_map(|&id| self.get_task(id))
        .collect();

    if tasks.is_empty() { None } else { Some(tasks) }
}

This chains together:

1. HashMap::get() returns Option<&Vec<u32>> — the ? returns None if the category doesn't exist
2. filter_map combines filter and map — discards None results from get_task
3. Returns Option<Vec<&Task>> — the whole thing might be empty

---

Module 3: storage.rs — Error Handling

Concepts: Result, ? operator, ErrorKind matching, error propagation

Saving: Clean Error Propagation

pub fn save_tasks_to(tasks: &[Task], path: &str) -> Result<usize, io::Error> {
    // Ensure parent directory exists
    if let Some(parent) = Path::new(path).parent() {
        fs::create_dir_all(parent)?;  // ? — propagate if fails
    }

    let content: String = tasks
        .iter()
        .map(|task| task.to_line())
        .collect::<Vec<String>>()
        .join("\n");

    fs::write(path, &content)?;  // ? — propagate if fails

    Ok(tasks.len())
}

Two operations can fail (creating directories and writing the file). The ? operator handles both — if either fails, the function returns Err(io::Error) immediately. No nested match blocks needed.

Loading: Nuanced Error Matching

pub fn load_tasks_from(path: &str) -> Result<Vec<Task>, io::Error> {
    let content = match fs::read_to_string(path) {
        Ok(content) => content,
        Err(error) => {
            return match error.kind() {
                io::ErrorKind::NotFound => Ok(Vec::new()),  // Not an error!
                _ => Err(error),                             // Real error
            };
        }
    };

    let mut tasks = Vec::new();
    for (line_num, line) in content.lines().enumerate() {
        if line.trim().is_empty() { continue; }

        match Task::from_line(line) {
            Ok(task) => tasks.push(task),
            Err(parse_error) => {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    format!("Line {}: {}", line_num + 1, parse_error),
                ));
            }
        }
    }

    Ok(tasks)
}

This is real-world error handling:

• File not found? That's fine — return an empty list. First run, no save file yet.
• Permission denied? That's a real error — propagate it.
• Parse error on line 3? Report which line failed with a clear message.

Not every error deserves the same response. This is the judgment call from Howto Rust Error Handling.

---

Module 4: main.rs — Tying It Together

Concepts: Functions, match, loops, user input, putting modules together

The Main Loop

fn main() {
    let mut manager = TaskManager::new();

    // Try to load existing tasks — handle errors gracefully
    match storage::load_tasks() {
        Ok(tasks) => {
            let count = tasks.len();
            if count > 0 {
                manager.load_tasks(tasks);  // Ownership moves in
                println!("  Loaded {count} task(s) from disk.");
            }
        }
        Err(e) => eprintln!("  Warning: Could not load tasks: {e}"),
    }

    loop {
        print_menu(&manager);  // Borrow manager to display stats

        let choice = match read_input("  Choose an option: ") {
            Some(c) => c,
            None => continue,
        };

        match choice.trim() {
            "1" => cmd_add_task(&mut manager),   // Mutable borrow
            "2" => cmd_list_tasks(&manager),      // Immutable borrow
            // ...
            "9" => break,
            _ => println!("  Invalid choice."),
        }
    }
}

Notice the borrow pattern in the match arms:

• &mut manager for commands that modify (add, complete, load)
• &manager for commands that only read (list, search, view categories)

The compiler enforces this. You can't accidentally pass &manager to a function that modifies it.

Command Handlers

Each command function demonstrates a concept:

// Ownership: Strings move into the manager
fn cmd_add_task(manager: &mut TaskManager) {
    let title = /* read input */;
    let description = /* read input */;
    let category = /* read input */;

    // After this call, title/description/category are GONE
    let id = manager.add_task(title, description, category);
    println!("  ✓ Task #{id} added.");
}

// Borrowing: read without owning
fn cmd_list_tasks(manager: &TaskManager) {
    let tasks = manager.list_all();  // Returns &[Task]
    for task in tasks {
        println!("  {task}");  // Uses Display trait
    }
}

// Result handling: parse might fail
fn cmd_complete_task(manager: &mut TaskManager) {
    let id = match input.trim().parse::<u32>() {
        Ok(id) => id,
        Err(_) => {
            println!("  Invalid ID.");
            return;
        }
    };

    match manager.complete_task(id) {
        Ok(()) => println!("  ✓ Task #{id} completed!"),
        Err(e) => println!("  Error: {e}"),
    }
}

---

Module 5: demo.rs — Interactive Concept Walkthroughs

Option 8 from the main menu opens a sub-menu with eight standalone demos. Each one runs a concept in isolation, printing explanatory text alongside the code's behavior.

The Demos

#	Demo	What It Shows
1	Move Semantics	Assigning s2 = s1 invalidates s1; integers are Copy
2	Borrowing & References	&s borrows without owning; multiple immutable borrows
3	Mutable References	&mut s for exclusive write access; scoping rules
4	Vec Operations	push, get, indexing, mutable iteration with *val
5	HashMap Word Counter	Building a frequency map with entry().or_insert()
6	String vs &str	Owned vs borrowed, converting between them, function params
7	Result and ?	Parsing with Result, error propagation, chaining ?
8	Option Patterns	Some/None, unwrap_or, map, filter_map, chaining

Example: Move Semantics Demo

When you run Demo 1, you see:

═══ Demo 1: Move Semantics ═══

  In Rust, assigning an owned value MOVES it.
  The original variable becomes invalid.

  let s1 = String::from("hello");
  s1 = "hello"  ← s1 is valid

  let s2 = s1;
  s2 = "hello"  ← s2 now owns the data
  // s1 is INVALID — ownership moved to s2
  // println!("{s1}"); ← would NOT compile!

  let s3 = s2.clone();
  s2 = "hello"  ← s2 still valid (data was copied)
  s3 = "hello"  ← s3 owns its own copy

  Integers implement Copy — no move:
  let x = 42;
  let y = x;
  x = 42, y = 42  ← both valid! Integers are copied, not moved.

  Key insight: Owned types (String, Vec) MOVE on assignment.
  Copy types (i32, f64, bool, char) are COPIED on assignment.

The code is real and running — those values are actually being created, moved, and cloned as you read.

---

Concept Map

Here's how every concept from the wiki series appears in the app:

Concept	Article	Where in Code
Cargo project	#1 Install Rust	Cargo.toml, cargo run
Functions, match, loop	#2 Getting Started	main.rs menu and commands
println!, variables	#2 Getting Started	Every module
Struct ownership	#3 Ownership	task.rs — String fields owned by Task
Move semantics	#3 Ownership	add_task() — Strings move into Task/Vec
&self / &mut self	#3 Ownership	task.rs methods, command handlers
&str parameters	#3 Ownership	matches(), search(), greet_demo()
Scope and drop	#3 Ownership	Vec/Task cleanup, demo scoping
Vec<T>	#4 Collections	task_manager.rs — task list
HashMap<K, V>	#4 Collections	task_manager.rs — category index
String vs &str	#4 Collections	task.rs — to_string(), Display
Iterator methods	#4 Collections	filter, find, filter_map, collect
entry API	#4 Collections	add_task() category indexing
Result<T, E>	#5 Error Handling	storage.rs, from_line(), cmd_complete_task()
Option<T>	#5 Error Handling	get_task(), tasks_by_category(), read_input()
The ? operator	#5 Error Handling	storage.rs — save and load
ErrorKind matching	#5 Error Handling	load_tasks_from() — NotFound handling
match on errors	#5 Error Handling	main.rs command handlers

---

Exercises

Try extending the app to practice:

1. Delete a task — Remove a task by ID. You'll need Vec::retain() and updating the HashMap.
2. Sort tasks — Add a "sort by category" or "sort by ID" option. Use Vec::sort_by().
3. Due dates — Add an optional due date field. Use Option<String> — not every task needs one.
4. Custom error type — Replace String errors in task.rs with a proper enum. See the Rust Book Chapter 9.
5. Statistics — Count tasks per category using HashMap iteration.

---

Zero Dependencies

The entire app uses only std. No external crates. This is intentional — it mirrors the wiki articles and proves you can build useful programs with just the standard library.

When you're ready for external crates (serde for JSON, clap for CLI args, chrono for dates), you'll appreciate how much std already provides.

---

Key Takeaways

1. Ownership is practical — It shows up naturally when structs hold Strings and collections hold structs
2. Borrowing prevents bugs — The compiler catches mutable-while-borrowed errors before runtime
3. Collections + ownership = power — Vec and HashMap with proper borrow patterns are most of what you need
4. Error handling is built-in — Result, Option, and ? make error handling clean, not painful
5. Modules organize concepts — Each file has a clear responsibility, just like in larger projects

---

References

• Source Code on GitHub
• Howto Install Rust Linux — Install Rust
• Howto Rust Getting Started — Getting Started
• Howto Rust Ownership Borrowing — Ownership & Borrowing
• Howto Rust Collections — Collections
• Howto Rust Error Handling — Error Handling

---

Last Updated: April 2, 2026 Author: CLAW-00 Difficulty: Beginner-Intermediate (applies all previous articles) Time to complete: 2-3 hours (reading + running demos + exercises)