Deryks _dev

Reach for a file, and get refused

The compiler rejects your code — and tells you exactly what's wrong.

Two edits. First, bring the filesystem module into scope:

editor/src/main.rstop of the file

use eframe::egui;
use std::fs;

std is Rust's standard library, always available, nothing to install.fs is its filesystem module. A use line doesn't import code so much as shorten a name — without it you'd writestd::fs::read_to_string(…) every time.

Second, swap the hardcoded greeting for a file read:

editor/src/main.rsin Default::default

        Self {
            text: "Hello, editor.\n".to_owned(),
            text: fs::read_to_string("src/main.rs"),
        }

cargo check

It doesn't compile. Verbatim:

error[E0308]: mismatched types
  --> src/main.rs:11:19
   |
11 |             text: fs::read_to_string("src/main.rs"),
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `String`, found `Result<String, Error>`
   |
   = note: expected struct `String`
                found enum `std::result::Result<String, std::io::Error>`
help: consider using `Result::expect` to unwrap the `Result` value, panicking if the value is a `Result::Err`
   |
11 |             text: fs::read_to_string("src/main.rs").expect("REASON"),
   |                                                    +++++++++++++++++

This is the central move. In many languages, reading a missing file throws an exception — an invisible second exit from the function that you can ignore until it surprises you in production. Rust has no exceptions. Failure comes back as an ordinaryreturn value, of type Result, and the type system won't let you mistake it for the success case.

Result<String, Error> reads as: either a String, or an Error. It's an enum — a type that is exactly one of a fixed set of shapes. This one has two:

Note what the compiler suggested: .expect("REASON"). That compiles, and it's wrong here — stage 3 shows what it actually does. Thehelp: line is usually right, but it optimises for "make this compile", not "make this good."

Say what to do about both

Your editor opens, showing its own source code.

Replace the whole body of default:

editor/src/main.rsin Default::default

    fn default() -> Self {
        Self {
            text: fs::read_to_string("src/main.rs"),
        }
        let text = match fs::read_to_string("src/main.rs") {
            Ok(contents) => contents,
            Err(error) => format!("could not open src/main.rs\n\n{error}"),
        };
        Self { text }
    }

match takes a value apart. You list every shape it could have, and what to produce for each. It's exhaustive: delete the Err arm and the compiler rejects the program, because you'd have left a possible shape unhandled. That exhaustiveness is why Rust programs rarely die of an unconsidered case.

Read the arms as: if it's Ok, name the contentscontents and use them; if it's Err, name the problemerror and build a message instead. Either way the matchevaluates to a String, which is what text needs.

format! is println!'s sibling — same macro, but it returns the string instead of printing it. {error} drops the variable straight into the text.

Self { text } is shorthand. When a variable's name is already the field's name, you write it once instead of text: text. Rust leans on this constantly.

cargo run
→ your editor, showing the source code of your editor

Break it on purpose

Point at a file that doesn't exist. The editor still opens.

Misspell the filename — mian instead of main:

editor/src/main.rsin Default::default

        let text = match fs::read_to_string("src/main.rs") {
        let text = match fs::read_to_string("src/mian.rs") {

cargo run
→ a window containing:

could not open src/main.rs

No such file or directory (os error 2)

No crash. The Err arm ran, produced a String like any other, and the program carried on. Your editor degraded instead of dying — which for a tool someone else might run is the difference between "handled that badly" and "handled that".

What the compiler suggested instead

Back in stage 1, rustc offered you .expect("REASON"). It has a shorter sibling, .unwrap(). Both mean: give me theString, and if it's an Err, kill the program. Had you written fs::read_to_string("src/mian.rs").unwrap(), this is what you'd have got instead of a window:

thread 'main' panicked at src/main.rs:10:38:
called `Result::unwrap()` on an `Err` value: Os { code: 2, kind: NotFound,
message: "No such file or directory" }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

That's a panic: the program aborts immediately. It's one line of code instead of four, which is exactly why it's tempting and why it's everywhere in tutorials. Your mission says no unwrap() in the hot path, and this is why — a text editor that vanishes because a path was mistyped is not a text editor.

unwrap() is not forbidden, it's a claim. It says "this cannot fail, and I accept a crash if I'm wrong." That's fine in a test or a throwaway script. In code a reviewer is reading as a work sample, every unwrap() is a claim you'd better be able to defend.

Give it a name

Same behaviour, but the code now says what it does.

Two edits. default() is the wrong home for this: a Rust reader expectsDefault to hand back a cheap, obvious starting value, not to touch the disk. And the path is written twice, so the two copies can drift apart. Both problems disappear if the file-opening gets a name and a parameter.

First edit — replace the entire impl Default block:

editor/src/main.rsreplacing impl Default for Editor

impl Default for Editor {
    fn default() -> Self {
        let text = match fs::read_to_string("src/main.rs") {
            Ok(contents) => contents,
            Err(error) => format!("could not open src/main.rs\n\n{error}"),
        };
        Self { text }
    }
}
impl Editor {
    /// Open a file into a new editor. A failure becomes the buffer contents,
    /// so the window always opens.
    fn open(path: &str) -> Self {
        let text = match fs::read_to_string(path) {
            Ok(contents) => contents,
            Err(error) => format!("could not open {path}\n\n{error}"),
        };
        Self { text }
    }
}

impl Editor — no for. Lesson 1's impl Default for Editor was fulfilling somebody else's contract. This one just attaches a function of your own to your own type. Same keyword, two different jobs, and thefor is the tell.

The parameter is &str, not String — a borrowed view of text, because open only needs to read the path, not own it. That's the same distinction fromlesson 1, stage 4, now paying rent: take the borrowed type and callers can pass a literal without allocating anything.

Those /// lines are a doc comment. Not decoration — cargo doc --open turns them into real documentation, and a reviewer will look for them.

Second edit — Editor::default() no longer exists, so mainhas to call the new name:

editor/src/main.rsat the bottom of main

    eframe::run_native(
        "editor",
        options,
        Box::new(|_cc| Ok(Box::new(Editor::default()))),
        Box::new(|_cc| Ok(Box::new(Editor::open("src/main.rs")))),
    )

cargo run
→ identical to stage 2 — and that's the point
Then: cargo fmt && cargo clippy — both should be silent.

Relative to what? cargo run starts your program with the working directory set to the crate root — editor/ — so"src/main.rs" resolves. Run the binary straight out oftarget/debug/ instead and it won't, because the working directory is wherever you were standing. Lesson 3 takes the path from the command line and the question stops mattering.