        (let ((docsets (+lookup-docsets-for-buffer)))
          (when (cl-some #'+lookup-docset-installed-p docsets)
            (+lookup/in-docsets identifier docsets)
-           t))))
+           'deferred))))
 
 
 ;;
 ;;; Main commands
 
 ;;;###autoload
-(defun +lookup/definition (identifier &optional other-window)
+(defun +lookup/definition (identifier)
   "Jump to the definition of IDENTIFIER (defaults to the symbol at point).
-
-If OTHER-WINDOW (universal argument), open the result in another window.
 
 Each function in `+lookup-definition-functions' is tried until one changes the
 point or current buffer. Falls back to dumb-jump, naive
 ripgrep/the_silver_searcher text search, then `evil-goto-definition' if
 evil-mode is active."
-  (interactive
-   (list (+lookup--symbol-or-region)
-         current-prefix-arg))
+  (interactive (list (+lookup--symbol-or-region)))
   (cond ((null identifier) (user-error "Nothing under point"))
-
-        ((+lookup--jump-to :definition identifier other-window))
-
-        ((error "Couldn't find the definition of '%s'" identifier))))
-
-;;;###autoload
-(defun +lookup/references (identifier &optional other-window)
+        ((+lookup--jump-to :definition identifier))
+        ((error "Couldn't find the definition of %S" identifier))))
+
+;;;###autoload
+(defun +lookup/references (identifier)
   "Show a list of usages of IDENTIFIER (defaults to the symbol at point)
 
 Tries each function in `+lookup-references-functions' until one changes the
 point and/or current buffer. Falls back to a naive ripgrep/the_silver_searcher
 search otherwise."
-  (interactive
-   (list (+lookup--symbol-or-region)
-         current-prefix-arg))
+  (interactive (list (+lookup--symbol-or-region)))
   (cond ((null identifier) (user-error "Nothing under point"))
-
-        ((+lookup--jump-to :references identifier other-window))
-
-        ((error "Couldn't find references of '%s'" identifier))))
-
-;;;###autoload
-(defun +lookup/documentation (identifier &optional _arg)
+        ((+lookup--jump-to :references identifier))
+        ((error "Couldn't find references of %S" identifier))))
+
+;;;###autoload
+(defun +lookup/documentation (identifier)
   "Show documentation for IDENTIFIER (defaults to symbol at point or selection.
 
 First attempts the :documentation handler specified with `set-lookup-handlers!'
 for the current mode/buffer (if any), then falls back to the backends in
 `+lookup-documentation-functions'."
-  (interactive
-   (list (+lookup--symbol-or-region)
-         current-prefix-arg))
-  (cond ((+lookup--jump-to :documentation identifier t))
-
-        ((user-error "Couldn't find documentation for '%s'" identifier))))
+  (interactive (list (+lookup--symbol-or-region)))
+  (cond ((+lookup--jump-to :documentation identifier 'pop-to-buffer))
+        ((user-error "Couldn't find documentation for %S" identifier))))
 
 (defvar ffap-file-finder)
 ;;;###autoload

If it doesn't change the current buffer, or it returns nil, the lookup module
will fall back to the next handler in `+lookup-definition-functions',
`+lookup-references-functions', `+lookup-file-functions' or
`+lookup-documentation-functions'."
  (declare (indent defun))
  (dolist (mode (doom-enlist modes))
    (let ((hook (intern (format "%s-hook" mode)))
          (fn   (intern (format "+lookup|init-%s" mode))))
      (cond ((null (car plist))
             (remove-hook hook fn)
             (delq! mode +lookup--handler-alist 'assq)
             (unintern fn nil))
            ((fset fn
                   (lambda ()

  (when spec
    (cl-destructuring-bind (fn . plist)
        (doom-enlist spec)
      (put fn '+lookup-async (or (plist-get plist :async) async))
      (add-hook functions-var fn nil t))))

(defun +lookup--symbol-or-region (&optional initial)
  "Grab the symbol at point or selected region."
  (cond ((stringp initial)
         initial)
        ((use-region-p)
         (buffer-substring-no-properties (region-beginning)
                                         (region-end)))
        ((require 'xref nil t)
         ;; A little smarter than using `symbol-at-point', though in most cases,
         ;; xref ends up using `symbol-at-point' anyway.
         (xref-backend-identifier-at-point (xref-find-backend)))))

(defun +lookup--run-handler (handler identifier)
