Deryks _dev

Point it somewhere safe

The editor opens a scratch file instead of its own source.

cd editor
printf 'scratch file\n\nedit me freely\n' > scratch.md

One edit — open that instead:

editor/src/main.rsat the bottom of main

        Box::new(|_cc| Ok(Box::new(Editor::open("src/main.rs")))),
        Box::new(|_cc| Ok(Box::new(Editor::open("scratch.md")))),

cargo run
→ a window showing scratch file / edit me freely

Remember which file

The window shows the name of the file you're editing.

open takes a path, uses it, and forgets it. To save, the editor has to still know where the text came from — so the path has to become part of the editor's state, not just an argument that passes through. Three edits.

First — give the struct somewhere to keep it:

editor/src/main.rsthe Editor struct

struct Editor {
    path: String,
    text: String,
}

String, not &str. The editor has to own its path — it must stay alive for as long as the editor does, and a borrowed&str would be tied to whatever it was borrowed from.

Second — fill it in:

editor/src/main.rsin Editor::open

        };
        Self { text }
        Self {
            path: path.to_owned(),
            text,
        }
    }

The parameter is still &str — borrowed, so callers can pass a literal — and to_owned() makes the editor's own copy. Note the two styles side by side: path: path.to_owned() spells out the field, while textuses the shorthand from lesson 2 because the variable already has the field's name.

Third — show it, replacing the hardcoded heading:

editor/src/main.rsin fn ui

            ui.heading("editor");
            ui.heading(&self.path);

cargo run
→ the window is now headed scratch.md

Write it back — and get told off

Ctrl+S changes the file on disk. The compiler is not happy about how.

Three edits. First, one more module:

editor/src/main.rstop of the file

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

Second — teach the editor to write. Put this inside your existingimpl Editor block, just after open:

editor/src/main.rsin impl Editor, after open

    }

    /// Write the buffer back to the file it came from.
    fn save(&self) -> io::Result<()> {
        fs::write(&self.path, &self.text)
    }
}

io::Result<()> is the same Result from lesson 2 with the error type already filled in — io::Result<T> is just a shorthand for Result<T, io::Error>. The () is theunit type: "succeeded, and there's no value to give you." A write either worked or it didn't; there's nothing to hand back.

There's no match here and no semicolon on that last line. The function just returns whatever fs::write returned — success or failure, untouched, straight up to whoever called it.

Third — trigger it. Add this as the first thing inside the panel closure:

editor/src/main.rsin fn ui, top of the panel closure

        egui::CentralPanel::default().show(ui, |ui| {
            let save_requested = ui.input(|i| i.modifiers.command && i.key_pressed(egui::Key::S));
            if save_requested {
                self.save();
            }
            ui.heading(&self.path);

ui.input(…) hands you this frame's input state to ask questions of.modifiers.command is Ctrl on Linux and Windows, ⌘ on macOS — one check for both. key_pressed is true only on the frame the key went down, not while it's held, which is what stops one keystroke from saving sixty times a second.

cargo run
→ type something, press Ctrl+S, then in another terminal:
cat editor/scratch.md
Your edits are there. It genuinely saved.

It works. It also produces this:

warning: unused `std::result::Result` that must be used
  --> src/main.rs:39:17
   |
39 |                 self.save();
   |                 ^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value

Result is marked #[must_use], an attribute that tells the compiler to complain if a value is dropped on the floor. Very few types carry it. This one does because a discarded Result is almost always a mistake — it's an error that was reported to you and that you didn't read.

Note the help: line: let _ = … silences it. That's the escape hatch for when ignoring really is right, and it's deliberately something you have to type. The point isn't that you can never discard aResult — it's that you can't do it silently.

Say what happened

A status line reports every save — including the ones that fail.

Five edits, and the file won't compile until all five are in.

First and second — the editor needs somewhere to put a message, andopen has to start it empty:

editor/src/main.rsthe Editor struct

struct Editor {
    path: String,
    text: String,
    status: String,
}

editor/src/main.rsin Editor::open

        Self {
            path: path.to_owned(),
            text,
            status: String::new(),
        }

Third — save gains a second job, and that's where ?arrives:

editor/src/main.rsin impl Editor

    fn save(&self) -> io::Result<()> {
        fs::write(&self.path, &self.text)
    fn save(&mut self) -> io::Result<()> {
        fs::write(&self.path, &self.text)?;
        self.status = format!("saved {} bytes to {}", self.text.len(), self.path);
        Ok(())
    }

That ? is the whole idea of this lesson. Read it as: if this is anErr, stop here and return it to my caller; otherwise unwrap theOk and carry on. It's the same match you wrote in lesson 2, compressed into one character:

The point isn't brevity — it's who decides. save has no idea whether a failed write should show a message, retry, or quit; it isn't the part of the program that knows. So it doesn't decide. It hands the failure upward and lets the caller, which has the context, do something sensible. That's propagation, and it's why the status line only gets set on the success path — a failed write returns before it ever gets there.

Also note &self became &mut self:save now modifies status, and bylesson 1's rule that needs an exclusive borrow. Miss this edit and the compiler will tell you, in almost the same words as lesson 1.

Fourth — the caller, which does know what to do:

editor/src/main.rsin fn ui, top of the panel closure

            let save_requested = ui.input(|i| i.modifiers.command && i.key_pressed(egui::Key::S));
            if save_requested {
                self.save();
            }
            if save_requested && let Err(error) = self.save() {
                self.status = format!("save failed: {error}");
            }

Fifth — somewhere to show it. This is an extra label, added below the byte counter; the byte counter stays.

editor/src/main.rsin fn ui, below the byte counter

            ui.label(format!("{} bytes", self.text.len()));
            ui.label(&self.status);

if … let Err(error) = self.save() is a let-chain: run the save only if a save was asked for, and take the branch only if the result matchedErr. The let Err(error) = … half is if let — amatch when you only care about one shape and want to ignore the rest. You could write it as a two-armed match with an empty Ok arm;if let says the same thing without the ceremony.

I didn't choose this shape — clippy did. The obvious version nests an if let inside an if, and clippy answers"this if statement can be collapsed". Run cargo clippyoften enough and it will teach you the idioms without you going looking for them.

cargo run
→ press Ctrl+S: saved 31 bytes to scratch.md
And the warning is gone — cargo clippy should now be silent.

Now make it fail

A status line that only ever says nice things proves nothing. Take away your own permission to write the file:

chmod 444 editor/scratch.md
→ run again, edit, Ctrl+S: save failed: Permission denied (os error 13)

The editor stayed open, kept your text, and told you what went wrong. Compare that with the two alternatives you've now seen: unwrap() would have killed the process mid-edit and lost the buffer, and the ignored Result from stage 3 would have told you it saved when it hadn't — which is worse than crashing, because you'd have closed the window believing your work was on disk.