Deryks _dev

Name what you actually have

Identical behaviour, honest names — one file, still working.

This stage changes no behaviour at all. It renames the thing you have and builds a new thing around it. Eight edits, and it won't compile until all eight are in.

First — rename the struct. The file-shaped fields stay; the app-shaped ones leave:

editor/src/main.rsthe Editor struct

struct Editor {
/// One open file.
struct Buffer {
    path: String,
    text: String,
    status: String,
    position: String,
    frame_ms: f32,
    line_col_us: f32,
}

Second — the impl block moves with it, and open stops setting the three fields that just left the struct:

editor/src/main.rsthe impl block

impl Editor {
impl Buffer {
open, save and line_col carry on unchanged — only the tail of open loses lines
            text,
            status,
            position: "no cursor".to_owned(),
            frame_ms: 0.0,
            line_col_us: 0.0,
        }
    }

Third — a tab needs a short label, so give Buffer one more method, after line_col:

editor/src/main.rsin impl Buffer, after line_col

    /// Just the file name, for the tab label.
    fn name(&self) -> &str {
        self.path.rsplit('/').next().unwrap_or(&self.path)
    }

Returning &str rather than String means no allocation per tab per frame — it's a borrowed window onto the path the buffer already owns. Remember this method. Lesson 10 comes back for it.

Fourth — a new Editor, holding many buffers and one of everything else:

editor/src/main.rsbelow impl Buffer

struct Editor {
    buffers: Vec<Buffer>,
    active: usize,
    position: String,
    frame_ms: f32,
    line_col_us: f32,
}

impl Editor {
    fn open(paths: &[String]) -> Self {
        let buffers = paths.iter().map(|p| Buffer::open(p)).collect();
        Self {
            buffers,
            active: 0,
            position: "no cursor".to_owned(),
            frame_ms: 0.0,
            line_col_us: 0.0,
        }
    }
}

Fifth — the status panel. It reads the file's text and status, and there is no longer a single file to read them from, so it goes through the active buffer:

editor/src/main.rsin fn ui, the bottom panel

        egui::Panel::bottom("status").show(ui, |ui| {
            let highlighting = if self.text.len() > HIGHLIGHT_LIMIT {
            let highlighting = if self.buffers[self.active].text.len() > HIGHLIGHT_LIMIT {
the two arms and the start of the label, unchanged
                self.position,
                self.text.len(),
                self.buffers[self.active].text.len(),
                self.line_col_us,
                self.frame_ms
            ));
            ui.label(&self.status);
            ui.label(&self.buffers[self.active].status);
        });

Why not let buffer = … up here too? Because this closure runs before the one below it, and each panel borrows self separately — a binding made here wouldn't be in scope down there. Three uses isn't enough repetition to be worth restructuring for.

Sixth — the central panel, where it is worth it. Reach the current file once at the top and use it throughout:

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

            let buffer = &mut self.buffers[self.active];
            let save_requested = ui.input(…);

Seventh — Editor::open wants a slice of paths, and mainstill has a single String. Wrap it in a one-element vector; stage 2 replaces this line with the real thing:

editor/src/main.rstop of main

    let path = env::args()
        .nth(1)
        .unwrap_or_else(|| "scratch.md".to_owned());
    let paths = vec![path];

Eighth — and now main can pass it:

editor/src/main.rsat the bottom of main

        Box::new(|_cc| Ok(Box::new(Editor::open(&path)))),
        Box::new(|_cc| Ok(Box::new(Editor::open(&paths)))),

cargo run
→ exactly what you had before
A refactor that changes nothing visible is the safest kind, and the only kind you can be sure you got right.

Take more than one path

cargo run -- a.rs b.rs opens both. You'll only see the first.

One edit. nth(1) took the second argument;skip(1) takes all of them:

editor/src/main.rstop of main

    let path = env::args()
        .nth(1)
        .unwrap_or_else(|| "scratch.md".to_owned());
    let paths = vec![path];
    let paths: Vec<String> = env::args().skip(1).collect();
    let paths = if paths.is_empty() {
        vec!["scratch.md".to_owned()]
    } else {
        paths
    };

collect() turns an iterator into a collection, and the type annotationVec<String> is how it knows which collection — the same call could build a HashSet or a String. This is one of the few places Rust genuinely needs you to say the type out loud.

The second let paths shadows the first. Shadowing isn't mutation — it's a new binding with the same name, and it's idiomatic for exactly this: take a value, transform it, keep calling it the thing it is.

printf 'fn a() {}\n' > editor/one.rs; printf 'fn b() {}\n' > editor/two.rs
cargo run -- one.rs two.rs
→ one.rs, highlighted. two.rs is open but has no way to be seen yet.

Tabs

Click a name, switch files.

One edit, at the very top of the panel — above thelet buffer = … line you added in stage 1:

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

            ui.horizontal(|ui| {
                for index in 0..self.buffers.len() {
                    let selected = index == self.active;
                    if ui
                        .selectable_label(selected, self.buffers[index].name())
                        .clicked()
                    {
                        self.active = index;
                    }
                }
            });
            let buffer = &mut self.buffers[self.active];

selectable_label(selected, text) draws a label that looks pressed whenselected is true — immediate mode again, so there's no tab widget holding state anywhere. You describe how it looks right now, and self.active is the only thing that remembers anything.

cargo run -- one.rs two.rs
→ two tabs; click to switch. Edit one, switch away, switch back — your edit is still there.

Why active: usize and not active: &mut Buffer

Storing an index looks primitive. Surely the editor should just hold a reference to the buffer it's editing? Try it:

struct Editor {
    buffers: Vec<Buffer>,
    active: &mut Buffer,
}

error[E0106]: missing lifetime specifier
 --> src/main.rs:5:13
  |
5 |     active: &mut Buffer,
  |             ^ expected named lifetime parameter

Take the compiler's advice, add the lifetime, and try to build one:

error[E0505]: cannot move out of `buffers` because it is borrowed
  |
9 |     let mut buffers = vec![Buffer { … }];
10 |     let active = &mut buffers[0];
  |                       ------- borrow of `buffers` occurs here
11 |     let editor = Editor { buffers, active };
  |                           ^^^^^^^  ------ borrow later used here
  |                           |
  |                           move out of `buffers` occurs here

The struct wants to own the vector and hold a reference into it at the same time. That's a self-referential struct, and safe Rust doesn't permit it: moving the Editor would move the vector, and the reference would be left pointing at where the data used to be.

rm editor/one.rs editor/two.rs
cargo fmt && cargo clippy
Both silent.