Deryks _dev

A button that closes a tab

An × on every tab. It works once, then the editor dies.

The obvious implementation, written the obvious way. One edit — inside the tab loop, just after the label:

editor/src/main.rsin fn ui, the tab loop

                    if ui.selectable_label(selected, label).clicked() {
                        self.active = index;
                    }
                    if ui.small_button("×").clicked() {
                        self.buffers.remove(index);
                    }
                }

printf 'fn a() {}\n' > a.rs; printf 'fn b() {}\n' > b.rs; printf 'fn c() {}\n' > c.rs
cargo run -- a.rs b.rs c.rs
→ three tabs, each with an ×
→ click the × on the first tab

thread 'main' panicked at src/main.rs:297:34:
index out of bounds: the len is 2 but the index is 2

Why the compiler let you do that

Read the loop again with that error in mind:

for index in 0..self.buffers.len() {   // evaluated once: 0..3
    let buffer = &self.buffers[index];   // panics when index is 2 and len is 2
    // …
    self.buffers.remove(index);           // the Vec is now one shorter
}

0..self.buffers.len() is evaluated once, before the first iteration. It becomes the range 0..3 and stays that way. Remove an element on the first pass and the loop still faithfully visits indices 1 and 2, of a vector that now ends at 1.

Rust moved the failure from compile time to run time, and made it loud rather than silent: a bounds check, a panic, a line number. In C this would have read whatever memory happened to be there. That's the trade the index bought, and it's a good one — but it is a trade, not a free pass.

Decide in the loop, act after it

Closing a tab works, and the editor stays up.

You can't safely change the vector while walking it, so don't. Note what you want to happen, finish the walk, and do it afterwards — when nothing is iterating any more.Four edits.

First — somewhere to note it, just above the tab row:

editor/src/main.rsin fn ui, directly above the tab row

            let mut closing = None;

            ui.horizontal(|ui| {
                for index in 0..self.buffers.len() {

Second — the button records the request instead of acting on it:

editor/src/main.rsin fn ui, the tab loop

                    if ui.small_button("×").clicked() {
                        self.buffers.remove(index);
                        closing = Some(index);
                    }

Third — and it's carried out after the loop has finished:

editor/src/main.rsin fn ui, just after the tab row closes

            });

            if let Some(index) = closing {
                self.close(index);
            }

            let buffer = &mut self.buffers[self.active];

Fourth — and the method it calls. It goes in impl Editor, above fn open — note that impl Buffer has an fn opentoo, and putting close above the wrong one gives you a method that can't seeself.buffers or self.active at all:

editor/src/main.rsin impl Editor, above fn open

    /// Close a buffer, keeping `active` pointing at the file it was on.
    fn close(&mut self, index: usize) {
        if self.buffers.len() == 1 {
            return;
        }

        self.buffers.remove(index);

        if index < self.active {
            self.active -= 1;
        }
    }

Collect, then act

Option<usize> is doing real work here. It holds two facts at once —whether anything was clicked and which tab — in a way that makes it impossible to read one without the other. That's the sameOption from lesson 4, used for a different kind of absence.

The pattern generalises well beyond egui: when a loop discovers it wants to change the thing it's looping over, record the intent and apply it afterwards.You'll reach for it again in the file tree, where clicking a folder changes the tree you're in the middle of drawing.

The two guards in close are worth reading. Refusing to close the last buffer isn't politeness — self.buffers[self.active] runs on every frame, and an empty Vec makes that a panic. Until there's a way to create a new empty buffer, which is part 2, one file must always be open.

cargo run -- a.rs b.rs c.rs
→ close the first tab: the editor survives, two tabs remain
→ close tabs until one is left: the last × does nothing

Prove the arithmetic

Four tests. One of them is red.

close does index arithmetic, and index arithmetic is the kind of thing that's right for the case you thought about and wrong for the case you didn't. It's alsopure — no egui, no window, no frame — which sincelesson 10 you know means testable. Two edits — and the second only makes sense once you've run the first. Here's the first, at the bottom of mod tests:

editor/src/main.rsin mod tests, at the end

    fn editor_with(names: &[&str]) -> Editor {
        let paths: Vec<String> = names.iter().map(|n| (*n).to_owned()).collect();
        Editor::open(&paths)
    }

    #[test]
    fn closing_a_tab_before_the_active_one_keeps_the_same_file() {
        let mut editor = editor_with(&["a.rs", "b.rs", "c.rs"]);
        editor.active = 2;
        editor.close(0);
        assert_eq!(editor.buffers[editor.active].name(), "c.rs");
    }

    #[test]
    fn closing_the_active_tab_selects_the_one_that_took_its_place() {
        let mut editor = editor_with(&["a.rs", "b.rs", "c.rs"]);
        editor.active = 1;
        editor.close(1);
        assert_eq!(editor.buffers[editor.active].name(), "c.rs");
    }

    #[test]
    fn closing_the_active_last_tab_leaves_the_index_in_range() {
        let mut editor = editor_with(&["a.rs", "b.rs", "c.rs"]);
        editor.active = 2;
        editor.close(2);
        assert!(editor.active < editor.buffers.len());
        assert_eq!(editor.buffers[editor.active].name(), "b.rs");
    }

    #[test]
    fn the_only_tab_cannot_be_closed() {
        let mut editor = editor_with(&["a.rs"]);
        editor.close(0);
        assert_eq!(editor.buffers.len(), 1);
    }
}

