Switch to most recent buffer in a given mode

Question

I am trying to create a function that switches to the most recent buffer in major mode major-mode. An answer to a related question supplies a function that should require the smallest of tweaks to serve my purpose, but I can't make it work. Here is the original function in that answer:

(defun switch-to-most-recent-org-buffer ()
  (interactive)
  (let (found)
    (catch 'done
      (mapc (lambda (x)
              (when (with-current-buffer x (eq major-mode 'org-mode))
                (switch-to-buffer x)
                (setq found t)
                (throw 'done nil)))
            (buffer-list))
      (unless found (message "not found")))))

I thought I could just replace the first and sixth lines, respectively, with

(defun switch-to-most-recent-buffer-in-mode (major-mode)

and

              (when (with-current-buffer x (eq major-mode major-mode))

Which gives me this:

(defun switch-to-most-recent-buffer-in-mode (major-mode)
  (interactive)
  (let (found)
    (catch 'done
      (mapc (lambda (x)
              (when (with-current-buffer x (eq major-mode major-mode))
                (switch-to-buffer x)
                (setq found t)
                (throw 'done nil)))
            (buffer-list))
      (unless found (message "not found")))))

but it doesn't work: while the original function switches to my most recent org buffer, evaluating (switch-to-most-recent-buffer-in-mode org-mode) returns a "not found" message. It seems I am failing to grasp something very basic about Elisp, so please excuse my ignorance: I'm not a programmer and am new to Emacs.

--

[edited to add:] The amended code below works (taken from phils's answer).

(defun switch-to-most-recent-buffer-in-mode (mode)
  (interactive "C")
  (let (found)
    (catch 'done
      (mapc (lambda (x)
              (when (with-current-buffer x (eq major-mode mode))
                (switch-to-buffer x)
                (setq found t)
                (throw 'done nil)))
            (buffer-list))
      (unless found (message "not found")))))

Answer 1

Regarding your changes:

(defun switch-to-most-recent-buffer-in-mode (major-mode)
  (interactive)

The first problem is that you used the name of a standard variable for your argument, which means that the real major-mode is shadowed by whatever you pass to your function. You should rename that to something else (mode would be safe).

The second problem is with the interactive form, which tells Emacs how to obtain the function arguments interactively (e.g. if called with M-x or by a key binding). By adding a required argument, but not changing the interactive spec, this command now won't work interactively.

You could make that (interactive "C") to read a command symbol (which will include all modes).

Your next change is:

(when (with-current-buffer x (eq major-mode major-mode))

That (eq major-mode major-mode) will hopefully look pretty dodgy to you upon review. It is guaranteed to be true.

You have run headlong into the first problem here -- you are trying to compare the standard variable major-mode with the argument you added of the exact same name, which obviously can't work.

Take note that even if the function wasn't directly using the standard variable, name clashes are often unsafe (whether and how depends on the specifics, though). It's best to stick to un-hyphenated single word names for function arguments, as the vast majority of global variables are hyphenated.

Finally, you're not calling your function correctly.

(switch-to-most-recent-buffer-in-mode org-mode)

You are trying to evaluate the variable org-mode and pass its value to the function.

The value of major-mode (the standard variable, with which you will later be comparing the argument you've passed) is a symbol, so you need to quote the argument to prevent it from being evaluated, so that you are passing the symbol org-mode:

(switch-to-most-recent-buffer-in-mode 'org-mode)

returns a "not found" message.

I would actually have expected either an error (because org-mode isn't normally a valid variable to evaluate in your call), or for it to unconditionally select the first buffer (because (eq major-mode major-mode) is always true), so I'm not sure whether you were testing what you've described; but hopefully these pointers are sufficient in any case.