Setting up display-buffer-alist for sly

[g-gundam]

The Problem

Someone once lamented that sly was opening so many windows, and Emacs was placing them in awkward locations. To solve this, I tried to come up with some display-buffer-alist rules to place sly windows more predictably.

Keeping sly's new windows under control

• The source code gets the majority of the screen space.
• The REPL and debugger are allocated bottom-side windows in slots 0 and 1 respectively.
• Windows for documentation and the inspector are given right-side windows in slots 0 and 1 respectively.

When all the windows are active, it might look like this.

The Config

(use-package sly
  :ensure t
  :config
  (let ((patterns '(("\\*sly-mrepl"
                     (display-buffer-in-side-window)
                     (side . bottom)
                     (slot . 0)
                     (window-height . 22))
                    ("\\*sly-db"
                     (display-buffer-in-side-window)
                     (side . bottom)
                     (slot . 1))
                    ("\\*sly-inspector"
                     (display-buffer-in-side-window)
                     (side . right)
                     (slot . 1)
                     (window-width . 80))
                    ("\\*sly-description"
                     (display-buffer-in-side-window)
                     (side . right)
                     (slot . 0)
                     (window-width . 80)))))
    (cl-loop for p in patterns
             do (add-to-list 'display-buffer-alist p)))
  (setopt inferior-lisp-program "/usr/bin/sbcl")
  (setopt org-babel-lisp-eval-fn #'sly-eval))

The Teacher

Thanks to @protesilaos for explaining display-buffer-alist so well.

[g-gundam]

Debugging display-buffer-alist

When I'm debugging display-buffer-alist, I like to go into the scratch buffer and M-x insert-setq RET display-buffer-alist RET. This gives me a setq expression that I can eval frequently and repeatedly if necessary, speeding up the debug cycle. When I get the settings how I want them, I can copy them back to my config.

The insert-setq function

(defun insert-setq (variable)
  "Insert a setq expression for a VARIABLE into the current buffer.

This is useful when hacking on variables that usually get their values
via repeated calls to `add-to-list'.  (That's OK for configuration, but
annoying during development.)

Example:
  \\[insert-setq] RET display-buffer-alist RET "
  ;; [2025-05-08 Thu 22:47] The interactive expression was shamelessly copied from describe-variable.
  (interactive
   (let ((v (variable-at-point))
         (enable-recursive-minibuffers t)
         (orig-buffer (current-buffer))
         val)
     (setq val (completing-read
                (format-prompt "Insert variable" (and (symbolp v) v))
                #'help--symbol-completion-table
                (lambda (vv)
                  (or (get vv 'variable-documentation)
                      (and (not (keywordp vv))
                           ;; Since the variable may only exist in the
                           ;; original buffer, we have to look for it
                           ;; there.
                           (buffer-local-boundp vv orig-buffer))))
                t nil nil
                (if (symbolp v) (symbol-name v))))
     (list (if (equal val "")
               v (intern val)))))
  (let* ((data       (eval variable))
         (need-quote (if (eq (type-of data) 'cons) "'" ""))
         (point-a    (point)))
    (insert (format "(setq %s %s%s)"
                    (symbol-name variable)
                    need-quote
                    (pp-to-string data)))
    (let ((point-b (point)))
      (indent-region point-a point-b))))

[joaotavora]

This is great stuff @g-gundam