Editor::open on files that don't exist gives you three perfectly good empty buffers — that's lesson 5's decision that a missing file is a new file, not an error, quietly making these tests possible without touching the disk.

cargo test

test tests::closing_a_tab_before_the_active_one_keeps_the_same_file ... ok
test tests::closing_the_active_tab_selects_the_one_that_took_its_place ... ok
test tests::the_only_tab_cannot_be_closed ... ok
test tests::closing_the_active_last_tab_leaves_the_index_in_range ... FAILED

---- tests::closing_the_active_last_tab_leaves_the_index_in_range stdout ----
assertion failed: editor.active < editor.buffers.len()

test result: FAILED. 13 passed; 1 failed

The case the arithmetic missed

close handles one case: a tab before the active one goes away, so everything after it shifts down by one and active shifts with it. That's the case you picture when you write it, and it's correct.

It says nothing about closing the tab at the end while you're on it. Nothing shifts — index < self.active is false when they're equal — soactive stays at 2, and the vector now ends at 1. The index didn't move; the vector moved out from under it.

The second edit — clamp the index to what's actually there:

editor/src/main.rsin Editor::close, at the end

        if index < self.active {
            self.active -= 1;
        }

        self.active = self.active.min(self.buffers.len() - 1);
    }

min is doing the work of an if without the branch:active becomes whichever is smaller, itself or the last valid index. In every case the first rule already handled, it changes nothing. In the case it didn't, it pulls the index back onto the end of the vector.

cargo test
→ test result: ok. 14 passed; 0 failed

cargo run -- a.rs b.rs c.rs
→ select the last tab, close it: you land on the one before it
→ close tabs in any order you like; the editor stays up

Close it from the keyboard

Ctrl+W closes the file you're looking at.

Nobody reaches for the mouse to close a tab. The work is already done — there's a method that closes a buffer by index, and self.active is an index.One edit, just above the block that applies closing:

editor/src/main.rsin fn ui, after the tab row

            });

            let close_requested = ui.input(|i| i.modifiers.command && i.key_pressed(egui::Key::W));
            if close_requested {
                closing = Some(self.active);
            }

            if let Some(index) = closing {
                self.close(index);
            }

That's the same shape as Ctrl+S from lesson 3, and it feeds the same closing variable the button does. Two ways to ask for the same thing, one place that carries it out — which is why the mouse path and the keyboard path can't drift apart.

modifiers.command rather than ctrl is deliberate, and it's been that way since lesson 3: egui maps it to Ctrl on Linux and Windows and to ⌘ on macOS, so the binding is right on all three without acfg.

cargo run -- a.rs b.rs c.rs
→ press Ctrl+W: the current tab closes and the next one takes over
→ keep pressing: the last one stays put