elisp/geiser-repl.el

   1 ;;; geiser-repl.el --- Geiser's REPL
   2
   3 ;; Copyright (C) 2009, 2010 Jose Antonio Ortega Ruiz
   4
   5 ;; This program is free software; you can redistribute it and/or
   6 ;; modify it under the terms of the Modified BSD License. You should
   7 ;; have received a copy of the license along with this program. If
   8 ;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>.
   9
  10 \f
  11
  12 (require 'geiser-company)
  13 (require 'geiser-autodoc)
  14 (require 'geiser-edit)
  15 (require 'geiser-completion)
  16 (require 'geiser-inf)
  17 (require 'geiser-impl)
  18 (require 'geiser-eval)
  19 (require 'geiser-connection)
  20 (require 'geiser-menu)
  21 (require 'geiser-custom)
  22 (require 'geiser-base)
  23
  24 (require 'comint)
  25 (require 'compile)
  26 (require 'scheme)
  27
  28 \f
  29 ;;; Customization:
  30
  31 (defgroup geiser-repl nil
  32   "Interacting with the Geiser REPL."
  33   :group 'geiser)
  34
  35 (geiser-custom--defcustom geiser-repl-use-other-window t
  36   "Whether to Use a window other than the current buffer's when
  37 switching to the Geiser REPL buffer."
  38   :type 'boolean
  39   :group 'geiser-repl)
  40
  41 (geiser-custom--defcustom geiser-repl-window-allow-split t
  42   "Whether to allow window splitting when switching to the Geiser
  43 REPL buffer."
  44   :type 'boolean
  45   :group 'geiser-repl)
  46
  47 (geiser-custom--defcustom geiser-repl-history-filename (expand-file-name "~/.geiser_history")
  48   "File where REPL input history is saved, so that it persists between sessions.
  49 This is actually the base name: the concrete Scheme
  50 implementation name gets appended to it."
  51   :type 'filename
  52   :group 'geiser-repl)
  53
  54 (geiser-custom--defcustom geiser-repl-history-size comint-input-ring-size
  55   "Maximum size of the saved REPL input history."
  56   :type 'integer
  57   :group 'geiser-repl)
  58
  59 (geiser-custom--defcustom geiser-repl-history-no-dups-p t
  60    "Whether to skip duplicates when recording history."
  61    :type 'boolean
  62    :group 'geiser-repl)
  63
  64 (geiser-custom--defcustom geiser-repl-autodoc-p t
  65   "Whether to enable `geiser-autodoc-mode' in the REPL by default."
  66   :type 'boolean
  67   :group 'geiser-repl)
  68
  69 (geiser-custom--defcustom geiser-repl-company-p t
  70   "Whether to use company-mode for completion, if available."
  71   :group 'geiser-mode
  72   :type 'boolean)
  73
  74 (geiser-custom--defcustom geiser-repl-read-only-prompt-p t
  75   "Whether the REPL's prompt should be read-only."
  76   :type 'boolean
  77   :group 'geiser-repl)
  78
  79 (geiser-custom--defcustom geiser-repl-auto-indent-p t
  80   "Whether newlines for incomplete sexps are autoindented."
  81   :type 'boolean
  82   :group 'geiser-repl)
  83
  84 (geiser-custom--defcustom geiser-repl-forget-old-errors-p t
  85   "Whether to forget old errors upon entering a new expression.
  86
  87 When on (the default), every time a new expression is entered in
  88 the REPL old error messages are flushed, and using \\[next-error]
  89 afterwards will jump only to error locations produced by the new
  90 expression, if any."
  91   :type 'boolean
  92   :group 'geiser-repl)
  93
  94 (geiser-custom--defcustom geiser-repl-query-on-exit-p nil
  95   "Whether to prompt for confirmation on \\[geiser-repl-exit]."
  96   :type 'boolean
  97   :group 'geiser-repl)
  98
  99 (geiser-custom--defcustom geiser-repl-default-host "localhost"
 100   "Default host when connecting to remote REPLs."
 101   :type 'string
 102   :group 'geiser-repl)
 103
 104 (geiser-custom--defcustom geiser-repl-default-port 37146
 105   "Default port for connecting to remote REPLs."
 106   :type 'integer
 107   :group 'geiser-repl)
 108
 109 \f
 110 ;;; Implementation-dependent parameters
 111
 112 (geiser-impl--define-caller
 113     geiser-repl--debugger-prompt-regexp debugger-prompt-regexp ()
 114   "A variable (or thunk returning a value) giving the regular
 115 expression for this implementation's debugging prompt.")
 116
 117 (geiser-impl--define-caller geiser-repl--startup startup ()
 118   "Function taking no parameters that is called after the REPL
 119 has been initialised. All Geiser functionality is available to
 120 you at that point.")
 121
 122 (geiser-impl--define-caller geiser-repl--enter-cmd enter-command (module)
 123   "Function taking a module designator and returning a REPL enter
 124 module command as a string")
 125
 126 (geiser-impl--define-caller geiser-repl--import-cmd import-command (module)
 127   "Function taking a module designator and returning a REPL import
 128 module command as a string")
 129
 130 (geiser-impl--define-caller geiser-repl--exit-cmd exit-command ()
 131   "Function returning the REPL exit command as a string")
 132
 133 \f
 134 ;;; Geiser REPL buffers and processes:
 135
 136 (defvar geiser-repl--repls nil)
 137 (defvar geiser-repl--closed-repls nil)
 138
 139 (make-variable-buffer-local
 140  (defvar geiser-repl--repl nil))
 141
 142 (defsubst geiser-repl--set-this-buffer-repl (r)
 143   (setq geiser-repl--repl r))
 144
 145 (defun geiser-repl--live-p ()
 146   (and geiser-repl--repl
 147        (get-buffer-process geiser-repl--repl)))
 148
 149 (defun geiser-repl--repl/impl (impl &optional repls)
 150   (catch 'repl
 151     (dolist (repl (or repls geiser-repl--repls))
 152       (when (buffer-live-p repl)
 153         (with-current-buffer repl
 154           (when (eq geiser-impl--implementation impl)
 155             (throw 'repl repl)))))))
 156
 157 (defun geiser-repl--set-up-repl (impl)
 158   (or (and (not impl) geiser-repl--repl)
 159       (setq geiser-repl--repl
 160             (let ((impl (or impl
 161                             geiser-impl--implementation
 162                             (geiser-impl--guess))))
 163               (when impl (geiser-repl--repl/impl impl))))))
 164
 165 (defun geiser-repl--active-impls ()
 166   (let ((act))
 167     (dolist (repl geiser-repl--repls act)
 168       (with-current-buffer repl
 169         (add-to-list 'act geiser-impl--implementation)))))
 170
 171 (defsubst geiser-repl--repl-name (impl)
 172   (format "%s REPL" (geiser-impl--impl-str impl)))
 173
 174 (defun geiser-repl--to-repl-buffer (impl)
 175   (unless (and (eq major-mode 'geiser-repl-mode)
 176                (not (get-buffer-process (current-buffer))))
 177     (let* ((old (geiser-repl--repl/impl impl geiser-repl--closed-repls))
 178            (old (and (buffer-live-p old)
 179                      (not (get-buffer-process old))
 180                      old)))
 181       (pop-to-buffer
 182        (or old
 183            (generate-new-buffer (format "* %s *"
 184                                         (geiser-repl--repl-name impl)))))
 185       (unless old
 186         (geiser-repl-mode)
 187         (geiser-impl--set-buffer-implementation impl)))))
 188
 189 (defun geiser-repl--read-impl (prompt &optional active)
 190   (geiser-impl--read-impl prompt (and active (geiser-repl--active-impls))))
 191
 192 (defsubst geiser-repl--only-impl-p ()
 193   (and (null (cdr geiser-active-implementations))
 194        (car geiser-active-implementations)))
 195
 196 (defun geiser-repl--get-impl (prompt)
 197   (or (geiser-repl--only-impl-p)
 198       (and (eq major-mode 'geiser-repl-mode) geiser-impl--implementation)
 199       (geiser-repl--read-impl prompt)))
 200
 201 \f
 202 ;;; REPL connections
 203
 204 (make-variable-buffer-local
 205  (defvar geiser-repl--address nil))
 206
 207 (make-variable-buffer-local
 208  (defvar geiser-repl--connection nil))
 209
 210 (make-variable-buffer-local
 211  (defvar geiser-repl--remote-p nil))
 212
 213 (make-variable-buffer-local
 214  (defvar geiser-repl--inferior-buffer nil))
 215
 216 (defsubst geiser-repl--host () (car geiser-repl--address))
 217 (defsubst geiser-repl--port () (cdr geiser-repl--address))
 218
 219 (defun geiser-repl--get-address (&optional host port)
 220   (let ((defhost (or (geiser-repl--host) geiser-repl-default-host))
 221         (defport (or (geiser-repl--port) geiser-repl-default-port)))
 222     (cons (or host
 223               (read-string (format "Host (default %s): " defhost)
 224                            nil nil defhost))
 225           (or port (read-number "Port: " defport)))))
 226
 227 (defun geiser-repl--save-remote-data (address remote)
 228   (setq geiser-repl--address address)
 229   (setq geiser-repl--remote-p remote)
 230   (setq header-line-format (and remote
 231                                 (format "Host: %s   Port: %s"
 232                                         (geiser-repl--host)
 233                                         (geiser-repl--port)))))
 234
 235 (defun geiser-repl--start-repl (impl host port remote)
 236   (message "Starting Geiser REPL for %s ..." impl)
 237   (geiser-repl--to-repl-buffer impl)
 238   (let ((address (geiser-repl--get-address host port))
 239         (prompt-rx (geiser-inf--prompt-regexp impl))
 240         (deb-prompt-rx (geiser-repl--debugger-prompt-regexp impl))
 241         (cname (geiser-repl--repl-name impl)))
 242     (unless prompt-rx
 243       (error "Sorry, I don't know how to start a REPL for %s" impl))
 244     (geiser-repl--save-remote-data address remote)
 245     (condition-case err
 246         (progn
 247           (setq geiser-repl--connection
 248                 (geiser-con--open-connection (car address)
 249                                              (cdr address)
 250                                              prompt-rx
 251                                              deb-prompt-rx))
 252           (set (make-local-variable 'comint-prompt-regexp)
 253                (geiser-con--connection-eot geiser-repl--connection))
 254           (apply 'make-comint-in-buffer `(,cname ,(current-buffer) ,address)))
 255       (error (insert "Unable to start REPL:\n\n"
 256                      (error-message-string err) "\n")
 257              (error "Couldn't start Geiser")))
 258     (geiser-inf--wait-for-prompt 10000)
 259     (geiser-repl--history-setup)
 260     (add-to-list 'geiser-repl--repls (current-buffer))
 261     (geiser-repl--set-this-buffer-repl (current-buffer))
 262     (geiser-repl--startup impl)
 263     (message "Geiser REPL up and running!")))
 264
 265 (defun geiser-repl--connection ()
 266   (let ((buffer (geiser-repl--set-up-repl geiser-impl--implementation)))
 267     (or (and (buffer-live-p buffer)
 268              (get-buffer-process buffer)
 269              (with-current-buffer buffer geiser-repl--connection))
 270         (error "No Geiser REPL for this buffer (try M-x run-geiser)"))))
 271
 272 (setq geiser-eval--default-connection-function 'geiser-repl--connection)
 273
 274 (defun geiser-repl--send (cmd)
 275   (when (and cmd (eq major-mode 'geiser-repl-mode))
 276     (goto-char (point-max))
 277     (comint-kill-input)
 278     (insert cmd)
 279     (let ((comint-input-filter (lambda (x) nil)))
 280       (comint-send-input nil t))))
 281
 282 \f
 283 ;;; REPL history and clean-up:
 284
 285 (defsubst geiser-repl--history-file ()
 286   (format "%s.%s" geiser-repl-history-filename geiser-impl--implementation))
 287
 288 (defun geiser-repl--quit-inf ()
 289   (when (buffer-live-p geiser-repl--inferior-buffer)
 290     (with-current-buffer geiser-repl--inferior-buffer
 291       (let ((geiser-repl-query-on-exit-p nil)) (geiser-repl-exit))
 292       (kill-buffer))))
 293
 294 (defun geiser-repl--on-quit ()
 295   (comint-write-input-ring)
 296   (let ((cb (current-buffer))
 297         (impl geiser-impl--implementation)
 298         (comint-prompt-read-only nil))
 299     (ignore-errors (geiser-con--connection-close geiser-repl--connection))
 300     (geiser-repl--quit-inf)
 301     (setq geiser-repl--repls (remove cb geiser-repl--repls))
 302     (dolist (buffer (buffer-list))
 303       (when (buffer-live-p buffer)
 304         (with-current-buffer buffer
 305           (when (and (eq geiser-impl--implementation impl)
 306                      (equal cb geiser-repl--repl))
 307             (geiser-repl--set-up-repl geiser-impl--implementation)))))))
 308
 309 (defun geiser-repl--sentinel (proc event)
 310   (let ((pb (process-buffer proc)))
 311     (when (buffer-live-p pb)
 312       (with-current-buffer pb
 313         (let ((comint-prompt-read-only nil)
 314               (comint-input-ring-file-name (geiser-repl--history-file)))
 315           (geiser-repl--on-quit)
 316           (push pb geiser-repl--closed-repls)
 317           (when (buffer-name (current-buffer))
 318             (comint-kill-region comint-last-input-start (point))
 319             (insert "\nIt's been nice interacting with you!\n")
 320             (insert "Press C-c C-z to bring me back.\n" )))))))
 321
 322 (defun geiser-repl--on-kill ()
 323   (geiser-repl--on-quit)
 324   (setq geiser-repl--closed-repls
 325         (remove (current-buffer) geiser-repl--closed-repls)))
 326
 327 (defun geiser-repl--input-filter (str)
 328   (not (or ;; (geiser-con--is-debugging)
 329            (string-match "^\\s *$" str)
 330            (string-match "^,quit *$" str))))
 331
 332 (defun geiser-repl--old-input ()
 333   (save-excursion
 334     (let ((end (point)))
 335       (backward-sexp)
 336       (buffer-substring (point) end))))
 337
 338 (defun geiser-repl--history-setup ()
 339   (set (make-local-variable 'comint-input-ring-file-name)
 340        (geiser-repl--history-file))
 341   (set (make-local-variable 'comint-input-ring-size) geiser-repl-history-size)
 342   (set (make-local-variable 'comint-input-filter) 'geiser-repl--input-filter)
 343   (set (make-local-variable 'comint-get-old-input) 'geiser-repl--old-input)
 344   (add-hook 'kill-buffer-hook 'geiser-repl--on-kill nil t)
 345   (comint-read-input-ring t)
 346   (set-process-sentinel (get-buffer-process (current-buffer))
 347                         'geiser-repl--sentinel))
 348
 349 \f
 350 ;;; geiser-repl mode:
 351
 352 (defun geiser-repl--bol ()
 353   (interactive)
 354   (when (= (point) (comint-bol)) (beginning-of-line)))
 355
 356 (defun geiser-repl--beginning-of-defun ()
 357   (save-restriction
 358     (when comint-last-prompt-overlay
 359       (narrow-to-region (overlay-end comint-last-prompt-overlay) (point)))
 360     (let ((beginning-of-defun-function nil))
 361       (beginning-of-defun))))
 362
 363 (defun geiser-repl--module-function (&optional ignore) :f)
 364
 365 (defun geiser-repl--doc-module ()
 366   (interactive)
 367   (let ((geiser-eval--get-module-function
 368          (geiser-impl--method 'find-module geiser-impl--implementation)))
 369     (geiser-doc-module)))
 370
 371 (defun geiser-repl--newline-and-indent ()
 372   (interactive)
 373   (save-restriction
 374     (narrow-to-region comint-last-input-start (point-max))
 375     (insert "\n")
 376     (lisp-indent-line)))
 377
 378 (defun geiser-repl--last-prompt-end ()
 379   (if comint-last-prompt-overlay
 380       (overlay-end comint-last-prompt-overlay)
 381     (save-excursion (geiser-repl--bol) (point))))
 382
 383 (defun geiser-repl--last-prompt-start ()
 384   (if comint-last-prompt-overlay
 385       (overlay-start comint-last-prompt-overlay)
 386     (save-excursion (geiser-repl--bol) (point))))
 387
 388 (defun geiser-repl--nesting-level ()
 389   (save-restriction
 390     (narrow-to-region (geiser-repl--last-prompt-end) (point-max))
 391     (geiser-syntax--nesting-level)))
 392
 393 (defun geiser-repl--send-input ()
 394   (let* ((proc (get-buffer-process (current-buffer)))
 395          (pmark (and proc (process-mark proc)))
 396          (intxt (and pmark (buffer-substring pmark (point)))))
 397     (when intxt
 398       (when (and geiser-repl-forget-old-errors-p
 399 ;;;                 (not (geiser-con--is-debugging)))
 400                  )
 401         (compilation-forget-errors))
 402       (comint-send-input)
 403       (when (string-match "^\\s-*$" intxt)
 404         (comint-send-string proc (geiser-eval--scheme-str '(:ge no-values)))
 405         (comint-send-string proc "\n")))))
 406
 407 (defun geiser-repl--maybe-send ()
 408   (interactive)
 409   (let ((p (point)))
 410     (cond ((< p (geiser-repl--last-prompt-start))
 411            (ignore-errors (compile-goto-error)))
 412           ((progn (end-of-line) (<= (geiser-repl--nesting-level) 0))
 413            (geiser-repl--send-input))
 414           (t (goto-char p)
 415              (if geiser-repl-auto-indent-p
 416                  (geiser-repl--newline-and-indent)
 417                (insert "\n"))))))
 418
 419 (defun geiser-repl--tab (n)
 420   "If we're after the last prompt, complete symbol or indent (if
 421 there's no symbol at point). Otherwise, go to next error in the REPL
 422 buffer."
 423   (interactive "p")
 424   (if (> (point) (geiser-repl--last-prompt-end))
 425       (geiser-completion--maybe-complete)
 426     (compilation-next-error n)))
 427
 428 (defun geiser-repl--previous-error (n)
 429   "Go to previous error in the REPL buffer."
 430   (interactive "p")
 431   (compilation-next-error (- n)))
 432
 433 (define-derived-mode geiser-repl-mode comint-mode "REPL"
 434   "Major mode for interacting with an inferior scheme repl process.
 435 \\{geiser-repl-mode-map}"
 436   (scheme-mode-variables)
 437   (set (make-local-variable 'mode-line-process) nil)
 438   (set (make-local-variable 'comint-use-prompt-regexp) nil)
 439   (set (make-local-variable 'comint-prompt-read-only)
 440        geiser-repl-read-only-prompt-p)
 441   (set (make-local-variable 'beginning-of-defun-function)
 442        'geiser-repl--beginning-of-defun)
 443   (set (make-local-variable 'comint-input-ignoredups)
 444        geiser-repl-history-no-dups-p)
 445   (setq geiser-eval--get-module-function 'geiser-repl--module-function)
 446   (when geiser-repl-autodoc-p
 447     (geiser--save-msg (geiser-autodoc-mode 1)))
 448   (geiser-company--setup geiser-repl-company-p)
 449   ;; enabling compilation-shell-minor-mode without the annoying highlighter
 450   (compilation-setup t))
 451
 452 (define-key geiser-repl-mode-map "\C-d" 'delete-char)
 453 (define-key geiser-repl-mode-map "\C-m" 'geiser-repl--maybe-send)
 454 (define-key geiser-repl-mode-map [return] 'geiser-repl--maybe-send)
 455 (define-key geiser-repl-mode-map "\C-j" 'geiser-repl--newline-and-indent)
 456 (define-key geiser-repl-mode-map (kbd "TAB") 'geiser-repl--tab)
 457 (define-key geiser-repl-mode-map [backtab] 'geiser-repl--previous-error)
 458
 459 (define-key geiser-repl-mode-map "\C-a" 'geiser-repl--bol)
 460 (define-key geiser-repl-mode-map (kbd "<home>") 'geiser-repl--bol)
 461
 462 (geiser-menu--defmenu repl geiser-repl-mode-map
 463   ("Complete symbol" ((kbd "M-TAB"))
 464    geiser-repl--tab :enable (symbol-at-point))
 465   ("Complete module name" ((kbd "C-.") (kbd "M-`"))
 466    geiser-completion--complete-module :enable (symbol-at-point))
 467   ("Edit symbol" "\M-." geiser-edit-symbol-at-point
 468    :enable (symbol-at-point))
 469   --
 470   ("Switch to module..." "\C-c\C-m" switch-to-geiser-module)
 471   ("Import module..." "\C-c\C-i" geiser-repl-import-module)
 472   --
 473   ("Previous matching input" "\M-p" comint-previous-matching-input-from-input
 474    "Previous input matching current")
 475   ("Next matching input" "\M-n" comint-next-matching-input-from-input
 476    "Next input matching current")
 477   ("Previous input" "\C-c\M-p" comint-previous-input)
 478   ("Next input" "\C-c\M-n" comint-next-input)
 479   --
 480   (mode "Autodoc mode" ("\C-c\C-da" "\C-c\C-d\C-a") geiser-autodoc-mode)
 481   ("Symbol documentation" ("\C-c\C-dd" "\C-c\C-d\C-d")
 482    geiser-doc-symbol-at-point
 483    "Documentation for symbol at point" :enable (symbol-at-point))
 484   ("Module documentation" ("\C-c\C-dm" "\C-c\C-d\C-m") geiser-repl--doc-module
 485    "Documentation for module at point" :enable (symbol-at-point))
 486   --
 487   ("Kill Scheme interpreter" "\C-c\C-q" geiser-repl-exit
 488    :enable (geiser-repl--live-p))
 489   ("Restart" "\C-c\C-z" switch-to-geiser :enable (not (geiser-repl--live-p)))
 490   --
 491   (custom "REPL options" geiser-repl))
 492
 493 (define-key geiser-repl-mode-map [menu-bar completion] 'undefined)
 494
 495 \f
 496 ;;; User commands
 497
 498 (defun run-geiser (impl)
 499   "Start a new Geiser REPL."
 500   (interactive
 501    (list (geiser-repl--get-impl "Start Geiser for scheme implementation: ")))
 502   (let ((b/p (geiser-inf--run-scheme impl)))
 503     (setq geiser-repl--inferior-buffer (car b/p))
 504     (geiser-repl--start-repl impl "localhost" (cdr b/p) nil)))
 505
 506 (defalias 'geiser 'run-geiser)
 507
 508 (defun geiser-connect (impl &optional host port)
 509   "Start a new Geiser REPL connected to a remote Scheme process."
 510   (interactive
 511    (list (geiser-repl--get-impl "Connect to Scheme implementation: ")))
 512   (geiser-repl--start-repl impl host port t))
 513
 514 (make-variable-buffer-local
 515  (defvar geiser-repl--last-scm-buffer nil))
 516
 517 (defun switch-to-geiser (&optional ask impl buffer)
 518   "Switch to running Geiser REPL.
 519 With prefix argument, ask for which one if more than one is running.
 520 If no REPL is running, execute `run-geiser' to start a fresh one."
 521   (interactive "P")
 522   (let* ((impl (or impl geiser-impl--implementation))
 523          (in-repl (eq major-mode 'geiser-repl-mode))
 524          (in-live-repl (and in-repl (get-buffer-process (current-buffer))))
 525          (repl (cond ((and (not ask)
 526                            (not impl)
 527                            (not in-repl)
 528                            (or geiser-repl--repl (car geiser-repl--repls))))
 529                      ((and (not ask)
 530                            (not in-repl)
 531                            impl
 532                            (geiser-repl--repl/impl impl)))))
 533          (pop-up-windows geiser-repl-window-allow-split))
 534     (cond ((or in-live-repl
 535                (and (eq (current-buffer) repl) (not (eq repl buffer))))
 536            (when (buffer-live-p geiser-repl--last-scm-buffer)
 537              (pop-to-buffer geiser-repl--last-scm-buffer)))
 538           (repl (pop-to-buffer repl))
 539           (geiser-repl--remote-p (geiser-connect impl))
 540           (t (run-geiser impl)))
 541     (when (and buffer (eq major-mode 'geiser-repl-mode))
 542       (setq geiser-repl--last-scm-buffer buffer))))
 543
 544 (defun switch-to-geiser-module (&optional module buffer)
 545   "Switch to running Geiser REPL and try to enter a given module."
 546   (interactive)
 547   (let* ((module (or module
 548                      (geiser-completion--read-module
 549                       "Switch to module (default top-level): ")))
 550          (cmd (and module
 551                    (geiser-repl--enter-cmd geiser-impl--implementation
 552                                            module))))
 553     (unless (eq major-mode 'geiser-repl-mode)
 554       (switch-to-geiser nil nil (or buffer (current-buffer))))
 555     (geiser-repl--send cmd)))
 556
 557 (defun geiser-repl-import-module (&optional module)
 558   "Import a given module in the current namespace of the REPL."
 559   (interactive)
 560   (let* ((module (or module
 561                      (geiser-completion--read-module "Import module: ")))
 562          (cmd (and module
 563                    (geiser-repl--import-cmd geiser-impl--implementation
 564                                             module))))
 565     (switch-to-geiser nil nil (current-buffer))
 566     (geiser-repl--send cmd)))
 567
 568 (defun geiser-repl-exit (&optional arg)
 569   "Exit the current REPL.
 570 With a prefix argument, force exit by killing the scheme process."
 571   (interactive "P")
 572   (when (or (not geiser-repl-query-on-exit-p)
 573             (y-or-n-p "Really quit this REPL? "))
 574     (let ((cmd (and (not arg)
 575                     (geiser-repl--exit-cmd geiser-impl--implementation))))
 576       (if cmd
 577           (when (stringp cmd) (geiser-repl--send cmd))
 578         (comint-kill-subjob)))))
 579
 580 \f
 581 ;;; Unload:
 582
 583 (defun geiser-repl--repl-list ()
 584   (let (lst)
 585     (dolist (repl geiser-repl--repls lst)
 586       (when (buffer-live-p repl)
 587         (with-current-buffer repl
 588           (push geiser-impl--implementation lst))))))
 589
 590 (defun geiser-repl--restore (impls)
 591   (dolist (impl impls)
 592     (when impl (run-geiser impl))))
 593
 594 (defun geiser-repl-unload-function ()
 595   (dolist (repl geiser-repl--repls)
 596     (when (buffer-live-p repl)
 597       (kill-buffer repl))))
 598
 599 \f
 600 (provide 'geiser-repl)
 601 ;;; geiser-repl.el ends here