emacs.d

My Emacs configuration
git clone https://git.jamzattack.xyz/emacs.d
Log | Files | Refs | LICENSE

commit 66ee87825a59701e3578a56888baa5ce07820c15
parent 7af0ab55775c2e4df6485449487f41f7fea65b60
Author: Jamie Beardslee <beardsleejamie@gmail.com>
Date:   Wed, 26 Feb 2020 10:05:14 +1300

updated elpa packages '(0x0 desktop-environment geiser mpdel slime vterm)

Diffstat:
Delpa/0x0-20200220.1853/0x0-pkg.el | 2--
Delpa/0x0-20200220.1853/0x0.el | 300-------------------------------------------------------------------------------
Delpa/0x0-20200220.1853/0x0.elc | 0
Relpa/0x0-20200220.1853/0x0-autoloads.el -> elpa/0x0-20200222.948/0x0-autoloads.el | 0
Aelpa/0x0-20200222.948/0x0-pkg.el | 2++
Aelpa/0x0-20200222.948/0x0.el | 296+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/0x0-20200222.948/0x0.elc | 0
Delpa/desktop-environment-20200207.1412/desktop-environment-autoloads.el | 96-------------------------------------------------------------------------------
Delpa/desktop-environment-20200207.1412/desktop-environment-pkg.el | 2--
Delpa/desktop-environment-20200207.1412/desktop-environment.el | 463-------------------------------------------------------------------------------
Delpa/desktop-environment-20200207.1412/desktop-environment.elc | 0
Aelpa/desktop-environment-20200225.1042/desktop-environment-autoloads.el | 96+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/desktop-environment-20200225.1042/desktop-environment-pkg.el | 2++
Aelpa/desktop-environment-20200225.1042/desktop-environment.el | 463+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/desktop-environment-20200225.1042/desktop-environment.elc | 0
Delpa/geiser-20200214.110/geiser-completion.el | 198-------------------------------------------------------------------------------
Delpa/geiser-20200214.110/geiser-completion.elc | 0
Delpa/geiser-20200214.110/geiser-pkg.el | 4----
Delpa/geiser-20200214.110/geiser.info | 1914-------------------------------------------------------------------------------
Delpa/geiser-20200214.110/scheme/mit/geiser/emacs.bci | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/emacs.bin | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/emacs.com | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.crf | 115-------------------------------------------------------------------------------
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.fre | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.pkd | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.crf | 115-------------------------------------------------------------------------------
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.fre | 0
Delpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.pkd | 0
Delpa/geiser-20200214.110/web.info | 1838-------------------------------------------------------------------------------
Relpa/geiser-20200214.110/bin/geiser-racket.sh -> elpa/geiser-20200225.1423/bin/geiser-racket.sh | 0
Relpa/geiser-20200214.110/dir -> elpa/geiser-20200225.1423/dir | 0
Relpa/geiser-20200214.110/geiser-autodoc.el -> elpa/geiser-20200225.1423/geiser-autodoc.el | 0
Relpa/geiser-20200214.110/geiser-autodoc.elc -> elpa/geiser-20200225.1423/geiser-autodoc.elc | 0
Relpa/geiser-20200214.110/geiser-autoloads.el -> elpa/geiser-20200225.1423/geiser-autoloads.el | 0
Relpa/geiser-20200214.110/geiser-base.el -> elpa/geiser-20200225.1423/geiser-base.el | 0
Relpa/geiser-20200214.110/geiser-base.elc -> elpa/geiser-20200225.1423/geiser-base.elc | 0
Relpa/geiser-20200214.110/geiser-chez.el -> elpa/geiser-20200225.1423/geiser-chez.el | 0
Relpa/geiser-20200214.110/geiser-chez.elc -> elpa/geiser-20200225.1423/geiser-chez.elc | 0
Relpa/geiser-20200214.110/geiser-chibi.el -> elpa/geiser-20200225.1423/geiser-chibi.el | 0
Relpa/geiser-20200214.110/geiser-chibi.elc -> elpa/geiser-20200225.1423/geiser-chibi.elc | 0
Relpa/geiser-20200214.110/geiser-chicken.el -> elpa/geiser-20200225.1423/geiser-chicken.el | 0
Relpa/geiser-20200214.110/geiser-chicken.elc -> elpa/geiser-20200225.1423/geiser-chicken.elc | 0
Relpa/geiser-20200214.110/geiser-company.el -> elpa/geiser-20200225.1423/geiser-company.el | 0
Relpa/geiser-20200214.110/geiser-company.elc -> elpa/geiser-20200225.1423/geiser-company.elc | 0
Relpa/geiser-20200214.110/geiser-compile.el -> elpa/geiser-20200225.1423/geiser-compile.el | 0
Relpa/geiser-20200214.110/geiser-compile.elc -> elpa/geiser-20200225.1423/geiser-compile.elc | 0
Aelpa/geiser-20200225.1423/geiser-completion.el | 198+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/geiser-20200225.1423/geiser-completion.elc | 0
Relpa/geiser-20200214.110/geiser-connection.el -> elpa/geiser-20200225.1423/geiser-connection.el | 0
Relpa/geiser-20200214.110/geiser-connection.elc -> elpa/geiser-20200225.1423/geiser-connection.elc | 0
Relpa/geiser-20200214.110/geiser-custom.el -> elpa/geiser-20200225.1423/geiser-custom.el | 0
Relpa/geiser-20200214.110/geiser-custom.elc -> elpa/geiser-20200225.1423/geiser-custom.elc | 0
Relpa/geiser-20200214.110/geiser-debug.el -> elpa/geiser-20200225.1423/geiser-debug.el | 0
Relpa/geiser-20200214.110/geiser-debug.elc -> elpa/geiser-20200225.1423/geiser-debug.elc | 0
Relpa/geiser-20200214.110/geiser-doc.el -> elpa/geiser-20200225.1423/geiser-doc.el | 0
Relpa/geiser-20200214.110/geiser-doc.elc -> elpa/geiser-20200225.1423/geiser-doc.elc | 0
Relpa/geiser-20200214.110/geiser-edit.el -> elpa/geiser-20200225.1423/geiser-edit.el | 0
Relpa/geiser-20200214.110/geiser-edit.elc -> elpa/geiser-20200225.1423/geiser-edit.elc | 0
Relpa/geiser-20200214.110/geiser-eval.el -> elpa/geiser-20200225.1423/geiser-eval.el | 0
Relpa/geiser-20200214.110/geiser-eval.elc -> elpa/geiser-20200225.1423/geiser-eval.elc | 0
Relpa/geiser-20200214.110/geiser-gambit.el -> elpa/geiser-20200225.1423/geiser-gambit.el | 0
Relpa/geiser-20200214.110/geiser-gambit.elc -> elpa/geiser-20200225.1423/geiser-gambit.elc | 0
Relpa/geiser-20200214.110/geiser-guile.el -> elpa/geiser-20200225.1423/geiser-guile.el | 0
Relpa/geiser-20200214.110/geiser-guile.elc -> elpa/geiser-20200225.1423/geiser-guile.elc | 0
Relpa/geiser-20200214.110/geiser-image.el -> elpa/geiser-20200225.1423/geiser-image.el | 0
Relpa/geiser-20200214.110/geiser-image.elc -> elpa/geiser-20200225.1423/geiser-image.elc | 0
Relpa/geiser-20200214.110/geiser-impl.el -> elpa/geiser-20200225.1423/geiser-impl.el | 0
Relpa/geiser-20200214.110/geiser-impl.elc -> elpa/geiser-20200225.1423/geiser-impl.elc | 0
Relpa/geiser-20200214.110/geiser-log.el -> elpa/geiser-20200225.1423/geiser-log.el | 0
Relpa/geiser-20200214.110/geiser-log.elc -> elpa/geiser-20200225.1423/geiser-log.elc | 0
Relpa/geiser-20200214.110/geiser-menu.el -> elpa/geiser-20200225.1423/geiser-menu.el | 0
Relpa/geiser-20200214.110/geiser-menu.elc -> elpa/geiser-20200225.1423/geiser-menu.elc | 0
Relpa/geiser-20200214.110/geiser-mit.el -> elpa/geiser-20200225.1423/geiser-mit.el | 0
Relpa/geiser-20200214.110/geiser-mit.elc -> elpa/geiser-20200225.1423/geiser-mit.elc | 0
Relpa/geiser-20200214.110/geiser-mode.el -> elpa/geiser-20200225.1423/geiser-mode.el | 0
Relpa/geiser-20200214.110/geiser-mode.elc -> elpa/geiser-20200225.1423/geiser-mode.elc | 0
Aelpa/geiser-20200225.1423/geiser-pkg.el | 4++++
Relpa/geiser-20200214.110/geiser-popup.el -> elpa/geiser-20200225.1423/geiser-popup.el | 0
Relpa/geiser-20200214.110/geiser-popup.elc -> elpa/geiser-20200225.1423/geiser-popup.elc | 0
Relpa/geiser-20200214.110/geiser-racket.el -> elpa/geiser-20200225.1423/geiser-racket.el | 0
Relpa/geiser-20200214.110/geiser-racket.elc -> elpa/geiser-20200225.1423/geiser-racket.elc | 0
Relpa/geiser-20200214.110/geiser-reload.el -> elpa/geiser-20200225.1423/geiser-reload.el | 0
Relpa/geiser-20200214.110/geiser-reload.elc -> elpa/geiser-20200225.1423/geiser-reload.elc | 0
Relpa/geiser-20200214.110/geiser-repl.el -> elpa/geiser-20200225.1423/geiser-repl.el | 0
Relpa/geiser-20200214.110/geiser-repl.elc -> elpa/geiser-20200225.1423/geiser-repl.elc | 0
Relpa/geiser-20200214.110/geiser-syntax.el -> elpa/geiser-20200225.1423/geiser-syntax.el | 0
Relpa/geiser-20200214.110/geiser-syntax.elc -> elpa/geiser-20200225.1423/geiser-syntax.elc | 0
Relpa/geiser-20200214.110/geiser-table.el -> elpa/geiser-20200225.1423/geiser-table.el | 0
Relpa/geiser-20200214.110/geiser-table.elc -> elpa/geiser-20200225.1423/geiser-table.elc | 0
Relpa/geiser-20200214.110/geiser-version.el -> elpa/geiser-20200225.1423/geiser-version.el | 0
Relpa/geiser-20200214.110/geiser-version.elc -> elpa/geiser-20200225.1423/geiser-version.elc | 0
Relpa/geiser-20200214.110/geiser-xref.el -> elpa/geiser-20200225.1423/geiser-xref.el | 0
Relpa/geiser-20200214.110/geiser-xref.elc -> elpa/geiser-20200225.1423/geiser-xref.elc | 0
Relpa/geiser-20200214.110/geiser.el -> elpa/geiser-20200225.1423/geiser.el | 0
Relpa/geiser-20200214.110/geiser.elc -> elpa/geiser-20200225.1423/geiser.elc | 0
Aelpa/geiser-20200225.1423/geiser.info | 1925+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Relpa/geiser-20200214.110/macros.info -> elpa/geiser-20200225.1423/macros.info | 0
Relpa/geiser-20200214.110/scheme/chez/geiser/geiser.ss -> elpa/geiser-20200225.1423/scheme/chez/geiser/geiser.ss | 0
Relpa/geiser-20200214.110/scheme/chez/geiser/test.ss -> elpa/geiser-20200225.1423/scheme/chez/geiser/test.ss | 0
Relpa/geiser-20200214.110/scheme/chibi/geiser/geiser.scm -> elpa/geiser-20200225.1423/scheme/chibi/geiser/geiser.scm | 0
Relpa/geiser-20200214.110/scheme/chibi/geiser/geiser.sld -> elpa/geiser-20200225.1423/scheme/chibi/geiser/geiser.sld | 0
Relpa/geiser-20200214.110/scheme/chicken/geiser/chicken4.scm -> elpa/geiser-20200225.1423/scheme/chicken/geiser/chicken4.scm | 0
Relpa/geiser-20200214.110/scheme/chicken/geiser/chicken5.scm -> elpa/geiser-20200225.1423/scheme/chicken/geiser/chicken5.scm | 0
Relpa/geiser-20200214.110/scheme/gambit/geiser/gambit.scm -> elpa/geiser-20200225.1423/scheme/gambit/geiser/gambit.scm | 0
Relpa/geiser-20200214.110/scheme/gambit/geiser/gambit_procedures.scm -> elpa/geiser-20200225.1423/scheme/gambit/geiser/gambit_procedures.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/completion.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/completion.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/doc.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/doc.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/emacs.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/emacs.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/evaluation.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/evaluation.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/modules.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/modules.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/utils.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/utils.scm | 0
Relpa/geiser-20200214.110/scheme/guile/geiser/xref.scm -> elpa/geiser-20200225.1423/scheme/guile/geiser/xref.scm | 0
Relpa/geiser-20200214.110/scheme/mit/geiser/compile.scm -> elpa/geiser-20200225.1423/scheme/mit/geiser/compile.scm | 0
Relpa/geiser-20200214.110/scheme/mit/geiser/emacs.scm -> elpa/geiser-20200225.1423/scheme/mit/geiser/emacs.scm | 0
Relpa/geiser-20200214.110/scheme/mit/geiser/geiser.pkg -> elpa/geiser-20200225.1423/scheme/mit/geiser/geiser.pkg | 0
Relpa/geiser-20200214.110/scheme/mit/geiser/load.scm -> elpa/geiser-20200225.1423/scheme/mit/geiser/load.scm | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/autodoc.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/autodoc.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/completions.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/completions.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/enter.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/enter.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/eval.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/eval.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/images.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/images.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/locations.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/locations.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/main.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/main.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/modules.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/modules.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/server.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/server.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/startup.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/startup.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/user.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/user.rkt | 0
Relpa/geiser-20200214.110/scheme/racket/geiser/utils.rkt -> elpa/geiser-20200225.1423/scheme/racket/geiser/utils.rkt | 0
Relpa/geiser-20200214.110/top.info -> elpa/geiser-20200225.1423/top.info | 0
Aelpa/geiser-20200225.1423/web.info | 1847+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Delpa/moe-theme-20200216.1927/moe-dark-theme.el | 962-------------------------------------------------------------------------------
Delpa/moe-theme-20200216.1927/moe-light-theme.el | 967-------------------------------------------------------------------------------
Delpa/moe-theme-20200216.1927/moe-theme-autoloads.el | 52----------------------------------------------------
Delpa/moe-theme-20200216.1927/moe-theme-pkg.el | 4----
Delpa/moe-theme-20200216.1927/moe-theme-switcher.el | 145-------------------------------------------------------------------------------
Delpa/moe-theme-20200216.1927/moe-theme-switcher.elc | 0
Delpa/moe-theme-20200216.1927/moe-theme.el | 513-------------------------------------------------------------------------------
Delpa/moe-theme-20200216.1927/moe-theme.elc | 0
Delpa/mpdel-20200116.815/mpdel-autoloads.el | 120-------------------------------------------------------------------------------
Delpa/mpdel-20200116.815/mpdel-browser.elc | 0
Delpa/mpdel-20200116.815/mpdel-core.el | 190-------------------------------------------------------------------------------
Delpa/mpdel-20200116.815/mpdel-core.elc | 0
Delpa/mpdel-20200116.815/mpdel-pkg.el | 14--------------
Delpa/mpdel-20200116.815/mpdel-playlist.elc | 0
Delpa/mpdel-20200116.815/mpdel-song.elc | 0
Delpa/mpdel-20200116.815/mpdel-tablist.elc | 0
Delpa/mpdel-20200116.815/mpdel.elc | 0
Aelpa/mpdel-20200221.1316/mpdel-autoloads.el | 134+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Relpa/mpdel-20200116.815/mpdel-browser.el -> elpa/mpdel-20200221.1316/mpdel-browser.el | 0
Aelpa/mpdel-20200221.1316/mpdel-browser.elc | 0
Aelpa/mpdel-20200221.1316/mpdel-core.el | 228+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/mpdel-20200221.1316/mpdel-core.elc | 0
Aelpa/mpdel-20200221.1316/mpdel-pkg.el | 14++++++++++++++
Relpa/mpdel-20200116.815/mpdel-playlist.el -> elpa/mpdel-20200221.1316/mpdel-playlist.el | 0
Aelpa/mpdel-20200221.1316/mpdel-playlist.elc | 0
Relpa/mpdel-20200116.815/mpdel-song.el -> elpa/mpdel-20200221.1316/mpdel-song.el | 0
Aelpa/mpdel-20200221.1316/mpdel-song.elc | 0
Relpa/mpdel-20200116.815/mpdel-tablist.el -> elpa/mpdel-20200221.1316/mpdel-tablist.el | 0
Aelpa/mpdel-20200221.1316/mpdel-tablist.elc | 0
Relpa/mpdel-20200116.815/mpdel.el -> elpa/mpdel-20200221.1316/mpdel.el | 0
Aelpa/mpdel-20200221.1316/mpdel.elc | 0
Delpa/slime-20200219.2239/contrib/slime-asdf.elc | 0
Delpa/slime-20200219.2239/contrib/slime-clipboard.elc | 0
Delpa/slime-20200219.2239/contrib/slime-compiler-notes-tree.elc | 0
Delpa/slime-20200219.2239/contrib/slime-enclosing-context.elc | 0
Delpa/slime-20200219.2239/contrib/slime-fancy-trace.elc | 0
Delpa/slime-20200219.2239/contrib/slime-hyperdoc.elc | 0
Delpa/slime-20200219.2239/contrib/slime-macrostep.elc | 0
Delpa/slime-20200219.2239/contrib/slime-media.elc | 0
Delpa/slime-20200219.2239/contrib/slime-parse.elc | 0
Delpa/slime-20200219.2239/contrib/slime-presentations.elc | 0
Delpa/slime-20200219.2239/contrib/slime-references.el | 156-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-references.elc | 0
Delpa/slime-20200219.2239/contrib/slime-repl.el | 1805-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-repl.elc | 0
Delpa/slime-20200219.2239/contrib/slime-sbcl-exts.el | 34----------------------------------
Delpa/slime-20200219.2239/contrib/slime-sbcl-exts.elc | 0
Delpa/slime-20200219.2239/contrib/slime-scheme.el | 40----------------------------------------
Delpa/slime-20200219.2239/contrib/slime-scheme.elc | 0
Delpa/slime-20200219.2239/contrib/slime-scratch.el | 48------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-scratch.elc | 0
Delpa/slime-20200219.2239/contrib/slime-snapshot.el | 34----------------------------------
Delpa/slime-20200219.2239/contrib/slime-snapshot.elc | 0
Delpa/slime-20200219.2239/contrib/slime-sprof.el | 224-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-sprof.elc | 0
Delpa/slime-20200219.2239/contrib/slime-trace-dialog.el | 837-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-trace-dialog.elc | 0
Delpa/slime-20200219.2239/contrib/slime-tramp.el | 121-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-tramp.elc | 0
Delpa/slime-20200219.2239/contrib/slime-typeout-frame.el | 92-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-typeout-frame.elc | 0
Delpa/slime-20200219.2239/contrib/slime-xref-browser.el | 99-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/slime-xref-browser.elc | 0
Delpa/slime-20200219.2239/contrib/swank-arglists.lisp | 1618-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-asdf.lisp | 533-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-buffer-streams.lisp | 39---------------------------------------
Delpa/slime-20200219.2239/contrib/swank-c-p-c.lisp | 298-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-clipboard.lisp | 71-----------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-fancy-inspector.lisp | 1006-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-fuzzy.lisp | 706-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-goo.goo | 996-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-hyperdoc.lisp | 18------------------
Delpa/slime-20200219.2239/contrib/swank-ikarus.ss | 86-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-indentation.lisp | 140-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-jolt.k | 998-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-kawa.scm | 2504-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-larceny.scm | 176-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-listener-hooks.lisp | 91-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-macrostep.lisp | 227-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-media.lisp | 25-------------------------
Delpa/slime-20200219.2239/contrib/swank-mit-scheme.scm | 870-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-mlworks.sml | 348-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-mrepl.lisp | 162-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-package-fu.lisp | 65-----------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-presentation-streams.lisp | 334-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-presentations.lisp | 246-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-quicklisp.lisp | 17-----------------
Delpa/slime-20200219.2239/contrib/swank-r6rs.scm | 416-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-repl.lisp | 441-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-sbcl-exts.lisp | 67-------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-snapshot.lisp | 67-------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-sprof.lisp | 154-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-trace-dialog.lisp | 264-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank-util.lisp | 63---------------------------------------------------------------
Delpa/slime-20200219.2239/contrib/swank.rb | 385-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/dir | 18------------------
Delpa/slime-20200219.2239/lib/hyperspec.el | 2511-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/lib/hyperspec.elc | 0
Delpa/slime-20200219.2239/metering.lisp | 1213-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/nregex.lisp | 523-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/packages.lisp | 202-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/sbcl-pprint-patch.lisp | 333-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/slime-autoloads.el | 69---------------------------------------------------------------------
Delpa/slime-20200219.2239/slime-pkg.el | 9---------
Delpa/slime-20200219.2239/slime-tests.el | 1459-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/slime-tests.elc | 0
Delpa/slime-20200219.2239/slime.el | 7659-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/slime.elc | 0
Delpa/slime-20200219.2239/slime.info | 3740-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/start-swank.lisp | 20--------------------
Delpa/slime-20200219.2239/swank-loader.lisp | 376-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank.asd | 36------------------------------------
Delpa/slime-20200219.2239/swank.lisp | 3800-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/abcl.lisp | 1532-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/allegro.lisp | 1086-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/backend.lisp | 1583-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/ccl.lisp | 868-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/clasp.lisp | 804-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/clisp.lisp | 930-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/cmucl.lisp | 2470-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/corman.lisp | 583-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/ecl.lisp | 1098-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/gray.lisp | 207-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/lispworks.lisp | 1020-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/match.lisp | 242-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/mezzano.lisp | 700-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/mkcl.lisp | 933-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/rpc.lisp | 162-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/sbcl.lisp | 2035-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/scl.lisp | 1726-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/source-file-cache.lisp | 136-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/swank/source-path-parser.lisp | 242-------------------------------------------------------------------------------
Delpa/slime-20200219.2239/xref.lisp | 2906-------------------------------------------------------------------------------
Relpa/slime-20200219.2239/contrib/README.md -> elpa/slime-20200225.619/contrib/README.md | 0
Relpa/slime-20200219.2239/contrib/bridge.el -> elpa/slime-20200225.619/contrib/bridge.el | 0
Relpa/slime-20200219.2239/contrib/bridge.elc -> elpa/slime-20200225.619/contrib/bridge.elc | 0
Relpa/slime-20200219.2239/contrib/inferior-slime.el -> elpa/slime-20200225.619/contrib/inferior-slime.el | 0
Relpa/slime-20200219.2239/contrib/inferior-slime.elc -> elpa/slime-20200225.619/contrib/inferior-slime.elc | 0
Relpa/slime-20200219.2239/contrib/slime-asdf.el -> elpa/slime-20200225.619/contrib/slime-asdf.el | 0
Aelpa/slime-20200225.619/contrib/slime-asdf.elc | 0
Relpa/slime-20200219.2239/contrib/slime-autodoc.el -> elpa/slime-20200225.619/contrib/slime-autodoc.el | 0
Relpa/slime-20200219.2239/contrib/slime-autodoc.elc -> elpa/slime-20200225.619/contrib/slime-autodoc.elc | 0
Relpa/slime-20200219.2239/contrib/slime-banner.el -> elpa/slime-20200225.619/contrib/slime-banner.el | 0
Relpa/slime-20200219.2239/contrib/slime-banner.elc -> elpa/slime-20200225.619/contrib/slime-banner.elc | 0
Relpa/slime-20200219.2239/contrib/slime-buffer-streams.el -> elpa/slime-20200225.619/contrib/slime-buffer-streams.el | 0
Relpa/slime-20200219.2239/contrib/slime-buffer-streams.elc -> elpa/slime-20200225.619/contrib/slime-buffer-streams.elc | 0
Relpa/slime-20200219.2239/contrib/slime-c-p-c.el -> elpa/slime-20200225.619/contrib/slime-c-p-c.el | 0
Relpa/slime-20200219.2239/contrib/slime-c-p-c.elc -> elpa/slime-20200225.619/contrib/slime-c-p-c.elc | 0
Relpa/slime-20200219.2239/contrib/slime-cl-indent.el -> elpa/slime-20200225.619/contrib/slime-cl-indent.el | 0
Relpa/slime-20200219.2239/contrib/slime-cl-indent.elc -> elpa/slime-20200225.619/contrib/slime-cl-indent.elc | 0
Relpa/slime-20200219.2239/contrib/slime-clipboard.el -> elpa/slime-20200225.619/contrib/slime-clipboard.el | 0
Aelpa/slime-20200225.619/contrib/slime-clipboard.elc | 0
Relpa/slime-20200219.2239/contrib/slime-compiler-notes-tree.el -> elpa/slime-20200225.619/contrib/slime-compiler-notes-tree.el | 0
Aelpa/slime-20200225.619/contrib/slime-compiler-notes-tree.elc | 0
Relpa/slime-20200219.2239/contrib/slime-editing-commands.el -> elpa/slime-20200225.619/contrib/slime-editing-commands.el | 0
Relpa/slime-20200219.2239/contrib/slime-editing-commands.elc -> elpa/slime-20200225.619/contrib/slime-editing-commands.elc | 0
Relpa/slime-20200219.2239/contrib/slime-enclosing-context.el -> elpa/slime-20200225.619/contrib/slime-enclosing-context.el | 0
Aelpa/slime-20200225.619/contrib/slime-enclosing-context.elc | 0
Relpa/slime-20200219.2239/contrib/slime-fancy-inspector.el -> elpa/slime-20200225.619/contrib/slime-fancy-inspector.el | 0
Relpa/slime-20200219.2239/contrib/slime-fancy-inspector.elc -> elpa/slime-20200225.619/contrib/slime-fancy-inspector.elc | 0
Relpa/slime-20200219.2239/contrib/slime-fancy-trace.el -> elpa/slime-20200225.619/contrib/slime-fancy-trace.el | 0
Aelpa/slime-20200225.619/contrib/slime-fancy-trace.elc | 0
Relpa/slime-20200219.2239/contrib/slime-fancy.el -> elpa/slime-20200225.619/contrib/slime-fancy.el | 0
Relpa/slime-20200219.2239/contrib/slime-fancy.elc -> elpa/slime-20200225.619/contrib/slime-fancy.elc | 0
Relpa/slime-20200219.2239/contrib/slime-fontifying-fu.el -> elpa/slime-20200225.619/contrib/slime-fontifying-fu.el | 0
Relpa/slime-20200219.2239/contrib/slime-fontifying-fu.elc -> elpa/slime-20200225.619/contrib/slime-fontifying-fu.elc | 0
Relpa/slime-20200219.2239/contrib/slime-fuzzy.el -> elpa/slime-20200225.619/contrib/slime-fuzzy.el | 0
Relpa/slime-20200219.2239/contrib/slime-fuzzy.elc -> elpa/slime-20200225.619/contrib/slime-fuzzy.elc | 0
Relpa/slime-20200219.2239/contrib/slime-highlight-edits.el -> elpa/slime-20200225.619/contrib/slime-highlight-edits.el | 0
Relpa/slime-20200219.2239/contrib/slime-highlight-edits.elc -> elpa/slime-20200225.619/contrib/slime-highlight-edits.elc | 0
Relpa/slime-20200219.2239/contrib/slime-hyperdoc.el -> elpa/slime-20200225.619/contrib/slime-hyperdoc.el | 0
Aelpa/slime-20200225.619/contrib/slime-hyperdoc.elc | 0
Relpa/slime-20200219.2239/contrib/slime-indentation.el -> elpa/slime-20200225.619/contrib/slime-indentation.el | 0
Relpa/slime-20200219.2239/contrib/slime-indentation.elc -> elpa/slime-20200225.619/contrib/slime-indentation.elc | 0
Relpa/slime-20200219.2239/contrib/slime-listener-hooks.el -> elpa/slime-20200225.619/contrib/slime-listener-hooks.el | 0
Relpa/slime-20200219.2239/contrib/slime-listener-hooks.elc -> elpa/slime-20200225.619/contrib/slime-listener-hooks.elc | 0
Relpa/slime-20200219.2239/contrib/slime-macrostep.el -> elpa/slime-20200225.619/contrib/slime-macrostep.el | 0
Aelpa/slime-20200225.619/contrib/slime-macrostep.elc | 0
Relpa/slime-20200219.2239/contrib/slime-mdot-fu.el -> elpa/slime-20200225.619/contrib/slime-mdot-fu.el | 0
Relpa/slime-20200219.2239/contrib/slime-mdot-fu.elc -> elpa/slime-20200225.619/contrib/slime-mdot-fu.elc | 0
Relpa/slime-20200219.2239/contrib/slime-media.el -> elpa/slime-20200225.619/contrib/slime-media.el | 0
Aelpa/slime-20200225.619/contrib/slime-media.elc | 0
Relpa/slime-20200219.2239/contrib/slime-mrepl.el -> elpa/slime-20200225.619/contrib/slime-mrepl.el | 0
Relpa/slime-20200219.2239/contrib/slime-mrepl.elc -> elpa/slime-20200225.619/contrib/slime-mrepl.elc | 0
Relpa/slime-20200219.2239/contrib/slime-package-fu.el -> elpa/slime-20200225.619/contrib/slime-package-fu.el | 0
Relpa/slime-20200219.2239/contrib/slime-package-fu.elc -> elpa/slime-20200225.619/contrib/slime-package-fu.elc | 0
Relpa/slime-20200219.2239/contrib/slime-parse.el -> elpa/slime-20200225.619/contrib/slime-parse.el | 0
Aelpa/slime-20200225.619/contrib/slime-parse.elc | 0
Relpa/slime-20200219.2239/contrib/slime-presentation-streams.el -> elpa/slime-20200225.619/contrib/slime-presentation-streams.el | 0
Relpa/slime-20200219.2239/contrib/slime-presentation-streams.elc -> elpa/slime-20200225.619/contrib/slime-presentation-streams.elc | 0
Relpa/slime-20200219.2239/contrib/slime-presentations.el -> elpa/slime-20200225.619/contrib/slime-presentations.el | 0
Aelpa/slime-20200225.619/contrib/slime-presentations.elc | 0
Relpa/slime-20200219.2239/contrib/slime-quicklisp.el -> elpa/slime-20200225.619/contrib/slime-quicklisp.el | 0
Relpa/slime-20200219.2239/contrib/slime-quicklisp.elc -> elpa/slime-20200225.619/contrib/slime-quicklisp.elc | 0
Aelpa/slime-20200225.619/contrib/slime-references.el | 156+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-references.elc | 0
Aelpa/slime-20200225.619/contrib/slime-repl.el | 1805+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-repl.elc | 0
Aelpa/slime-20200225.619/contrib/slime-sbcl-exts.el | 34++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-sbcl-exts.elc | 0
Aelpa/slime-20200225.619/contrib/slime-scheme.el | 40++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-scheme.elc | 0
Aelpa/slime-20200225.619/contrib/slime-scratch.el | 48++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-scratch.elc | 0
Aelpa/slime-20200225.619/contrib/slime-snapshot.el | 34++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-snapshot.elc | 0
Aelpa/slime-20200225.619/contrib/slime-sprof.el | 224+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-sprof.elc | 0
Aelpa/slime-20200225.619/contrib/slime-trace-dialog.el | 837+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-trace-dialog.elc | 0
Aelpa/slime-20200225.619/contrib/slime-tramp.el | 121+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-tramp.elc | 0
Aelpa/slime-20200225.619/contrib/slime-typeout-frame.el | 92+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-typeout-frame.elc | 0
Aelpa/slime-20200225.619/contrib/slime-xref-browser.el | 99+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/slime-xref-browser.elc | 0
Aelpa/slime-20200225.619/contrib/swank-arglists.lisp | 1618+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-asdf.lisp | 533+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-buffer-streams.lisp | 39+++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-c-p-c.lisp | 298+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-clipboard.lisp | 71+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-fancy-inspector.lisp | 1006+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-fuzzy.lisp | 706+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-goo.goo | 996+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-hyperdoc.lisp | 18++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-ikarus.ss | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-indentation.lisp | 140+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-jolt.k | 998+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-kawa.scm | 2504+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-larceny.scm | 176+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-listener-hooks.lisp | 91+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-macrostep.lisp | 227+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-media.lisp | 25+++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-mit-scheme.scm | 870+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-mlworks.sml | 348+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-mrepl.lisp | 162+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-package-fu.lisp | 65+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-presentation-streams.lisp | 334+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-presentations.lisp | 246+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-quicklisp.lisp | 17+++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-r6rs.scm | 416+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-repl.lisp | 441+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-sbcl-exts.lisp | 67+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-snapshot.lisp | 67+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-sprof.lisp | 154+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-trace-dialog.lisp | 264+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank-util.lisp | 63+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/contrib/swank.rb | 385+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/dir | 18++++++++++++++++++
Aelpa/slime-20200225.619/lib/hyperspec.el | 2511+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/lib/hyperspec.elc | 0
Aelpa/slime-20200225.619/metering.lisp | 1213+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/nregex.lisp | 523+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/packages.lisp | 202+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/sbcl-pprint-patch.lisp | 333+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/slime-autoloads.el | 69+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/slime-pkg.el | 9+++++++++
Aelpa/slime-20200225.619/slime-tests.el | 1459+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/slime-tests.elc | 0
Aelpa/slime-20200225.619/slime.el | 7659+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/slime.elc | 0
Aelpa/slime-20200225.619/slime.info | 3740+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/start-swank.lisp | 20++++++++++++++++++++
Aelpa/slime-20200225.619/swank-loader.lisp | 376+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank.asd | 36++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank.lisp | 3800+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/abcl.lisp | 1532+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/allegro.lisp | 1086+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/backend.lisp | 1583+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/ccl.lisp | 868+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/clasp.lisp | 803+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/clisp.lisp | 930+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/cmucl.lisp | 2470+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/corman.lisp | 583+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/ecl.lisp | 1098+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/gray.lisp | 207+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/lispworks.lisp | 1020+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/match.lisp | 242+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/mezzano.lisp | 700+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/mkcl.lisp | 933+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/rpc.lisp | 162+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/sbcl.lisp | 2035+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/scl.lisp | 1726+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/source-file-cache.lisp | 136+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/swank/source-path-parser.lisp | 242+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aelpa/slime-20200225.619/xref.lisp | 2906+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
416 files changed, 65360 insertions(+), 68166 deletions(-)

diff --git a/elpa/0x0-20200220.1853/0x0-pkg.el b/elpa/0x0-20200220.1853/0x0-pkg.el @@ -1,2 +0,0 @@ -;;; Generated package description from /home/jdb/.config/emacs/elpa/0x0-20200220.1853/0x0.el -*- no-byte-compile: t -*- -(define-package "0x0" "20200220.1853" "Upload to 0x0.st" '((emacs "24.1")) :commit "ae55ae0397ff3cf28a3ea52111bfc053dffb126d" :keywords '("comm") :authors '(("Philip K." . "philip@warpmail.net")) :maintainer '("Philip K." . "philip@warpmail.net") :url "https://git.sr.ht/~zge/nullpointer-emacs") diff --git a/elpa/0x0-20200220.1853/0x0.el b/elpa/0x0-20200220.1853/0x0.el @@ -1,300 +0,0 @@ -;;; 0x0.el --- Upload to 0x0.st -*- lexical-binding: t -*- - -;; Author: Philip K. <philip@warpmail.net> -;; Version: 0.2.0 -;; Package-Version: 20200220.1853 -;; Keywords: comm -;; Package-Requires: ((emacs "24.1")) -;; URL: https://git.sr.ht/~zge/nullpointer-emacs - -;; This file is NOT part of Emacs. -;; -;; This file is in the public domain, to the extent possible under law, -;; published under the CC0 1.0 Universal license. -;; -;; For a full copy of the CC0 license see -;; https://creativecommons.org/publicdomain/zero/1.0/legalcode - -;;; Commentary: -;; -;; This package defines three main functions: `0x0-upload', -;; `0x0-upload-file' and `0x0-upload-string', which respectively upload -;; (parts of) the current buffer, a file on your disk and a string from -;; the minibuffer to a 0x0.st-like or pomf-lie servers. - -(require 'url) -(require 'json) -(require 'ert) - -;;; Code: - -(defgroup 0x0 nil - "Upload data to 0x0.st-compatible servers." - :group 'convenience - :prefix "0x0-") - -(defcustom 0x0-services - `((0x0 - :host "0x0.st" - :query "file" - :min-age 30 - :max-age 365 - :max-size ,(* 1024 1024 512)) - (ttm - :host "ttm.sh" - :query "file" - :min-age 30 - :max-age 365 - :max-size ,(* 1024 1024 256)) - (ix - :host "ix.io" - :query "f:1" - :no-tls t) - (w1r3 - :host "w1r3.net" - :query "upload") - (sprunge - :host "sprunge.us" - :query "sprunge" - :no-tls t) - (sprunge - :host "sprunge.us" - :query "sprunge" - :no-tls t) - (you-die-if-you-work - :host "youdieifyou.work" - :path "upload.php" - :query "files[]" - :pomf t - :no-tls t) - (fiery - :host "safe.fiery.me" - :path "api/upload" - :query "files[]" - :pomf t) - (dmca-gripe - :host "dmca.gripe" - :path "api/upload" - :query "files[]" - :pomf t) - (uguu - :host "uguu.se" - :path "api.php?d=upload-tool" - :query "file" - :min-age 1 - :max-age 1 - :max-size ,(* 1024 1024 100))) - "Alist of different 0x0-like services. - -The car is a symbol identifying the service, the cdr a plist, -with the following keys: - - :host - domain name of the server (string, necessary) - :path - server path to send POST request to (string, - optional) - :no-tls - is tls not supported (bool, nil by default) - :query - query string used for file upload (string, - necessary) - :min-age - on 0x0-like servers, minimal number of days - a file is kept online (number, optional) - :max-age - on 0x0-like servers, maximal number of days - a file is kept online (number, optional) - :max-size - file limit for this server (number, optional) - :pomf - is pomf clone (bool, optional) - -This variable only describes servers, but doesn't set anything. -See `0x0-default-host' if you want to change the server you use." - :type '(alist :key-type symbol - :value-type (plist :value-type sexp))) - -(defcustom 0x0-default-service '0x0 - "Symbol describing server to use. - -The symbol must be a key from the alist `0x0-services'." - :type `(choice ,@(mapcar #'car 0x0-services))) - -(defcustom 0x0-use-curl-if-installed t - "Automatically check if curl is installed." - :type 'boolean) - -(defvar 0x0--filename) -(defvar 0x0--use-file nil) -(defvar 0x0--server) -(defvar 0x0--current-host) - -(defun 0x0--calculate-timeout (size) - "Calculate days a file of size SIZE would last." - (condition-case nil - (let ((min-age (float (plist-get 0x0--server :min-age))) - (max-age (float (plist-get 0x0--server :max-age))) - (max-size (float (plist-get 0x0--server :max-size)))) - (+ min-age (* (- min-age max-age) - (expt (- (/ size max-size) 1.0) 3)))) - (wrong-type-argument nil))) - -(defun 0x0--use-curl (start end) - "Backend function for uploading using curl. - -Operate on region between START and END." - (let ((buf (generate-new-buffer (format " *%s response*" 0x0--current-host)))) - (call-process-region start end "curl" - nil buf nil - "-s" "-S" "-F" - (format (if 0x0--use-file - "%s=@%s" - "%s=@-;filename=%s") - (plist-get 0x0--server :query) - 0x0--filename) - (format "%s://%s/%s" - (if (plist-get 0x0--server :no-tls) - "http" "https") - (plist-get 0x0--server :host) - (or (plist-get 0x0--server :path) ""))) - buf)) - -(defun 0x0--use-url (start end) - "Backend function for uploading using `url' functions. - -Operate on region between START and END." - (let* ((boundary (format "%X-%X-%X" (random) (random) (random))) - (url-request-extra-headers - `(("Content-Type" . ,(concat "multipart/form-data; boundary=" boundary)))) - (url-request-data - (let ((source (current-buffer)) - (filename (if (boundp '0x0--filename) - 0x0--filename - (buffer-name)))) - (with-temp-buffer - (insert "--" boundary "\r\n") - (insert "Content-Disposition: form-data; ") - (insert "name=\"" (plist-get 0x0--server :query) - "\"; filename=\"" filename "\"\r\n") - (insert "Content-type: text/plain\r\n\r\n") - (insert-buffer-substring-no-properties source start end) - (insert "\r\n--" boundary "--") - (buffer-string)))) - (url-request-method "POST")) - (with-current-buffer - (url-retrieve-synchronously - (concat (if (plist-get 0x0--server :no-tls) - "http" "https") - "://" (plist-get 0x0--server :host) - "/" (or (plist-get 0x0--server :path) ""))) - (rename-buffer (format " *%s response*" 0x0--current-host) t) - (goto-char (point-min)) - (save-match-data - (when (search-forward-regexp "^[[:space:]]*$" nil t) - (delete-region (point-min) (match-end 0)))) - (current-buffer)))) - -(defun 0x0--choose-service () - (if current-prefix-arg - (intern (completing-read "Service: " - (mapcar #'car 0x0-services) - nil t nil nil - 0x0-default-service)) - 0x0-default-service)) - -(defun 0x0--parse-plain () - (save-match-data - (unless (search-forward-regexp "^https?://.*$" nil t) - (error "Failed to upload/parse. See %s for more details" - (buffer-name))) - (match-string 0))) - -(defun 0x0--parse-pomf () - (let ((data (json-read))) - (unless data - (error "Empty response. See %s for more details" - (buffer-name))) - (unless (eq t (cdr (assq 'success data))) - (error "Failed to upload (%d): \"%s\"" - (cdr (assq 'errorcode data)) - (cdr (assq 'description data)))) - (cdr (assq 'url (aref (cdr (assq 'files data)) 0))))) - -;;;###autoload -(defun 0x0-upload (start end service) - "Upload current buffer to `0x0-url' from START to END. - -If START and END are not specified, upload entire buffer." - (interactive (list (if (use-region-p) (region-beginning) (point-min)) - (if (use-region-p) (region-end) (point-max)) - (0x0--choose-service))) - (let ((0x0--current-host service) - (0x0--server (cdr (assq service 0x0-services))) - (0x0--filename (if (bound-and-true-p 0x0--filename) - 0x0--filename (buffer-name)))) - (unless 0x0--server - (error "Service %s unknown." service)) - (unless (plist-get 0x0--server :host) - (error "Service %s has no :host field" service)) - (unless (plist-get 0x0--server :query) - (error "Service %s has no :query field" service)) - (let ((resp (if (and 0x0-use-curl-if-installed - (executable-find "curl")) - (0x0--use-curl start end) - (0x0--use-url start end))) - (timeout (0x0--calculate-timeout (- end start)))) - (with-current-buffer resp - (goto-char (point-min)) - (let ((result (cond ((plist-get 0x0--server :pomf) - (0x0--parse-pomf)) - (t (0x0--parse-plain))))) - (kill-new result) - (message (concat (format "Yanked `%s' into kill ring." result) - (and timeout (format " Should last ~%g days." timeout)))) - (kill-buffer resp) - result))))) - -;;;###autoload -(defun 0x0-upload-file (file service) - "Upload FILE to `0x0-url'." - (interactive (list (read-file-name "Upload file: ") - (0x0--choose-service))) - (with-temp-buffer - (unless 0x0-use-curl-if-installed - (insert-file-contents file)) - (let ((0x0--filename file) - (0x0--use-file t)) - (0x0-upload (point-min) (point-max) service)))) - -;;;###autoload -(defun 0x0-upload-string (string service) - "Upload STRING to `0x0-url'." - (interactive (list (read-string "Upload string: ") - (0x0--choose-service))) - (with-temp-buffer - (insert string) - (let ((0x0--filename "upload.txt")) - (0x0-upload (point-min) (point-max) service)))) - -(defun 0x0--test-service (service) - (let ((rand (make-string 256 0))) - (dotimes (i (length rand)) - (setf (aref rand i) (+ ?a (random (- ?z ?a))))) - (let* ((resp (0x0-upload-string rand service)) - result) - (with-current-buffer (url-retrieve-synchronously resp) - (goto-char (point-min)) - (forward-paragraph) - (delete-region (point-min) (1+ (point))) - (setq result (buffer-string))) - (should (or (equal rand result) - (save-match-data - (and (string-match "[[:space:]]*\\'" result) - (replace-match "" nil nil result)))))))) - -(dolist (service (mapcar #'car 0x0-services)) - (let ((name (intern (format "0x0-test-%s" (symbol-name service)))) - (name* (intern (format "0x0-test-%s-curl" (symbol-name service))))) - (eval `(ert-deftest ,name () - (let ((0x0-use-curl-if-installed nil)) - (0x0--test-service ',service)))) - (eval `(ert-deftest ,name* () - (let ((0x0-use-curl-if-installed t)) - (0x0--test-service ',service)))))) - -(provide '0x0) - -;;; 0x0.el ends here diff --git a/elpa/0x0-20200220.1853/0x0.elc b/elpa/0x0-20200220.1853/0x0.elc Binary files differ. diff --git a/elpa/0x0-20200220.1853/0x0-autoloads.el b/elpa/0x0-20200222.948/0x0-autoloads.el diff --git a/elpa/0x0-20200222.948/0x0-pkg.el b/elpa/0x0-20200222.948/0x0-pkg.el @@ -0,0 +1,2 @@ +;;; Generated package description from /home/jdb/.config/emacs/elpa/0x0-20200222.948/0x0.el -*- no-byte-compile: t -*- +(define-package "0x0" "20200222.948" "Upload to 0x0.st" '((emacs "24.1")) :commit "265b7d65e1bc54d84435e9d79379bc808e9a488b" :keywords '("comm") :authors '(("Philip K." . "philip@warpmail.net")) :maintainer '("Philip K." . "philip@warpmail.net") :url "https://git.sr.ht/~zge/nullpointer-emacs") diff --git a/elpa/0x0-20200222.948/0x0.el b/elpa/0x0-20200222.948/0x0.el @@ -0,0 +1,296 @@ +;;; 0x0.el --- Upload to 0x0.st -*- lexical-binding: t -*- + +;; Author: Philip K. <philip@warpmail.net> +;; Version: 0.2.0 +;; Package-Version: 20200222.948 +;; Keywords: comm +;; Package-Requires: ((emacs "24.1")) +;; URL: https://git.sr.ht/~zge/nullpointer-emacs + +;; This file is NOT part of Emacs. +;; +;; This file is in the public domain, to the extent possible under law, +;; published under the CC0 1.0 Universal license. +;; +;; For a full copy of the CC0 license see +;; https://creativecommons.org/publicdomain/zero/1.0/legalcode + +;;; Commentary: +;; +;; This package defines three main functions: `0x0-upload', +;; `0x0-upload-file' and `0x0-upload-string', which respectively upload +;; (parts of) the current buffer, a file on your disk and a string from +;; the minibuffer to a 0x0.st-like or pomf-lie servers. + +(require 'url) +(require 'json) +(require 'ert) + +;;; Code: + +(defgroup 0x0 nil + "Upload data to 0x0.st-compatible servers." + :group 'convenience + :prefix "0x0-") + +(defcustom 0x0-services + `((0x0 + :host "0x0.st" + :query "file" + :min-age 30 + :max-age 365 + :max-size ,(* 1024 1024 512)) + (ttm + :host "ttm.sh" + :query "file" + :min-age 30 + :max-age 365 + :max-size ,(* 1024 1024 256)) + (ix + :host "ix.io" + :query "f:1" + :no-tls t) + (w1r3 + :host "w1r3.net" + :query "upload") + (sprunge + :host "sprunge.us" + :query "sprunge" + :no-tls t) + (you-die-if-you-work + :host "youdieifyou.work" + :path "upload.php" + :query "files[]" + :pomf t + :no-tls t) + (fiery + :host "safe.fiery.me" + :path "api/upload" + :query "files[]" + :pomf t) + (dmca-gripe + :host "dmca.gripe" + :path "api/upload" + :query "files[]" + :pomf t) + (uguu + :host "uguu.se" + :path "api.php?d=upload-tool" + :query "file" + :min-age 1 + :max-age 1 + :max-size ,(* 1024 1024 100))) + "Alist of different 0x0-like services. + +The car is a symbol identifying the service, the cdr a plist, +with the following keys: + + :host - domain name of the server (string, necessary) + :path - server path to send POST request to (string, + optional) + :no-tls - is tls not supported (bool, nil by default) + :query - query string used for file upload (string, + necessary) + :min-age - on 0x0-like servers, minimal number of days + a file is kept online (number, optional) + :max-age - on 0x0-like servers, maximal number of days + a file is kept online (number, optional) + :max-size - file limit for this server (number, optional) + :pomf - is pomf clone (bool, optional) + +This variable only describes servers, but doesn't set anything. +See `0x0-default-host' if you want to change the server you use." + :type '(alist :key-type symbol + :value-type (plist :value-type sexp))) + +(defcustom 0x0-default-service '0x0 + "Symbol describing server to use. + +The symbol must be a key from the alist `0x0-services'." + :type `(choice ,@(mapcar #'car 0x0-services))) + +(defcustom 0x0-use-curl-if-installed t + "Automatically check if curl is installed." + :type 'boolean) + +(defvar 0x0--filename) +(defvar 0x0--use-file nil) +(defvar 0x0--server) +(defvar 0x0--current-host) + +(defun 0x0--calculate-timeout (size) + "Calculate days a file of size SIZE would last." + (condition-case nil + (let ((min-age (float (plist-get 0x0--server :min-age))) + (max-age (float (plist-get 0x0--server :max-age))) + (max-size (float (plist-get 0x0--server :max-size)))) + (+ min-age (* (- min-age max-age) + (expt (- (/ size max-size) 1.0) 3)))) + (wrong-type-argument nil))) + +(defun 0x0--use-curl (start end) + "Backend function for uploading using curl. + +Operate on region between START and END." + (let ((buf (generate-new-buffer (format " *%s response*" 0x0--current-host)))) + (call-process-region start end "curl" + nil buf nil + "-s" "-S" "-F" + (format (if 0x0--use-file + "%s=@%s" + "%s=@-;filename=%s") + (plist-get 0x0--server :query) + 0x0--filename) + (format "%s://%s/%s" + (if (plist-get 0x0--server :no-tls) + "http" "https") + (plist-get 0x0--server :host) + (or (plist-get 0x0--server :path) ""))) + buf)) + +(defun 0x0--use-url (start end) + "Backend function for uploading using `url' functions. + +Operate on region between START and END." + (let* ((boundary (format "%X-%X-%X" (random) (random) (random))) + (url-request-extra-headers + `(("Content-Type" . ,(concat "multipart/form-data; boundary=" boundary)))) + (url-request-data + (let ((source (current-buffer)) + (filename (if (boundp '0x0--filename) + 0x0--filename + (buffer-name)))) + (with-temp-buffer + (insert "--" boundary "\r\n") + (insert "Content-Disposition: form-data; ") + (insert "name=\"" (plist-get 0x0--server :query) + "\"; filename=\"" filename "\"\r\n") + (insert "Content-type: text/plain\r\n\r\n") + (insert-buffer-substring-no-properties source start end) + (insert "\r\n--" boundary "--") + (buffer-string)))) + (url-request-method "POST")) + (with-current-buffer + (url-retrieve-synchronously + (concat (if (plist-get 0x0--server :no-tls) + "http" "https") + "://" (plist-get 0x0--server :host) + "/" (or (plist-get 0x0--server :path) ""))) + (rename-buffer (format " *%s response*" 0x0--current-host) t) + (goto-char (point-min)) + (save-match-data + (when (search-forward-regexp "^[[:space:]]*$" nil t) + (delete-region (point-min) (match-end 0)))) + (current-buffer)))) + +(defun 0x0--choose-service () + (if current-prefix-arg + (intern (completing-read "Service: " + (mapcar #'car 0x0-services) + nil t nil nil + 0x0-default-service)) + 0x0-default-service)) + +(defun 0x0--parse-plain () + (save-match-data + (unless (search-forward-regexp "^https?://.*$" nil t) + (error "Failed to upload/parse. See %s for more details" + (buffer-name))) + (match-string 0))) + +(defun 0x0--parse-pomf () + (let ((data (json-read))) + (unless data + (error "Empty response. See %s for more details" + (buffer-name))) + (unless (eq t (cdr (assq 'success data))) + (error "Failed to upload (%d): \"%s\"" + (cdr (assq 'errorcode data)) + (cdr (assq 'description data)))) + (cdr (assq 'url (aref (cdr (assq 'files data)) 0))))) + +;;;###autoload +(defun 0x0-upload (start end service) + "Upload current buffer to `0x0-url' from START to END. + +If START and END are not specified, upload entire buffer." + (interactive (list (if (use-region-p) (region-beginning) (point-min)) + (if (use-region-p) (region-end) (point-max)) + (0x0--choose-service))) + (let ((0x0--current-host service) + (0x0--server (cdr (assq service 0x0-services))) + (0x0--filename (if (bound-and-true-p 0x0--filename) + 0x0--filename (buffer-name)))) + (unless 0x0--server + (error "Service %s unknown." service)) + (unless (plist-get 0x0--server :host) + (error "Service %s has no :host field" service)) + (unless (plist-get 0x0--server :query) + (error "Service %s has no :query field" service)) + (let ((resp (if (and 0x0-use-curl-if-installed + (executable-find "curl")) + (0x0--use-curl start end) + (0x0--use-url start end))) + (timeout (0x0--calculate-timeout (- end start)))) + (with-current-buffer resp + (goto-char (point-min)) + (let ((result (cond ((plist-get 0x0--server :pomf) + (0x0--parse-pomf)) + (t (0x0--parse-plain))))) + (kill-new result) + (message (concat (format "Yanked `%s' into kill ring." result) + (and timeout (format " Should last ~%g days." timeout)))) + (kill-buffer resp) + result))))) + +;;;###autoload +(defun 0x0-upload-file (file service) + "Upload FILE to `0x0-url'." + (interactive (list (read-file-name "Upload file: ") + (0x0--choose-service))) + (with-temp-buffer + (unless 0x0-use-curl-if-installed + (insert-file-contents file)) + (let ((0x0--filename file) + (0x0--use-file t)) + (0x0-upload (point-min) (point-max) service)))) + +;;;###autoload +(defun 0x0-upload-string (string service) + "Upload STRING to `0x0-url'." + (interactive (list (read-string "Upload string: ") + (0x0--choose-service))) + (with-temp-buffer + (insert string) + (let ((0x0--filename "upload.txt")) + (0x0-upload (point-min) (point-max) service)))) + +(defun 0x0--test-service (service) + (let ((rand (make-string 256 0))) + (dotimes (i (length rand)) + (setf (aref rand i) (+ ?a (random (- ?z ?a))))) + (let* ((resp (0x0-upload-string rand service)) + result) + (with-current-buffer (url-retrieve-synchronously resp) + (goto-char (point-min)) + (forward-paragraph) + (delete-region (point-min) (1+ (point))) + (setq result (buffer-string))) + (should (or (equal rand result) + (save-match-data + (and (string-match "[[:space:]]*\\'" result) + (replace-match "" nil nil result)))))))) + +(dolist (service (mapcar #'car 0x0-services)) + (let ((name (intern (format "0x0-test-%s" (symbol-name service)))) + (name* (intern (format "0x0-test-%s-curl" (symbol-name service))))) + (eval `(ert-deftest ,name () + (let ((0x0-use-curl-if-installed nil)) + (0x0--test-service ',service)))) + (eval `(ert-deftest ,name* () + (let ((0x0-use-curl-if-installed t)) + (0x0--test-service ',service)))))) + +(provide '0x0) + +;;; 0x0.el ends here diff --git a/elpa/0x0-20200222.948/0x0.elc b/elpa/0x0-20200222.948/0x0.elc Binary files differ. diff --git a/elpa/desktop-environment-20200207.1412/desktop-environment-autoloads.el b/elpa/desktop-environment-20200207.1412/desktop-environment-autoloads.el @@ -1,96 +0,0 @@ -;;; desktop-environment-autoloads.el --- automatically extracted autoloads -;; -;;; Code: - -(add-to-list 'load-path (directory-file-name - (or (file-name-directory #$) (car load-path)))) - - -;;;### (autoloads nil "desktop-environment" "desktop-environment.el" -;;;;;; (0 0 0 0)) -;;; Generated autoloads from desktop-environment.el - -(autoload 'desktop-environment-brightness-increment "desktop-environment" "\ -Increment brightness by `desktop-environment-brightness-normal-increment'." t nil) - -(autoload 'desktop-environment-brightness-decrement "desktop-environment" "\ -Increment brightness by `desktop-environment-brightness-normal-decrement'." t nil) - -(autoload 'desktop-environment-brightness-increment-slowly "desktop-environment" "\ -Increment brightness by `desktop-environment-brightness-small-increment'." t nil) - -(autoload 'desktop-environment-brightness-decrement-slowly "desktop-environment" "\ -Decrement brightness by `desktop-environment-brightness-small-decrement'." t nil) - -(autoload 'desktop-environment-volume-increment "desktop-environment" "\ -Increment volume by `desktop-environment-volume-normal-increment'." t nil) - -(autoload 'desktop-environment-volume-decrement "desktop-environment" "\ -Increment volume by `desktop-environment-volume-normal-decrement'." t nil) - -(autoload 'desktop-environment-volume-increment-slowly "desktop-environment" "\ -Increment volume by `desktop-environment-volume-small-increment'." t nil) - -(autoload 'desktop-environment-volume-decrement-slowly "desktop-environment" "\ -Decrement volume by `desktop-environment-volume-small-decrement'." t nil) - -(autoload 'desktop-environment-toggle-mute "desktop-environment" "\ -Toggle between muted and un-muted." t nil) - -(autoload 'desktop-environment-toggle-microphone-mute "desktop-environment" "\ -Toggle microphone between muted and un-muted." t nil) - -(autoload 'desktop-environment-keyboard-backlight-increment "desktop-environment" "\ -Increment keyboard backlight by `desktop-environment-keyboard-backlight-normal-increment'." t nil) - -(autoload 'desktop-environment-screenshot "desktop-environment" "\ -Take a screenshot of the screen in the current working directory." t nil) - -(autoload 'desktop-environment-screenshot-part "desktop-environment" "\ -Take a partial screenshot in the current working directory. - -The command asks the user to interactively select a portion of -the screen." t nil) - -(autoload 'desktop-environment-lock-screen "desktop-environment" "\ -Lock the screen, preventing anyone without a password from using the system." t nil) - -(autoload 'desktop-environment-toggle-wifi "desktop-environment" "\ -Toggle wifi adapter on and off." t nil) - -(autoload 'desktop-environment-toggle-bluetooth "desktop-environment" "\ -Toggle bluetooth on and off." t nil) - -(defvar desktop-environment-mode nil "\ -Non-nil if Desktop-Environment mode is enabled. -See the `desktop-environment-mode' command -for a description of this minor mode. -Setting this variable directly does not take effect; -either customize it (see the info node `Easy Customization') -or call the function `desktop-environment-mode'.") - -(custom-autoload 'desktop-environment-mode "desktop-environment" nil) - -(autoload 'desktop-environment-mode "desktop-environment" "\ -Activate keybindings to control your desktop environment. - -If called interactively, enable Desktop-Environment mode if ARG -is positive, and disable it if ARG is zero or negative. If -called from Lisp, also enable the mode if ARG is omitted or nil, -and toggle it if ARG is `toggle'; disable the mode otherwise. - -\\{desktop-environment-mode-map} - -\(fn &optional ARG)" t nil) - -(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "desktop-environment" '("desktop-environment-"))) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; coding: utf-8 -;; End: -;;; desktop-environment-autoloads.el ends here diff --git a/elpa/desktop-environment-20200207.1412/desktop-environment-pkg.el b/elpa/desktop-environment-20200207.1412/desktop-environment-pkg.el @@ -1,2 +0,0 @@ -;;; Generated package description from /home/jdb/.config/emacs/elpa/desktop-environment-20200207.1412/desktop-environment.el -*- no-byte-compile: t -*- -(define-package "desktop-environment" "20200207.1412" "Helps you control your GNU/Linux computer" '((emacs "25.1")) :commit "cd5145288944f4bbd7b2459e4b55a6a95e37f06d" :authors '(("Damien Cassou <damien@cassou.me>, Nicolas Petton" . "nicolas@petton.fr")) :maintainer '("Damien Cassou <damien@cassou.me>, Nicolas Petton" . "nicolas@petton.fr") :url "https://gitlab.petton.fr/DamienCassou/desktop-environment") diff --git a/elpa/desktop-environment-20200207.1412/desktop-environment.el b/elpa/desktop-environment-20200207.1412/desktop-environment.el @@ -1,463 +0,0 @@ -;;; desktop-environment.el --- Helps you control your GNU/Linux computer -*- lexical-binding: t; -*- - -;; Copyright (C) 2018 Damien Cassou - -;; Author: Damien Cassou <damien@cassou.me>, Nicolas Petton <nicolas@petton.fr> -;; Url: https://gitlab.petton.fr/DamienCassou/desktop-environment -;; Package-Version: 20200207.1412 -;; Package-requires: ((emacs "25.1")) -;; Version: 0.3.0 - -;; This program is free software; you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; This program is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with this program. If not, see <https://www.gnu.org/licenses/>. - -;;; Commentary: - -;; This package helps you control your GNU/Linux desktop from Emacs. -;; With desktop-environment, you can control the brightness and volume -;; as well as take screenshots and lock your screen. The package -;; depends on the availability of shell commands to do the hard work -;; for us. These commands can be changed by customizing the -;; appropriate variables. - -;; The global minor mode `desktop-environment-mode' binds standard -;; keys to provided commands: e.g., <XF86AudioRaiseVolume> to raise -;; the volume, <print> to take a screenshot, and <s-l> to lock the -;; screen. - -;;; Code: - -(require 'dbus) - -(defgroup desktop-environment nil - "Configure desktop-environment." - :group 'environment) - - -;;; Customization - keyboard backlight -(defcustom desktop-environment-keyboard-backlight-normal-increment 1 - "Normal keyboard increment value." - :type 'integer) - -(defcustom desktop-environment-keyboard-backlight-normal-decrement -1 - "Normal keyboard decrement value." - :type 'integer) - - -;;; Customization - brightness - -(defcustom desktop-environment-brightness-normal-increment "10%+" - "Normal brightness increment value." - :type 'string) - -(defcustom desktop-environment-brightness-normal-decrement "10%-" - "Normal brightness decrement value." - :type 'string) - -(defcustom desktop-environment-brightness-small-increment "5%+" - "Small brightness increment value." - :type 'string) - -(defcustom desktop-environment-brightness-small-decrement "5%-" - "Small brightness decrement value." - :type 'string) - -(defcustom desktop-environment-brightness-get-command "brightnessctl" - "Shell command getting current screen brightness level. -If you change this variable, you might want to change -`desktop-environment-brightness-get-regexp' as well." - :type 'string) - -(defcustom desktop-environment-brightness-get-regexp "\\([0-9]+%\\)" - "Regular expression matching brightness value. - -This regular expression will be tested against the result of -`desktop-environment-brightness-get-command' and group 1 must -match the current brightness level." - :type 'regexp) - -(defcustom desktop-environment-brightness-set-command "brightnessctl set %s" - "Shell command setting the brightness level. -The value must contain 1 occurrence of '%s' that will be -replaced by the desired new brightness level." - :type 'string) - - -;;; Customization - volume - -(defcustom desktop-environment-volume-normal-increment "5%+" - "Normal volume increment value." - :type 'string) - -(defcustom desktop-environment-volume-normal-decrement "5%-" - "Normal volume decrement value." - :type 'string) - -(defcustom desktop-environment-volume-small-increment "1%+" - "Small volume increment value." - :type 'string) - -(defcustom desktop-environment-volume-small-decrement "1%-" - "Small volume decrement value." - :type 'string) - -(defcustom desktop-environment-volume-get-command "amixer get Master" - "Shell command getting current volume level. -If you change this variable, you might want to change -`desktop-environment-volume-get-regexp' as well." - :type 'string) - -(defcustom desktop-environment-volume-get-regexp "\\([0-9]+%\\)" - "Regular expression matching volume value. - -This regular expression will be tested against the result of -`desktop-environment-volume-get-command' and group 1 must -match the current volume level." - :type 'regexp) - -(defcustom desktop-environment-volume-set-command "amixer set Master %s" - "Shell command setting the volume level. -The value must contain 1 occurrence of '%s' that will be -replaced by the desired new volume level." - :type 'string) - -(defcustom desktop-environment-volume-toggle-command "amixer set Master toggle" - "Shell command toggling between muted and unmuted." - :type 'string) - -(defcustom desktop-environment-volume-toggle-microphone-command "amixer set Capture toggle" - "Shell command toggling microphone between muted and unmuted." - :type 'string) - - -;;; Customization - screenshots - -(defcustom desktop-environment-screenshot-command "scrot" - "Shell command taking a screenshot in the current working directory." - :type 'string) - -(defcustom desktop-environment-screenshot-partial-command "scrot -s" - "Shell command taking a partial screenshot in the current working directory. - -The shell command should let the user interactively select the -portion of the screen." - :type 'string) - -(defcustom desktop-environment-screenshot-directory "~/Pictures" - "Directory where to save screenshots." - :type 'directory) - - -;;; Customization - screen locking - -(defcustom desktop-environment-screenlock-command "slock" - "Shell command locking the screen." - :type 'string) - - -;;; Customization - wifi - -(defcustom desktop-environment-wifi-command "wifi toggle" - "Shell command toggling wifi." - :type 'string) - -;;; Customization - bluetooth - -(defcustom desktop-environment-bluetooth-command "bluetooth toggle" - "Shell command toggling bluetooth." - :type 'string) - - -;;; Customization - EXWM keybindings - -(defcustom desktop-environment-update-exwm-global-keys :global - "Determines interacting with EXWM bindings when enabling/disabling the mode." - :type '(radio - (const :tag "Global" :doc "Use `exwm-input-set-key' on mode activation to set bindings." :global) - (const :tag "Prefix" :doc "Add/Remove keys to `exwm-input-prefix-keys' when enabling/disabling the mode." :prefix) - (const :tag "Off" :doc "Do not touch EXWM key bindings." nil))) - -;;; Helper functions - brightness - -(defun desktop-environment-brightness-get () - "Return a string representing current brightness level." - (let ((output (shell-command-to-string desktop-environment-brightness-get-command))) - (save-match-data - (string-match desktop-environment-brightness-get-regexp output) - (match-string 1 output)))) - -(defun desktop-environment-brightness-set (value) - "Set brightness to VALUE." - (shell-command-to-string (format desktop-environment-brightness-set-command value)) - (message "New brightness value: %s" (desktop-environment-brightness-get))) - - -;;; Helper functions - volume - -(defun desktop-environment-volume-get () - "Return a string representing current volume level." - (let ((output (shell-command-to-string desktop-environment-volume-get-command))) - (save-match-data - (string-match desktop-environment-volume-get-regexp output) - (match-string 1 output)))) - -(defun desktop-environment-volume-set (value) - "Set volume to VALUE." - (shell-command-to-string (format desktop-environment-volume-set-command value)) - (message "New volume value: %s" (desktop-environment-volume-get))) - - -;;; Helper functions - keyboard backlight -(defun desktop-environment-keyboard-backlight-percent () - "Return the new keyboard backlight value as a % of maximum backlight." - (let ((backlight-level (desktop-environment-keyboard-backlight-get))) - (if (eq backlight-level 0) - "0.0" - (* - (/ (* backlight-level 1.0) - (* (desktop-environment-keyboard-backlight-get-max) 1.0)) - 100)))) - -(defun desktop-environment-keyboard-backlight-get () - "Return a number representing keyboard backlight current level." - (dbus-call-method :system - "org.freedesktop.UPower" - "/org/freedesktop/UPower/KbdBacklight" - "org.freedesktop.UPower.KbdBacklight" - "GetBrightness")) - -(defun desktop-environment-keyboard-backlight-get-max () - "Return a number representing keyboard backlight maximum level." - (dbus-call-method :system - "org.freedesktop.UPower" - "/org/freedesktop/UPower/KbdBacklight" - "org.freedesktop.UPower.KbdBacklight" - "GetMaxBrightness")) - -(defun desktop-environment-keyboard-backlight-set (value) - "Set keyboard backlight to VALUE." - (dbus-call-method :system - "org.freedesktop.UPower" - "/org/freedesktop/UPower/KbdBacklight" - "org.freedesktop.UPower.KbdBacklight" - "SetBrightness" - :int32 value) - (message "New keyboard value: %s%%" (desktop-environment-keyboard-backlight-percent))) - - -;;; Commands - brightness - -;;;###autoload -(defun desktop-environment-brightness-increment () - "Increment brightness by `desktop-environment-brightness-normal-increment'." - (interactive) - (desktop-environment-brightness-set desktop-environment-brightness-normal-increment)) - -;;;###autoload -(defun desktop-environment-brightness-decrement () - "Increment brightness by `desktop-environment-brightness-normal-decrement'." - (interactive) - (desktop-environment-brightness-set desktop-environment-brightness-normal-decrement)) - -;;;###autoload -(defun desktop-environment-brightness-increment-slowly () - "Increment brightness by `desktop-environment-brightness-small-increment'." - (interactive) - (desktop-environment-brightness-set desktop-environment-brightness-small-increment)) - -;;;###autoload -(defun desktop-environment-brightness-decrement-slowly () - "Decrement brightness by `desktop-environment-brightness-small-decrement'." - (interactive) - (desktop-environment-brightness-set desktop-environment-brightness-small-decrement)) - - -;;; Commands - volume - -;;;###autoload -(defun desktop-environment-volume-increment () - "Increment volume by `desktop-environment-volume-normal-increment'." - (interactive) - (desktop-environment-volume-set desktop-environment-volume-normal-increment)) - -;;;###autoload -(defun desktop-environment-volume-decrement () - "Increment volume by `desktop-environment-volume-normal-decrement'." - (interactive) - (desktop-environment-volume-set desktop-environment-volume-normal-decrement)) - -;;;###autoload -(defun desktop-environment-volume-increment-slowly () - "Increment volume by `desktop-environment-volume-small-increment'." - (interactive) - (desktop-environment-volume-set desktop-environment-volume-small-increment)) - -;;;###autoload -(defun desktop-environment-volume-decrement-slowly () - "Decrement volume by `desktop-environment-volume-small-decrement'." - (interactive) - (desktop-environment-volume-set desktop-environment-volume-small-decrement)) - -;;;###autoload -(defun desktop-environment-toggle-mute () - "Toggle between muted and un-muted." - (interactive) - (message "%s" - (shell-command-to-string desktop-environment-volume-toggle-command))) - -;;;###autoload -(defun desktop-environment-toggle-microphone-mute () - "Toggle microphone between muted and un-muted." - (interactive) - (message "%s" - (shell-command-to-string desktop-environment-volume-toggle-microphone-command))) - - -;;; Commands - keyboard backlight -;;;###autoload -(defun desktop-environment-keyboard-backlight-increment () - "Increment keyboard backlight by `desktop-environment-keyboard-backlight-normal-increment'." - (interactive) - (desktop-environment-keyboard-backlight-set - (+ desktop-environment-keyboard-backlight-normal-increment - (desktop-environment-keyboard-backlight-get)))) - -(defun desktop-environment-keyboard-backlight-decrement () - "Decrement keyboard backlight by `desktop-environment-keyboard-backlight-normal-decrement'." - (interactive) - (desktop-environment-keyboard-backlight-set - (+ desktop-environment-keyboard-backlight-normal-decrement - (desktop-environment-keyboard-backlight-get)))) - - -;;; Commands - screenshots - -;;;###autoload -(defun desktop-environment-screenshot () - "Take a screenshot of the screen in the current working directory." - (interactive) - (let ((default-directory (expand-file-name desktop-environment-screenshot-directory))) - (start-process-shell-command "desktop-environment-screenshot" nil desktop-environment-screenshot-command))) - -;;;###autoload -(defun desktop-environment-screenshot-part () - "Take a partial screenshot in the current working directory. - -The command asks the user to interactively select a portion of -the screen." - (interactive) - (let ((default-directory (expand-file-name desktop-environment-screenshot-directory))) - (message "Please select the part of your screen to shoot.") - (start-process-shell-command "desktop-environment-screenshot" nil desktop-environment-screenshot-partial-command))) - - -;;; Commands - screen locking - -;;;###autoload -(defun desktop-environment-lock-screen () - "Lock the screen, preventing anyone without a password from using the system." - (interactive) - ;; Run command asynchronously so that Emacs does not wait in the background. - (start-process-shell-command "lock" nil desktop-environment-screenlock-command)) - - -;;; Commands - wifi - -;;;###autoload -(defun desktop-environment-toggle-wifi () - "Toggle wifi adapter on and off." - (interactive) - (let ((async-shell-command-buffer 'new-buffer)) - (async-shell-command desktop-environment-wifi-command))) - -;;; Commands - bluetooth - -;;;###autoload -(defun desktop-environment-toggle-bluetooth () - "Toggle bluetooth on and off." - (interactive) - (let ((async-shell-command-buffer 'new-buffer)) - (async-shell-command desktop-environment-bluetooth-command))) - -;;; Minor mode - -(defvar desktop-environment-mode-map - (let ((desktop-environment--keybindings - `(;; Brightness - (,(kbd "<XF86MonBrightnessUp>") . ,(function desktop-environment-brightness-increment)) - (,(kbd "<XF86MonBrightnessDown>") . ,(function desktop-environment-brightness-decrement)) - (,(kbd "S-<XF86MonBrightnessUp>") . ,(function desktop-environment-brightness-increment-slowly)) - (,(kbd "S-<XF86MonBrightnessDown>") . ,(function desktop-environment-brightness-decrement-slowly)) - ;; Volume - (,(kbd "<XF86AudioRaiseVolume>") . ,(function desktop-environment-volume-increment)) - (,(kbd "<XF86AudioLowerVolume>") . ,(function desktop-environment-volume-decrement)) - (,(kbd "S-<XF86AudioRaiseVolume>") . ,(function desktop-environment-volume-increment-slowly)) - (,(kbd "S-<XF86AudioLowerVolume>") . ,(function desktop-environment-volume-decrement-slowly)) - (,(kbd "<XF86AudioMute>") . ,(function desktop-environment-toggle-mute)) - (,(kbd "<XF86AudioMicMute>") . ,(function desktop-environment-toggle-microphone-mute)) - ;; Volume - (,(kbd "S-<print>") . ,(function desktop-environment-screenshot-part)) - (,(kbd "<print>") . ,(function desktop-environment-screenshot)) - ;; Screen locking - (,(kbd "s-l") . ,(function desktop-environment-lock-screen)) - ;; Wifi controls - (,(kbd "<XF86WLAN>") . ,(function desktop-environment-toggle-wifi)) - ;; Bluetooth controls - (,(kbd "<XF86Bluetooth>") . ,(function desktop-environment-toggle-bluetooth)))) - (map (make-sparse-keymap))) - (dolist (keybinding desktop-environment--keybindings) - (define-key map (car keybinding) (cdr keybinding))) - map) - "Keymap for `desktop-environment-mode'.") - -(declare-function exwm-input-set-key "ext:exwm-input") - -(defun desktop-environment-exwm-set-global-keybindings (enable) - "When using EXWM, add `desktop-environment-mode-map' to global keys. - -When ENABLE is non-nil, the bindings will be installed depending -on the value of `desktop-environment-update-exwm-global-keys'. -If set to `:prefix', the bindings will be disabled when ENABLE is -nil." - (when (featurep 'exwm-input) - (cl-case desktop-environment-update-exwm-global-keys - (:global - (when enable - (map-keymap (lambda (event definition) - (exwm-input-set-key (vector event) definition)) - desktop-environment-mode-map))) - (:prefix - (when (boundp 'exwm-input-prefix-keys) - (map-keymap (lambda (event definition) - (ignore definition) - (setq exwm-input-prefix-keys (if enable - (cons event exwm-input-prefix-keys) - (delq event exwm-input-prefix-keys)))) - desktop-environment-mode-map))) - ((nil) nil) - (t - (message "Ignoring unknown value %s for `desktop-environment-update-exwm-global-keys'" - desktop-environment-update-exwm-global-keys))))) - -;;;###autoload -(define-minor-mode desktop-environment-mode - "Activate keybindings to control your desktop environment. - -\\{desktop-environment-mode-map}" - :global t - :require 'desktop-environment - :lighter " DE" - (desktop-environment-exwm-set-global-keybindings desktop-environment-mode)) - -(provide 'desktop-environment) -;;; desktop-environment.el ends here diff --git a/elpa/desktop-environment-20200207.1412/desktop-environment.elc b/elpa/desktop-environment-20200207.1412/desktop-environment.elc Binary files differ. diff --git a/elpa/desktop-environment-20200225.1042/desktop-environment-autoloads.el b/elpa/desktop-environment-20200225.1042/desktop-environment-autoloads.el @@ -0,0 +1,96 @@ +;;; desktop-environment-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + +(add-to-list 'load-path (directory-file-name + (or (file-name-directory #$) (car load-path)))) + + +;;;### (autoloads nil "desktop-environment" "desktop-environment.el" +;;;;;; (0 0 0 0)) +;;; Generated autoloads from desktop-environment.el + +(autoload 'desktop-environment-brightness-increment "desktop-environment" "\ +Increment brightness by `desktop-environment-brightness-normal-increment'." t nil) + +(autoload 'desktop-environment-brightness-decrement "desktop-environment" "\ +Decrement brightness by `desktop-environment-brightness-normal-decrement'." t nil) + +(autoload 'desktop-environment-brightness-increment-slowly "desktop-environment" "\ +Increment brightness by `desktop-environment-brightness-small-increment'." t nil) + +(autoload 'desktop-environment-brightness-decrement-slowly "desktop-environment" "\ +Decrement brightness by `desktop-environment-brightness-small-decrement'." t nil) + +(autoload 'desktop-environment-volume-increment "desktop-environment" "\ +Increment volume by `desktop-environment-volume-normal-increment'." t nil) + +(autoload 'desktop-environment-volume-decrement "desktop-environment" "\ +Decrement volume by `desktop-environment-volume-normal-decrement'." t nil) + +(autoload 'desktop-environment-volume-increment-slowly "desktop-environment" "\ +Increment volume by `desktop-environment-volume-small-increment'." t nil) + +(autoload 'desktop-environment-volume-decrement-slowly "desktop-environment" "\ +Decrement volume by `desktop-environment-volume-small-decrement'." t nil) + +(autoload 'desktop-environment-toggle-mute "desktop-environment" "\ +Toggle between muted and un-muted." t nil) + +(autoload 'desktop-environment-toggle-microphone-mute "desktop-environment" "\ +Toggle microphone between muted and un-muted." t nil) + +(autoload 'desktop-environment-keyboard-backlight-increment "desktop-environment" "\ +Increment keyboard backlight by `desktop-environment-keyboard-backlight-normal-increment'." t nil) + +(autoload 'desktop-environment-screenshot "desktop-environment" "\ +Take a screenshot of the screen in the current working directory." t nil) + +(autoload 'desktop-environment-screenshot-part "desktop-environment" "\ +Take a partial screenshot in the current working directory. + +The command asks the user to interactively select a portion of +the screen." t nil) + +(autoload 'desktop-environment-lock-screen "desktop-environment" "\ +Lock the screen, preventing anyone without a password from using the system." t nil) + +(autoload 'desktop-environment-toggle-wifi "desktop-environment" "\ +Toggle wifi adapter on and off." t nil) + +(autoload 'desktop-environment-toggle-bluetooth "desktop-environment" "\ +Toggle bluetooth on and off." t nil) + +(defvar desktop-environment-mode nil "\ +Non-nil if Desktop-Environment mode is enabled. +See the `desktop-environment-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `desktop-environment-mode'.") + +(custom-autoload 'desktop-environment-mode "desktop-environment" nil) + +(autoload 'desktop-environment-mode "desktop-environment" "\ +Activate keybindings to control your desktop environment. + +If called interactively, enable Desktop-Environment mode if ARG +is positive, and disable it if ARG is zero or negative. If +called from Lisp, also enable the mode if ARG is omitted or nil, +and toggle it if ARG is `toggle'; disable the mode otherwise. + +\\{desktop-environment-mode-map} + +\(fn &optional ARG)" t nil) + +(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "desktop-environment" '("desktop-environment-"))) + +;;;*** + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; desktop-environment-autoloads.el ends here diff --git a/elpa/desktop-environment-20200225.1042/desktop-environment-pkg.el b/elpa/desktop-environment-20200225.1042/desktop-environment-pkg.el @@ -0,0 +1,2 @@ +;;; Generated package description from /home/jdb/.config/emacs/elpa/desktop-environment-20200225.1042/desktop-environment.el -*- no-byte-compile: t -*- +(define-package "desktop-environment" "20200225.1042" "Helps you control your GNU/Linux computer" '((emacs "25.1")) :commit "dbcf3d9411d53908de09ab0d34932d19c8117144" :authors '(("Damien Cassou <damien@cassou.me>, Nicolas Petton" . "nicolas@petton.fr")) :maintainer '("Damien Cassou <damien@cassou.me>, Nicolas Petton" . "nicolas@petton.fr") :url "https://gitlab.petton.fr/DamienCassou/desktop-environment") diff --git a/elpa/desktop-environment-20200225.1042/desktop-environment.el b/elpa/desktop-environment-20200225.1042/desktop-environment.el @@ -0,0 +1,463 @@ +;;; desktop-environment.el --- Helps you control your GNU/Linux computer -*- lexical-binding: t; -*- + +;; Copyright (C) 2018 Damien Cassou + +;; Author: Damien Cassou <damien@cassou.me>, Nicolas Petton <nicolas@petton.fr> +;; Url: https://gitlab.petton.fr/DamienCassou/desktop-environment +;; Package-Version: 20200225.1042 +;; Package-requires: ((emacs "25.1")) +;; Version: 0.3.0 + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, or +;; (at your option) any later version. + +;; This program is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; GNU General Public License for more details. + +;; You should have received a copy of the GNU General Public License +;; along with this program. If not, see <https://www.gnu.org/licenses/>. + +;;; Commentary: + +;; This package helps you control your GNU/Linux desktop from Emacs. +;; With desktop-environment, you can control the brightness and volume +;; as well as take screenshots and lock your screen. The package +;; depends on the availability of shell commands to do the hard work +;; for us. These commands can be changed by customizing the +;; appropriate variables. + +;; The global minor mode `desktop-environment-mode' binds standard +;; keys to provided commands: e.g., <XF86AudioRaiseVolume> to raise +;; the volume, <print> to take a screenshot, and <s-l> to lock the +;; screen. + +;;; Code: + +(require 'dbus) + +(defgroup desktop-environment nil + "Configure desktop-environment." + :group 'environment) + + +;;; Customization - keyboard backlight +(defcustom desktop-environment-keyboard-backlight-normal-increment 1 + "Normal keyboard increment value." + :type 'integer) + +(defcustom desktop-environment-keyboard-backlight-normal-decrement -1 + "Normal keyboard decrement value." + :type 'integer) + + +;;; Customization - brightness + +(defcustom desktop-environment-brightness-normal-increment "10%+" + "Normal brightness increment value." + :type 'string) + +(defcustom desktop-environment-brightness-normal-decrement "10%-" + "Normal brightness decrement value." + :type 'string) + +(defcustom desktop-environment-brightness-small-increment "5%+" + "Small brightness increment value." + :type 'string) + +(defcustom desktop-environment-brightness-small-decrement "5%-" + "Small brightness decrement value." + :type 'string) + +(defcustom desktop-environment-brightness-get-command "brightnessctl" + "Shell command getting current screen brightness level. +If you change this variable, you might want to change +`desktop-environment-brightness-get-regexp' as well." + :type 'string) + +(defcustom desktop-environment-brightness-get-regexp "\\([0-9]+%\\)" + "Regular expression matching brightness value. + +This regular expression will be tested against the result of +`desktop-environment-brightness-get-command' and group 1 must +match the current brightness level." + :type 'regexp) + +(defcustom desktop-environment-brightness-set-command "brightnessctl set %s" + "Shell command setting the brightness level. +The value must contain 1 occurrence of '%s' that will be +replaced by the desired new brightness level." + :type 'string) + + +;;; Customization - volume + +(defcustom desktop-environment-volume-normal-increment "5%+" + "Normal volume increment value." + :type 'string) + +(defcustom desktop-environment-volume-normal-decrement "5%-" + "Normal volume decrement value." + :type 'string) + +(defcustom desktop-environment-volume-small-increment "1%+" + "Small volume increment value." + :type 'string) + +(defcustom desktop-environment-volume-small-decrement "1%-" + "Small volume decrement value." + :type 'string) + +(defcustom desktop-environment-volume-get-command "amixer get Master" + "Shell command getting current volume level. +If you change this variable, you might want to change +`desktop-environment-volume-get-regexp' as well." + :type 'string) + +(defcustom desktop-environment-volume-get-regexp "\\([0-9]+%\\)" + "Regular expression matching volume value. + +This regular expression will be tested against the result of +`desktop-environment-volume-get-command' and group 1 must +match the current volume level." + :type 'regexp) + +(defcustom desktop-environment-volume-set-command "amixer set Master %s" + "Shell command setting the volume level. +The value must contain 1 occurrence of '%s' that will be +replaced by the desired new volume level." + :type 'string) + +(defcustom desktop-environment-volume-toggle-command "amixer set Master toggle" + "Shell command toggling between muted and unmuted." + :type 'string) + +(defcustom desktop-environment-volume-toggle-microphone-command "amixer set Capture toggle" + "Shell command toggling microphone between muted and unmuted." + :type 'string) + + +;;; Customization - screenshots + +(defcustom desktop-environment-screenshot-command "scrot" + "Shell command taking a screenshot in the current working directory." + :type 'string) + +(defcustom desktop-environment-screenshot-partial-command "scrot -s" + "Shell command taking a partial screenshot in the current working directory. + +The shell command should let the user interactively select the +portion of the screen." + :type 'string) + +(defcustom desktop-environment-screenshot-directory "~/Pictures" + "Directory where to save screenshots." + :type 'directory) + + +;;; Customization - screen locking + +(defcustom desktop-environment-screenlock-command "slock" + "Shell command locking the screen." + :type 'string) + + +;;; Customization - wifi + +(defcustom desktop-environment-wifi-command "wifi toggle" + "Shell command toggling wifi." + :type 'string) + +;;; Customization - bluetooth + +(defcustom desktop-environment-bluetooth-command "bluetooth toggle" + "Shell command toggling bluetooth." + :type 'string) + + +;;; Customization - EXWM keybindings + +(defcustom desktop-environment-update-exwm-global-keys :global + "Determines interacting with EXWM bindings when enabling/disabling the mode." + :type '(radio + (const :tag "Global" :doc "Use `exwm-input-set-key' on mode activation to set bindings." :global) + (const :tag "Prefix" :doc "Add/Remove keys to `exwm-input-prefix-keys' when enabling/disabling the mode." :prefix) + (const :tag "Off" :doc "Do not touch EXWM key bindings." nil))) + +;;; Helper functions - brightness + +(defun desktop-environment-brightness-get () + "Return a string representing current brightness level." + (let ((output (shell-command-to-string desktop-environment-brightness-get-command))) + (save-match-data + (string-match desktop-environment-brightness-get-regexp output) + (match-string 1 output)))) + +(defun desktop-environment-brightness-set (value) + "Set brightness to VALUE." + (shell-command-to-string (format desktop-environment-brightness-set-command value)) + (message "New brightness value: %s" (desktop-environment-brightness-get))) + + +;;; Helper functions - volume + +(defun desktop-environment-volume-get () + "Return a string representing current volume level." + (let ((output (shell-command-to-string desktop-environment-volume-get-command))) + (save-match-data + (string-match desktop-environment-volume-get-regexp output) + (match-string 1 output)))) + +(defun desktop-environment-volume-set (value) + "Set volume to VALUE." + (shell-command-to-string (format desktop-environment-volume-set-command value)) + (message "New volume value: %s" (desktop-environment-volume-get))) + + +;;; Helper functions - keyboard backlight +(defun desktop-environment-keyboard-backlight-percent () + "Return the new keyboard backlight value as a % of maximum backlight." + (let ((backlight-level (desktop-environment-keyboard-backlight-get))) + (if (eq backlight-level 0) + "0.0" + (* + (/ (* backlight-level 1.0) + (* (desktop-environment-keyboard-backlight-get-max) 1.0)) + 100)))) + +(defun desktop-environment-keyboard-backlight-get () + "Return a number representing keyboard backlight current level." + (dbus-call-method :system + "org.freedesktop.UPower" + "/org/freedesktop/UPower/KbdBacklight" + "org.freedesktop.UPower.KbdBacklight" + "GetBrightness")) + +(defun desktop-environment-keyboard-backlight-get-max () + "Return a number representing keyboard backlight maximum level." + (dbus-call-method :system + "org.freedesktop.UPower" + "/org/freedesktop/UPower/KbdBacklight" + "org.freedesktop.UPower.KbdBacklight" + "GetMaxBrightness")) + +(defun desktop-environment-keyboard-backlight-set (value) + "Set keyboard backlight to VALUE." + (dbus-call-method :system + "org.freedesktop.UPower" + "/org/freedesktop/UPower/KbdBacklight" + "org.freedesktop.UPower.KbdBacklight" + "SetBrightness" + :int32 value) + (message "New keyboard value: %s%%" (desktop-environment-keyboard-backlight-percent))) + + +;;; Commands - brightness + +;;;###autoload +(defun desktop-environment-brightness-increment () + "Increment brightness by `desktop-environment-brightness-normal-increment'." + (interactive) + (desktop-environment-brightness-set desktop-environment-brightness-normal-increment)) + +;;;###autoload +(defun desktop-environment-brightness-decrement () + "Decrement brightness by `desktop-environment-brightness-normal-decrement'." + (interactive) + (desktop-environment-brightness-set desktop-environment-brightness-normal-decrement)) + +;;;###autoload +(defun desktop-environment-brightness-increment-slowly () + "Increment brightness by `desktop-environment-brightness-small-increment'." + (interactive) + (desktop-environment-brightness-set desktop-environment-brightness-small-increment)) + +;;;###autoload +(defun desktop-environment-brightness-decrement-slowly () + "Decrement brightness by `desktop-environment-brightness-small-decrement'." + (interactive) + (desktop-environment-brightness-set desktop-environment-brightness-small-decrement)) + + +;;; Commands - volume + +;;;###autoload +(defun desktop-environment-volume-increment () + "Increment volume by `desktop-environment-volume-normal-increment'." + (interactive) + (desktop-environment-volume-set desktop-environment-volume-normal-increment)) + +;;;###autoload +(defun desktop-environment-volume-decrement () + "Decrement volume by `desktop-environment-volume-normal-decrement'." + (interactive) + (desktop-environment-volume-set desktop-environment-volume-normal-decrement)) + +;;;###autoload +(defun desktop-environment-volume-increment-slowly () + "Increment volume by `desktop-environment-volume-small-increment'." + (interactive) + (desktop-environment-volume-set desktop-environment-volume-small-increment)) + +;;;###autoload +(defun desktop-environment-volume-decrement-slowly () + "Decrement volume by `desktop-environment-volume-small-decrement'." + (interactive) + (desktop-environment-volume-set desktop-environment-volume-small-decrement)) + +;;;###autoload +(defun desktop-environment-toggle-mute () + "Toggle between muted and un-muted." + (interactive) + (message "%s" + (shell-command-to-string desktop-environment-volume-toggle-command))) + +;;;###autoload +(defun desktop-environment-toggle-microphone-mute () + "Toggle microphone between muted and un-muted." + (interactive) + (message "%s" + (shell-command-to-string desktop-environment-volume-toggle-microphone-command))) + + +;;; Commands - keyboard backlight +;;;###autoload +(defun desktop-environment-keyboard-backlight-increment () + "Increment keyboard backlight by `desktop-environment-keyboard-backlight-normal-increment'." + (interactive) + (desktop-environment-keyboard-backlight-set + (+ desktop-environment-keyboard-backlight-normal-increment + (desktop-environment-keyboard-backlight-get)))) + +(defun desktop-environment-keyboard-backlight-decrement () + "Decrement keyboard backlight by `desktop-environment-keyboard-backlight-normal-decrement'." + (interactive) + (desktop-environment-keyboard-backlight-set + (+ desktop-environment-keyboard-backlight-normal-decrement + (desktop-environment-keyboard-backlight-get)))) + + +;;; Commands - screenshots + +;;;###autoload +(defun desktop-environment-screenshot () + "Take a screenshot of the screen in the current working directory." + (interactive) + (let ((default-directory (expand-file-name desktop-environment-screenshot-directory))) + (start-process-shell-command "desktop-environment-screenshot" nil desktop-environment-screenshot-command))) + +;;;###autoload +(defun desktop-environment-screenshot-part () + "Take a partial screenshot in the current working directory. + +The command asks the user to interactively select a portion of +the screen." + (interactive) + (let ((default-directory (expand-file-name desktop-environment-screenshot-directory))) + (message "Please select the part of your screen to shoot.") + (start-process-shell-command "desktop-environment-screenshot" nil desktop-environment-screenshot-partial-command))) + + +;;; Commands - screen locking + +;;;###autoload +(defun desktop-environment-lock-screen () + "Lock the screen, preventing anyone without a password from using the system." + (interactive) + ;; Run command asynchronously so that Emacs does not wait in the background. + (start-process-shell-command "lock" nil desktop-environment-screenlock-command)) + + +;;; Commands - wifi + +;;;###autoload +(defun desktop-environment-toggle-wifi () + "Toggle wifi adapter on and off." + (interactive) + (let ((async-shell-command-buffer 'new-buffer)) + (async-shell-command desktop-environment-wifi-command))) + +;;; Commands - bluetooth + +;;;###autoload +(defun desktop-environment-toggle-bluetooth () + "Toggle bluetooth on and off." + (interactive) + (let ((async-shell-command-buffer 'new-buffer)) + (async-shell-command desktop-environment-bluetooth-command))) + +;;; Minor mode + +(defvar desktop-environment-mode-map + (let ((desktop-environment--keybindings + `(;; Brightness + (,(kbd "<XF86MonBrightnessUp>") . ,(function desktop-environment-brightness-increment)) + (,(kbd "<XF86MonBrightnessDown>") . ,(function desktop-environment-brightness-decrement)) + (,(kbd "S-<XF86MonBrightnessUp>") . ,(function desktop-environment-brightness-increment-slowly)) + (,(kbd "S-<XF86MonBrightnessDown>") . ,(function desktop-environment-brightness-decrement-slowly)) + ;; Volume + (,(kbd "<XF86AudioRaiseVolume>") . ,(function desktop-environment-volume-increment)) + (,(kbd "<XF86AudioLowerVolume>") . ,(function desktop-environment-volume-decrement)) + (,(kbd "S-<XF86AudioRaiseVolume>") . ,(function desktop-environment-volume-increment-slowly)) + (,(kbd "S-<XF86AudioLowerVolume>") . ,(function desktop-environment-volume-decrement-slowly)) + (,(kbd "<XF86AudioMute>") . ,(function desktop-environment-toggle-mute)) + (,(kbd "<XF86AudioMicMute>") . ,(function desktop-environment-toggle-microphone-mute)) + ;; Volume + (,(kbd "S-<print>") . ,(function desktop-environment-screenshot-part)) + (,(kbd "<print>") . ,(function desktop-environment-screenshot)) + ;; Screen locking + (,(kbd "s-l") . ,(function desktop-environment-lock-screen)) + ;; Wifi controls + (,(kbd "<XF86WLAN>") . ,(function desktop-environment-toggle-wifi)) + ;; Bluetooth controls + (,(kbd "<XF86Bluetooth>") . ,(function desktop-environment-toggle-bluetooth)))) + (map (make-sparse-keymap))) + (dolist (keybinding desktop-environment--keybindings) + (define-key map (car keybinding) (cdr keybinding))) + map) + "Keymap for `desktop-environment-mode'.") + +(declare-function exwm-input-set-key "ext:exwm-input") + +(defun desktop-environment-exwm-set-global-keybindings (enable) + "When using EXWM, add `desktop-environment-mode-map' to global keys. + +When ENABLE is non-nil, the bindings will be installed depending +on the value of `desktop-environment-update-exwm-global-keys'. +If set to `:prefix', the bindings will be disabled when ENABLE is +nil." + (when (featurep 'exwm-input) + (cl-case desktop-environment-update-exwm-global-keys + (:global + (when enable + (map-keymap (lambda (event definition) + (exwm-input-set-key (vector event) definition)) + desktop-environment-mode-map))) + (:prefix + (when (boundp 'exwm-input-prefix-keys) + (map-keymap (lambda (event definition) + (ignore definition) + (setq exwm-input-prefix-keys (if enable + (cons event exwm-input-prefix-keys) + (delq event exwm-input-prefix-keys)))) + desktop-environment-mode-map))) + ((nil) nil) + (t + (message "Ignoring unknown value %s for `desktop-environment-update-exwm-global-keys'" + desktop-environment-update-exwm-global-keys))))) + +;;;###autoload +(define-minor-mode desktop-environment-mode + "Activate keybindings to control your desktop environment. + +\\{desktop-environment-mode-map}" + :global t + :require 'desktop-environment + :lighter " DE" + (desktop-environment-exwm-set-global-keybindings desktop-environment-mode)) + +(provide 'desktop-environment) +;;; desktop-environment.el ends here diff --git a/elpa/desktop-environment-20200225.1042/desktop-environment.elc b/elpa/desktop-environment-20200225.1042/desktop-environment.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-completion.el b/elpa/geiser-20200214.110/geiser-completion.el @@ -1,198 +0,0 @@ -;;; geiser-completion.el -- tab completion - -;; Copyright (C) 2009, 2010, 2011, 2012, 2018, 2020 Jose Antonio Ortega Ruiz - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the Modified BSD License. You should -;; have received a copy of the license along with this program. If -;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>. - -;; Start date: Mon Feb 09, 2009 22:21 - - - -(require 'geiser-impl) -(require 'geiser-eval) -(require 'geiser-log) -(require 'geiser-syntax) -(require 'geiser-base) - -(require 'comint) -(require 'minibuffer) - - -;;; Minibuffer maps: - -(defvar geiser-completion--minibuffer-map - (let ((map (make-keymap))) - (set-keymap-parent map minibuffer-local-completion-map) - (define-key map "?" 'self-insert-command) - map)) - -(defvar geiser-completion--module-minibuffer-map - (let ((map (make-keymap))) - (set-keymap-parent map minibuffer-local-completion-map) - (define-key map " " 'self-insert-command) - (define-key map "?" 'self-insert-command) - map)) - - -;;; Completion functionality: - -(defvar geiser-completion--binding-forms nil) -(geiser-impl--register-local-variable - 'geiser-completion--binding-forms 'binding-forms nil - "A list of forms introducing local bindings, a la let or lambda.") - -(defvar geiser-completion--binding-forms* nil) -(geiser-impl--register-local-variable - 'geiser-completion--binding-forms* 'binding-forms* nil - "A list of forms introducing nested local bindings, a la let*.") - -(defsubst geiser-completion--locals () - (geiser-syntax--locals-around-point geiser-completion--binding-forms - geiser-completion--binding-forms*)) - -(defun geiser-completion--symbol-list (prefix) - (geiser--del-dups - (append (all-completions prefix (geiser-completion--locals)) - (geiser-eval--send/result `(:eval (:ge completions ,prefix)))))) - -(defsubst geiser-completion--module-list (prefix) - (geiser-eval--send/result `(:eval (:ge module-completions ,prefix)))) - -(defvar geiser-completion--module-list-func - (if (= emacs-major-version 25) - (completion-table-dynamic 'geiser-completion--module-list t) - (completion-table-dynamic 'geiser-completion--module-list))) - -(defvar geiser-completion-symbol-list-func - (if (< emacs-major-version 25) - (completion-table-dynamic 'geiser-completion--symbol-list t))) - -(defun geiser-completion--complete (prefix modules) - (if modules (geiser-completion--module-list prefix) - (geiser-completion--symbol-list prefix))) - -(defvar geiser-completion--symbol-history nil) - -(defun geiser-completion--read-symbol (prompt &optional default history) - (let ((minibuffer-local-completion-map geiser-completion--minibuffer-map)) - (make-symbol (completing-read prompt - geiser-completion-symbol-list-func - nil nil nil - (or history - geiser-completion--symbol-history) - (or default (geiser--symbol-at-point)))))) - -(defvar geiser-completion--module-history nil) - -(defun geiser-completion--read-module (&optional prompt default history) - (let ((minibuffer-local-completion-map - geiser-completion--module-minibuffer-map)) - (completing-read (or prompt "Module name: ") - geiser-completion-module-list-func - nil nil nil - (or history geiser-completion--module-history) - default))) - -(defvar geiser-completion--symbol-begin-function nil) - -(defun geiser-completion--def-symbol-begin (module) - (save-excursion (skip-syntax-backward "^-()>") (point))) - -(geiser-impl--register-local-method - 'geiser-completion--symbol-begin-function 'find-symbol-begin - 'geiser-completion--def-symbol-begin - "An optional function finding the position of the beginning of -the identifier around point. Takes a boolean, indicating whether -we're looking for a module name.") - -(defun geiser-completion--symbol-begin (module) - (funcall geiser-completion--symbol-begin-function module)) - -(defun geiser-completion--module-at-point () - (save-excursion - (goto-char (geiser-completion--symbol-begin t)) - (ignore-errors (thing-at-point 'sexp)))) - -(defsubst geiser-completion--prefix (module) - (buffer-substring-no-properties (geiser-completion--symbol-begin module) - (point))) - -(defsubst geiser-completion--prefix-end (beg mod) - (unless (or (eq beg (point-max)) - (member (char-syntax (char-after beg)) - (if mod '(?\" ?\)) '(?\" ?\( ?\))))) - (let ((pos (point))) - (condition-case nil - (save-excursion - (goto-char beg) - (forward-sexp 1) - (when (>= (point) pos) - (point))) - (scan-error pos))))) - -(defun geiser-completion--thing-at-point (module &optional predicate) - (with-syntax-table scheme-mode-syntax-table - (let* ((beg (geiser-completion--symbol-begin module)) - (end (or (geiser-completion--prefix-end beg module) beg)) - (prefix (and (> end beg) (buffer-substring-no-properties beg end))) - (prefix (and prefix - (if (string-match "\\([^-]+\\)-" prefix) - (match-string 1 prefix) - prefix))) - (cmps (and prefix (geiser-completion--complete prefix module)))) - (and cmps (list beg end cmps))))) - -(defun geiser-completion--for-symbol (&optional predicate) - (geiser-completion--thing-at-point nil predicate)) - -(defun geiser-completion--for-module (&optional predicate) - (geiser-completion--thing-at-point t predicate)) - -(defun geiser-completion--for-filename () - (when (geiser-syntax--in-string-p) - (let ((comint-completion-addsuffix "\"")) - (comint-dynamic-complete-filename)))) - -(defun geiser-completion--setup (enable) - (set (make-local-variable 'completion-at-point-functions) - (if enable - '(geiser-completion--for-symbol - geiser-completion--for-module - geiser-completion--for-filename) - (default-value 'completion-at-point-functions)))) - -(defun geiser-completion--complete-module () - "Complete module name at point." - (interactive) - (let ((completion-at-point-functions '(geiser-completion--for-module))) - (call-interactively 'completion-at-point))) - - -;;; Smart tab mode: - -(make-variable-buffer-local - (defvar geiser-smart-tab-mode-string " SmartTab" - "Modeline indicator for geiser-smart-tab-mode")) - -(define-minor-mode geiser-smart-tab-mode - "Toggle smart tab mode. -With no argument, this command toggles the mode. -Non-null prefix argument turns on the mode. -Null prefix argument turns off the mode. - -When this mode is enable, TAB will indent if at point is at -beginning of line or after a white space or closing parenthesis, -and will try completing symbol at point otherwise." - :init-value nil - :lighter geiser-smart-tab-mode-string - :group 'geiser-mode - (set (make-local-variable 'tab-always-indent) - (if geiser-smart-tab-mode - 'complete - (default-value 'tab-always-indent)))) - - -(provide 'geiser-completion) diff --git a/elpa/geiser-20200214.110/geiser-completion.elc b/elpa/geiser-20200214.110/geiser-completion.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-pkg.el b/elpa/geiser-20200214.110/geiser-pkg.el @@ -1,4 +0,0 @@ -(define-package "geiser" "20200214.110" "GNU Emacs and Scheme talk to each other" 'nil :url "http://www.nongnu.org/geiser/") -;; Local Variables: -;; no-byte-compile: t -;; End: diff --git a/elpa/geiser-20200214.110/geiser.info b/elpa/geiser-20200214.110/geiser.info @@ -1,1914 +0,0 @@ -This is geiser.info, produced by makeinfo version 6.5 from geiser.texi. - -This manual documents Geiser, an Emacs environment to hack in Scheme. - - Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018 Jose -Antonio Ortega Ruiz - - Permission is granted to copy, distribute and/or modify this - document under the terms of the GNU Free Documentation License, - Version 1.3 or any later version published by the Free Software - Foundation; with no Invariant Sections, no Front-Cover Texts, and - no Back-Cover Texts. A copy of the license is available from the - Free Software Foundation Web site at - <http://www.gnu.org/licenses/fdl.html>. - - The document was typeset with GNU Texinfo -(http://www.gnu.org/software/texinfo/index.html). -INFO-DIR-SECTION Emacs -START-INFO-DIR-ENTRY -* Geiser: (geiser). Emacs environment for Scheme hacking. -END-INFO-DIR-ENTRY - - -File: geiser.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) - -Geiser -****** - -This manual documents Geiser, an Emacs environment to hack in Scheme. - - Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018 Jose -Antonio Ortega Ruiz - - Permission is granted to copy, distribute and/or modify this - document under the terms of the GNU Free Documentation License, - Version 1.3 or any later version published by the Free Software - Foundation; with no Invariant Sections, no Front-Cover Texts, and - no Back-Cover Texts. A copy of the license is available from the - Free Software Foundation Web site at - <http://www.gnu.org/licenses/fdl.html>. - - The document was typeset with GNU Texinfo -(http://www.gnu.org/software/texinfo/index.html). - -* Menu: - -* Introduction:: -* Installation:: -* The REPL:: -* Between the parens:: -* Cheat sheet:: -* No hacker is an island:: -* Index:: - - -- The Detailed Node Listing -- - -Introduction - -* Modus operandi:: -* Showing off:: - -Installation - -* Must needs:: -* The easy and quick way:: -* From the source's mouth:: -* Friends:: - -The REPL - -* Starting the REPL:: -* First aids:: -* Switching context:: -* Completion and error handling:: -* Autodoc and friends:: -* Seeing is believing:: -* Customization and tips:: - -Between the parens - -* Activating Geiser:: -* The source and the REPL:: -* Documentation helpers:: -* To eval or not to eval:: -* To err perchance to debug:: -* Jumping around:: -* Geiser writes for you:: - -Cheat sheet - -* Scheme buffers:: -* REPL:: -* Documentation browser:: - - - Geiser is a collection of Emacs major and minor modes that conspire -with one or more Scheme interpreters to keep the Lisp Machine Spirit -alive. It draws inspiration (and a bit more) from environments such as -Common Lisp's Slime, Factor's FUEL, Squeak or Emacs itself, and does its -best to make Scheme hacking inside Emacs (even more) fun. - - Or, to be precise, what i (https://jao.io) consider fun. Geiser is -thus my humble contribution to the dynamic school of expression, and a -reaction against what i perceive as a derailment, in modern times, of -standard Scheme towards the static camp. Because i prefer growing and -healing to poking at corpses, the continuously running Scheme -interpreter takes the center of the stage in Geiser. A bundle of Elisp -shims orchestrates the dialog between the Scheme interpreter, Emacs and, -ultimately, the schemer, giving her access to live metadata. Here's -how. - - -File: geiser.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top - -1 Introduction -************** - -Geiser is an Emacs environment to hack and have fun in Scheme. If -that's enough for you, see *note Installation:: to get it running and -*note The REPL:: for the fun part. - -* Menu: - -* Modus operandi:: -* Showing off:: - - -File: geiser.info, Node: Modus operandi, Next: Showing off, Prev: Introduction, Up: Introduction - -1.1 Modus operandi -================== - -As already mentioned, Geiser relies on a running Scheme process to -obtain the information it makes accessible to the programmer. There's -little effort, on the Elisp side, to understand, say, the module system -used by the Scheme implementation at hand; instead, a generic interface -between the two worlds is defined, and each supported Scheme includes a -library implementing that API, together with some wee shims in Elisp -allowing the reuse of the Emacs-side framework, which constitutes the -bulk of the code. - - While being as generic as possible, the Scheme-Elisp interface makes -some assumptions about the capabilities and interaction mode of the -corresponding REPL. In particular, Geiser expects the latter to support -namespaces in the form of a module system, and to provide a well-defined -way to establish the REPL's current namespace (or module), as well as -the current file's module (or namespace). Thus, all evaluations -performed by Geiser either in the REPL or in a source code buffer happen -in the context of the current namespace. Every time you switch to a -different file, you're switching namespaces automatically; at the REPL, -you must request the switch explicitly (usually just using means -provided by the Scheme implementation itself). - - If your favourite Scheme supports the above modus operandi, it has -all that's needed for a bare-bones Geiser mode. But Geiser can, and -will, use any metadata available: procedure arities and argument lists -to display interactive help, documentation strings, location information -to jump to definitions, export lists to provide completion, and so on -and so forth. Although this is not an all-or-none proposition (Geiser -can operate with just part of that functionality available), i initially -concentrated in supporting those Schemes with the richest (to my -knowledge) introspection capabilities, namely, Guile and Racket. Later -on, Dan Leslie added support for Chicken, and there's active work to add -support for scsh. - - -File: geiser.info, Node: Showing off, Prev: Modus operandi, Up: Introduction - -1.2 Showing off -=============== - -When working with a fully conniving Scheme, Geiser can offer the -following functionality: - - * Form evaluation in the context of the current file's module. - * Macro expansion. - * File/module loading and/or compilation. - * Namespace-aware identifier completion (including local bindings, - names visible in the current module, and module names). - * Autodoc: the echo area shows information about the signature of the - procedure/macro around point automatically. - * Jump to definition of identifier at point. - * Access to documentation (including docstrings when the - implementation provides it). - * Listings of identifiers exported by a given module. - * Listings of callers/callees of procedures. - * Rudimentary support for debugging (when the REPL provides a - debugger) and error navigation. - * Support for multiple, simultaneous REPLs. - * Support for image display in those Schemes that treat them as first - class values. - - In the following pages, i'll try to explain what these features -actually are (i'm just swanking here), and how to use them for your -profit. But, before that, let's see how to install Geiser. - - -File: geiser.info, Node: Installation, Next: The REPL, Prev: Introduction, Up: Top - -2 Installation -************** - -* Menu: - -* Must needs:: -* The easy and quick way:: -* From the source's mouth:: -* Friends:: - - -File: geiser.info, Node: Must needs, Next: The easy and quick way, Prev: Installation, Up: Installation - -2.1 Must needs -============== - -If Geiser came with any guarantees, you'd break all of them by not using -GNU Emacs 24 (or better: i regularly use it with a recent Emacs -snapshot) and at least one of the supported Schemes, namely: - - * Guile (http://www.gnu.org/software/guile) 2.2 or better - * Chicken (http://call-cc.org) 4.8.0 or better - * MIT/GNU Scheme (https://www.gnu.org/software/mit-scheme/) 9.1 or - better - * Chibi Scheme (http://synthcode.com/scheme/chibi/) 0.7 or better - * Chez Scheme (http://www.scheme.com) 9.4 or better - * Gambit (http://gambitscheme.org/wiki/index.php/Main_Page) 4.9 or - better - * Racket (http://www.racket-lang.org) 6.0 or better - - Since Geiser supports multiple REPLs, having all of them will just -add to the fun. - - You'll also need Geiser itself. The quickest installation is via its -ELPA package, as described in the next section. If you prefer to use -the source code directly, it's not that difficult either: just keep on -reading. - - -File: geiser.info, Node: The easy and quick way, Next: From the source's mouth, Prev: Must needs, Up: Installation - -2.2 The easy and quick way -========================== - -Did i mention that the easiest way of installing Geiser is using its -ELPA (http://emacswiki.org/emacs/ELPA) package? If you're using Emacs -24, ELPA (http://emacswiki.org/emacs/ELPA) is already there; for earlier -versions, the page i just linked to twice will tell you where to find -the goodies. - - ELPA packages live in repositories accessible via HTTP. You can find -Geiser's package in either MELPA stable -(http://stable.melpa.org/#/geiser) or, if you like living on the -bleeding edge, MELPA (http://melpa.org/#/geiser) (directly from the git -repo). To tell Emacs that an ELPA repo exists, you add it to -'package-archives': - - (require 'package) - ;;; either the stable version: - - (add-to-list 'package-archives - ;; choose either the stable or the latest git version: - ;; '("melpa-stable" . "http://stable.melpa.org/packages/") - '("melpa-unstable" . "http://melpa.org/packages/")) - - (package-initialize) - - And then installing Geiser is as easy as: - - M-x package-install RET geiser RET - - Alternatively, you can manually download the package file -(http://download-mirror.savannah.gnu.org/releases/geiser/packages/geiser-0.11.tar), -and install from your local disk with 'M-x package-install-file'. - -Chicken installation -.................... - -If you plan to use Chicken, you'll need also to fire a terminal and -configure a couple of Chicken eggs. For Chicken 4 that would be: - $ chicken-install -s apropos chicken-doc - $ cd `csi -p '(chicken-home)'` - $ curl http://3e8.org/pub/chicken-doc/chicken-doc-repo.tgz | sudo tar zx - - while Chicken 5 prefers: - $ chicken-install -s apropos chicken-doc srfi-18 srfi-1 - $ cd `csi -R chicken.platform -p '(chicken-home)'` - $ curl https://3e8.org/pub/chicken-doc/chicken-doc-repo-5.tgz | sudo tar zx - - (see also Chicken's wiki (https://wiki.call-cc.org/emacs#geiser)). - - With that, you are pretty much all set up. See *note The REPL:: to -start using Geiser. - -Gambit installation -................... - -If you plan to use Gambit, you'll also need to open a terminal and -configure a couple of awesome Gambit's features: - - SETUP : 1 - clone the last version of gambit and of this repo 2 - -configure gambit using -enable-rtlib-debug-source to activate autodoc - $ cd ~/ - $ git clone "the gambit repo current address" - $ cd gambit - $ ./configure --enable-single-host --enable-debug --enable-rtlib-debug-source - $ make bootstrap - $ make bootclean - $ make -j - $ make install - 3 - put a link to geiser/elisp/geiser.el in your init file in your -init file paste : - (load-file "~/geiser/elisp/geiser.el") - (the path is your path to geiser.el.) - - # setup REMOTE CONNECT TO A GAMBIT REPL 1 - you need to enable the -gambit/geiser module ( if you can't, substitute the command below with -the PS: at the end of the readme ) - $ mkdir ~/gambit/lib/gambit/geiser - $ cp ~/geiser/geiser-module/* ~/gambit/lib/geiser/ - 2 - now that you have the module you start gsi with it and using the --:d - $ gsi -:d gambit/geiser - - 3 - you can now open emacs and write - M-x geiser-connect gambit - Enjoy ! - - By the way, if you are unable to use gambit modules, open gsi with -the 'gambit.scm' file located in -'geiser/scheme/gambit/geiser/gambit.scm' something like : - gsi -:d ~/geiser/scheme/gambit/geiser/gambit.scm - - (Keep in mind that these paths may be a little different for you.) - - -File: geiser.info, Node: From the source's mouth, Next: Friends, Prev: The easy and quick way, Up: Installation - -2.3 Installing from source -========================== - -Downloading Geiser -.................. - -The latest release tarballs can be found here -(https://gitlab.com/jaor/geiser/-/releases). - - If you feel like living on the bleeding edge, just grab Geiser from -its Git repository over at Savannah -(http://git.savannah.nongnu.org/cgit/geiser.git/), either with the -following incantation: - - git clone git://git.sv.gnu.org/geiser.git - -or, if you happen to live behind a firewall, with the alternative: - - git clone http://git.sv.gnu.org/r/geiser.git - -You can also follow Geiser's development in one -(https://gitlab.com/jaor/geiser) or (http://repo.or.cz/w/geiser.git) -three (http://gitorious.org/geiser) mirrors that are kept synchronized -with the one at Savannah. - - Either way, you'll now be in possession of a copy of Geiser's libre -code. I'll follow you into its directory and the next section. - -Setting it up -............. - -Geiser is ready to be used out of the box without much more ado. For -the sake of concreteness, let's assume you put its source in the -directory '~/lisp/geiser'. All you need to do is to add the following -line to your Emacs initialisation file (be it '~/.emacs', -'~/.emacs.d/init.el' or any of its moral equivalents): - - (load-file "~/lisp/geiser/elisp/geiser.el") - -or simply evaluate that form inside Emacs (you wouldn't kill a friend -just to start using Geiser, would you?). That's it: you're ready to go -(*note The REPL::). - - What? You still here? I promise the above is all that's needed to -start using Geiser. But, in case you are missing your configure/make -all install routine, by all means, you can go through those motions to -byte compile and install Geiser too. That is, you enter the source -directory and (since we grabbed the development tree) run the customary -autogen script: - - $ cd ~/lisp/geiser - $ ./autogen.sh - -I recommend that you compile Geiser in a separate directory: - - $ mkdir build && cd build - $ ../configure - <some drivel here> - $ make all - <more of the above> - - Now you have two options: loading the byte-compiled Geiser from the -'elisp' subdirectory, or installing it system-wide. To load the -byte-code from here, add this line to your initialisation file: - - (load "~/lisp/geiser/build/elisp/geiser-load") - -and eval that form and you're done (you could also restart Emacs, but -killing your friends is widely considered bad form). Yes, that's 'load' -and 'geiser-load' instead of 'load-file' and 'geiser.el'. - - If you prefer a system-wide installation, just type: - - $ sudo make install - - With the above spell, Geiser will be compiled and installed in a safe -place inside Emacs' load path. To load it into Emacs you'll need, -instead of the 'load-file' form above, the following line in your -initialisation file: - - (require 'geiser-install) - -Please note that we're requiring 'geiser-install', and not 'geiser', and -that there's no 'load-file' to be seen this time. There are some ways -of fine-tuning this process, mainly by providing additional arguments in -the call to configure: you'll find those gory details in the file called -'INSTALL', right at the root of the source tree. The installation will -also take care of placing this manual, in Info format, where Emacs can -find it, so you can continue to learn about Geiser inside its natural -habitat. See you there and into the next chapter! - - -File: geiser.info, Node: Friends, Prev: From the source's mouth, Up: Installation - -2.4 Friends -=========== - -Although Geiser does not need them, it plays well with (and is enhanced -by) the following Emacs packages: - - * Paredit (http://www.emacswiki.org/emacs/ParEdit). Regardless of - whether you use Geiser or not, you shouldn't be coding in any Lisp - dialect without the aid of Taylor Campbell's structured editing - mode. - * Company (http://company-mode.github.io/). Nikolaj Schumacher's and - Dmitry Gutov's 'company-mode' provides a generic front-end for - completion engines (such as Geiser's), with pretty and automatic - completion lists. - * ac-geiser (https://github.com/xiaohanyu/ac-geiser/) If you prefer - 'auto-complete-mode' to 'company-mode', Xiao Hanyu's 'ac-geiser', - which provides a Geiser plugin for the popular Emacs Auto - Completion Mode (https://www.emacswiki.org/emacs/AutoComplete), is - the package for you. Like Geiser, 'ac-geiser' is available in - MELPA, and also as an 'el-get' package. - -You just need to install and setup them as usual, for every package's -definition of usual. Geiser will notice their presence and react -accordingly. - - -File: geiser.info, Node: The REPL, Next: Between the parens, Prev: Installation, Up: Top - -3 The REPL -********** - -If you've followed the instructions in *note Installation::, your Emacs -is now ready to start playing. Otherwise, i'll wait for you: when -you're ready, just come back here and proceed to the following sections. - -* Menu: - -* Starting the REPL:: -* First aids:: -* Switching context:: -* Completion and error handling:: -* Autodoc and friends:: -* Seeing is believing:: -* Customization and tips:: - - -File: geiser.info, Node: Starting the REPL, Next: First aids, Prev: The REPL, Up: The REPL - -3.1 Starting the REPL -===================== - -To start a Scheme REPL (meaning, a Scheme process offering you a -Read-Eval-Print Loop), Geiser provides the generic interactive command -'run-geiser'. If you invoke it (via, as is customary in Emacs, 'M-x -run-geiser'), you'll be saluted by a prompt asking which one of the -supported implementations you want to launch--yes, you can stop the -asking, see *note below: active-implementations. Tabbing for completion -will offer you, as of this writing, 'guile', 'racket', 'chicken', 'mit', -'chibi' and 'chez'. Just choose your poison, and a new REPL buffer will -pop up (by default, the REPL will appear in a new window: if that annoys -you, just set 'geiser-repl-use-other-window' to 'nil' and the current -window will be used). - - If all went according to plan, you'll be facing an -implementation-dependent banner, followed by an interactive prompt. -Going according to plan includes having the executable of the Scheme you -chose in your path. If that's not the case, you can tell Emacs where it -is, as described in *note a moment: impl-binary. Returning to our REPL, -the first thing to notice is that the funny prompt is telling you your -current module: its name is the part just after the @ sign (in Guile, -that means 'guile-user', while Racket's and Chicken's top namespaces -don't have a name; cf. discussion in *note Switching context::). Other -than that, this is pretty much equivalent to having a command-line -interpreter in a terminal, with a bunch of add-ons that we'll be -reviewing below. You can start typing sexps right there: Geiser will -only dispatch them for evaluation when they're complete, and will indent -new lines properly until then. It will also keep track of your input, -maintaining a history file that will be reloaded whenever you restart -the REPL. - - If you're not happy with the faces Geiser is using for the REPL's -prompt and evaluated input, you can customise -'geiser-font-lock-repl-prompt' and 'geiser-font-lock-repl-input' to -better-looking faces. - -Connecting to an external Scheme -................................ - -There's an alternative way of starting a Geiser REPL: you can connect to -an external Scheme process, provided it's running a REPL server at some -known port. How to make that happen depends on the Scheme -implementation. - - If you use Guile, you just need to start your Guile process (possibly -outside Emacs) passing to it the flag '--listen'. This flag accepts an -optional port as argument (as in '--listen=1969'), if you don't want to -use the default. - - In Racket, you have to use the REPL server that comes with Geiser. -To that end, put Geiser's Racket 'scheme' directory in Racket's -collection search path and invoke 'start-geiser' (a procedure in the -module 'geiser/server') somewhere in your program, passing it the -desired port and, if desired, network interface name. This procedure -will start the REPL server in a separate thread. For an example of how -to do that, see the script 'bin/geiser-racket.sh' in the source -distribution, or, if you've compiled Geiser, 'bin/geiser-racket-noinst' -in the build directory, or, if you've installed Geiser, 'geiser-racket' -in '<installation-prefix>/bin'. These scripts start a new interactive -Racket that is also running a REPL server (they also load the errortrace -library to provide better diagnostics, but that's not strictly needed). - - With your external Scheme process running and serving, come back to -Emacs and execute 'M-x geiser-connect', 'M-x connect-to-guile' or 'M-x -connect-to-racket'. You'll be asked for a host and a port, and, voila, -you'll have a Geiser REPL that is served by the remote Scheme process in -a dedicated thread, meaning that your external program can go on doing -whatever it was doing while you tinker with it from Emacs. Note, -however, that all Scheme threads share the heap, so that you'll be able -to interact with those other threads in the running Scheme from Emacs in -a variety of ways. For starters, all your (re)definitions will be -visible everywhere. That's dangerous, but will come in handy when you -need to debug your running web server. - - The connection between Emacs and the Scheme process goes over TCP, so -it can be as remote as you need, perhaps with the intervention of an SSH -tunnel. - - -File: geiser.info, Node: First aids, Next: Switching context, Prev: Starting the REPL, Up: The REPL - -3.2 First aids -============== - -A quick way of seeing what else Geiser's REPL can do for you, is to -display the corresponding entry up there in your menu bar. No, i don't -normally use menus either; but they can come in handy until you've -memorized Geiser's commands, as a learning device. And yes, i usually -run Emacs inside a terminal, but one can always use La Carte -(http://www.emacswiki.org/emacs/LaCarte) to access the menus in a -convenient enough fashion. - - Or just press 'C-h m' and be done with that. - - Among the commands at your disposal, we find the familiar input -navigation keys, with a couple twists. By default, 'M-p' and 'M-n' are -bound to matching items in your input history. That is, they'll find -the previous or next sexp that starts with the current input prefix -(defined as the text between the end of the prompt and your current -position, a.k.a. "point", in the buffer). For going up and down the -list unconditionally, just use 'C-c M-p' and 'C-c M-n'. In addition, -navigation is sexp-based rather than line-based. - - There are also a few commands to twiddle with the Scheme process. -'C-c C-q' will gently ask it to quit, while 'C-u C-c C-q' will -mercilessly kill the process (but not before stowing your history in the -file system). Unless you're using a remote REPL, that is, in which case -both commands will just sever the connection and leave the remote -process alone. If worse comes to worst and the process is dead, 'C-c -C-z' will restart it. However, the same shortcut, issued when the REPL -is alive, will bring you back to the buffer you came from, as explained -in *note this section: switching-repl-buff. - - The remaining commands are meatier, and deserve sections of their -own. - - -File: geiser.info, Node: Switching context, Next: Completion and error handling, Prev: First aids, Up: The REPL - -3.3 Switching context -===================== - -In tune with Geiser's modus operandi, evaluations in the REPL take place -in the namespace of the current module. As noted above, the REPL's -prompt tells you the name of the current module. To switch to a -different one, you can use the command 'switch-to-geiser-module', bound -to 'C-c C-m'. You'll notice that Geiser simply uses a couple of -meta-commands provided by the Scheme REPL (the stock ',m' in Guile and -Chicken and the (geiser-defined) ',enter' in Racket), and that it -doesn't even try to hide that fact. That means that you can freely use -said native ways directly at the REPL, and Geiser will be happy to -oblige. In Racket, ',enter' works like Racket's standard 'enter!' form, -but you can also provide a path string as its argument (e.g., ',enter -"/tmp/foo.rkt"' is equivalent to ',enter (file "/tmp/foo.rkt")'). Like -'enter!', ',enter' accepts also module names (as in, say, ',enter -geiser/main'). As mentioned, in Guile and Chicken, ',m' is used as is. - - Once you enter a new module, only those bindings visible in its -namespace will be available to your evaluations. All Schemes supported -by Geiser provide a way to import new modules in the current namespace. -Again, there's a Geiser command, 'geiser-repl-import-module', to invoke -such functionality, bound this time to 'C-c C-i'. And, again, you'll -see Geiser just introducing the native incantation for you, and you're -free to use such incantations by hand whenever you want. - - One convenience provided by these two Geiser commands is that -completion is available when introducing the new module name, using the -'<TAB>' key. Pressing it at the command's prompt will offer you a -prefix-aware list of available module names. - - Which brings me to the next group of REPL commands. - - -File: geiser.info, Node: Completion and error handling, Next: Autodoc and friends, Prev: Switching context, Up: The REPL - -3.4 Completion and error handling -================================= - -We've already seen Geiser completion of module names in action at the -minibuffer. You won't be surprised to know that it's also available at -the REPL buffer itself. There, you can use either 'C-.' or 'M-`' to -complete module names, and '<TAB>' or 'M-<TAB>' to complete identifiers. -Geiser will know what identifiers are bound in the current module and -show you a list of those starting with the prefix at point. Needless to -say, this is not a static list, and it will grow as you define or import -new bindings in the namespace at hand. If no completion is found, -'<TAB>' will try to complete the prefix after point as a module name. - - REPL buffers use Emacs' compilation mode to highlight errors reported -by the Scheme interpreter, and you can use the 'next-error' command -('M-g n') to jump to their location. By default, every time you enter a -new expression for evaluation old error messages are forgotten, so that -'M-g n' will always jump to errors related to the last evaluation -request, if any. If you prefer a not-so-forgetful REPL, set the -customization variable 'geiser-repl-forget-old-errors-p' to 'nil'. -Note, however, that even when that variable is left as 't', you can -always jump to an old error by moving to its line at the REPL and -pressing '<RET>'. When your cursor is away from the last prompt, -'<TAB>' will move to the next error in the buffer, and you can use -'<BACKTAB>' everywhere to go to the previous one. - -Caveat about completion & the REPL ----------------------------------- - -It is possible for Geiser to hang your Emacs process when trying to -complete symbols. This can happen in the REPL itself or even in a -Scheme buffer that is attached to the REPL process. If this happens, -you've probably entered a module that changes the REPL prompt from what -Geiser was expecting to see. - - Unfortunately, there's no general solution for this issue right now -(as it is a daunting task to try to make a regexp that can encompass all -possible REPL prompts). The best solution for now is to fix this issue -on a case-by-case basis by adjusting your prompt regexp variable so that -it matches the default prompt as well as your Scheme module's special -prompt. - - For example, XREPL is a Racket module that implements a better Racket -REPL. You might be interested in toying around with some of its -functions, but when you try to enter XREPL via, say, 'C-c C-m xrepl', -you'll notice that the REPL prompt has changed to something like this: - - <pkgs>/xrepl-lib/xrepl/main> - - If you start typing symbols, and then you try to auto-complete those -symbols, your Emacs process may hang. This is because Geiser expects -the REPL prompt to match this regexp (for Racket): - - "\\(mzscheme\\|racket\\)@[^ ]*> " - - Therefore, we can fix this issue by changing our default prompt -regexp like so: - - (setq geiser-racket--prompt-regexp "<pkgs>.*> \\|\\(mzscheme\\|racket\\)@[^ ]*> ") - - Note that you may have to run 'M-x geiser-reload' after setting this -variable so that your changes will take effect. - - Again, you'll have to change the regexp to fit every prompt that -causes this issue, but the only alternative (that we can think of right -now) is to create a regexp that will match every possible prompt. -Obviously, that is going to be more than a little tricky. However, if -you have a better solution than that, please share it with the Geiser -developers; we'll be more than happy to hear it. - - -File: geiser.info, Node: Autodoc and friends, Next: Seeing is believing, Prev: Completion and error handling, Up: The REPL - -3.5 Autodoc and friends -======================= - -Oftentimes, there's more you'll want to know about an identifier besides -its name: What module does it belong to? Is it a procedure and, if so, -what arguments does it take? Geiser tries to help you answering those -questions too. - - Actually, if you've been playing with the REPL as you read, you might -have notice some frantic activity taking place in the echo area every -now and then. That was Geiser trying to be helpful (while, hopefully, -not being clippy), or, more concretely, what i call, for want of a -better name, its "autodoc" mode. Whenever it's active (did you notice -that A in the mode-line?), Geiser's gerbils will be scanning what you -type and showing (unless you silence them with 'C-c C-d C-a') -information about the identifier nearest to point. - - If that identifier corresponds to a variable visible in the current -namespace, you'll see the module it belongs to and its value. For -procedures and macros, autodoc will display, instead of their value, the -argument names (or an underscore if Geiser cannot determine the name -used in the definition). Optional arguments are surrounded by -parentheses. When the optional argument has a default value, it's -represented by a list made up of its name and that value. When the -argument is a keyword argument, its name has "#:" as a prefix. - - If that's not enough documentation for you, 'C-c C-d d' will open a -separate documentation buffer with help on the symbol at point. This -buffer will contain implementation-specific information about the -identifier (e.g., its docstring for Guile, or its contract, if any, for -Racket), and a handy button to open the corresponding manual entry for -the symbol, which will open an HTML page (for Racket and Chicken) or the -texinfo manual (for Guile). If you'd rather go directly to the manual, -try 'C-c C-d i', which invokes 'geiser-doc-look-up-manual' as the handy -button does. - - Geiser can also produce for you a list, classified by kind, of the -identifiers exported by a given module: all you need to do is press 'C-c -C-d m', and type or complete the desired module's name. - - The list of exported bindings is shown, again, in a buffer belonging -to Geiser's documentation browser, where you have at your disposal a -bunch of navigation commands listed in *note our cheat-sheet: -Documentation browser. - - We'll have a bit more to say about the documentation browser in *note -a later section: doc-browser. - - If that's still not enough, Geiser can jump, via 'M-.', to the -symbol's definition. A buffer with the corresponding file will pop up, -with its point resting upon the identifier's defining form. When you're -done inspecting, 'M-,' will bring you back to where you were. As we -will see, these commands are also available in Scheme buffers. 'M-.' -also works for modules: if your point is on an unambiguous module name, -the file where it's defined will be opened for you. - - -File: geiser.info, Node: Seeing is believing, Next: Customization and tips, Prev: Autodoc and friends, Up: The REPL - -3.6 Seeing is believing -======================= - -In schemes that support images as values (currently, that means Racket), -the REPL will display them inline if you're using them in a -graphics-aware Emacs. - - For the terminal, images will appear as buttons: press return on them -to invoke an external viewer (configurable via 'geiser-image-viewer') -that will show you the image at hand. You can also ask for the same -behaviour on all emacsen by customising 'geiser-repl-inline-images-p' to -'nil'. - - Geiser keeps a cache of the last displayed images in the directory -'geiser-image-cache-dir', which defaults to the system's temp directory, -with up to 'geiser-image-cache-keep-last' files. You can invoke the -external image viewer on any of them with 'M-x geiser-view-last-image', -which takes a prefix argument to indicate which image number you want, 0 -corresponding to the newest one. - - -File: geiser.info, Node: Customization and tips, Prev: Seeing is believing, Up: The REPL - -3.7 Customization and tips -========================== - -The looks and ways of the REPL can be fine-tuned via a bunch of -customization variables. You can see and modify them all in the -corresponding customization group (by using the menu entry or the good -old 'M-x customize-group geiser-repl'), or by setting them in your Emacs -initialisation files (as a rule, all knobs in Geiser are tunable this -way: you don't need to use customization buffers if you don't like -them). - - I'm documenting below a proper subset of those settings, together -with some related tips. - -Choosing a Scheme implementation -................................ - -Instead of using the generic 'run-geiser' command, you can directly -start your Scheme of choice using any of the following commands: - * 'run-racket' - * 'run-guile' - * 'run-chicken' - * 'run-mit' - * 'run-chibi' - * 'run-chez' - In addition, the variable 'geiser-active-implementations' contains a -list of those Schemes Geiser should be aware of. Thus, if you happen to -be, say, a racketeer not to be beguiled by other schemes, you can tell -Geiser to forget about the richness of the Scheme ecosystem with -something like: - - (setq geiser-active-implementations '(racket)) - -in your initialisation files. - - When starting a new REPL, Geiser assumes, by default, that the -corresponding Scheme binary is in your path. If that's not the case, -the variables to tweak are (depending on which Scheme you choose): - * 'geiser-guile-binary' - * 'geiser-racket-binary' - * 'geiser-chicken-binary' - * 'geiser-mit-binary' - * 'geiser-chibi-binary' - * 'geiser-chez-binary' - They should be set to a string with the full path to the requisite -binary. - - Before starting the REPL, Geiser will check wether the version of -your Scheme interpreter is good enough. This means that it will spend a -couple tenths of a second launching and quickly discarding a Scheme -process, but also that the error message you'll get if you're on the -wrong Scheme version will be much more informative. If you one to avoid -version checks, just check 'geiser-repl-skip-version-check-p' to 't' in -your configuration. - - You can also specify a couple more initialisation parameters. For -Guile, 'geiser-guile-load-path' is a list of paths to add to its load -path (and its compiled load path) when it's started, while -'geiser-guile-init-file' is the path to an initialisation file to be -loaded on start-up. The equivalent variables for Racket are -'geiser-racket-collects' and 'geiser-racket-init-file'. - - Note, however, that specifying 'geiser-guile-init-file' is not -equivalent to changing Guile's initialization file ('~/.guile'), because -the former is loaded using the '-l' flag, together with '-q' to disable -loading the second. But there are subtle differences in the way Guile -loads the initialization file versus how it loads a file specified via -the '-l' flag. If what you want is just loading '~/.guile', leave -'geiser-guile-init-file' alone and set 'geiser-guile-load-init-file-p' -to 't' instead. - - These variables controlling your scheme's initialisation process are -good candidates for an entry in a project's '.dir-locals.el' file, so -that they are automatically set to a sensible value whenever you start a -REPL in the project's directory. - -Racket startup time -................... - -When starting Racket in little computers, Geiser might have to wait a -bit more than it expects (which is ten seconds, or ten thousand -milliseconds, by default). If you find that Geiser is giving up too -quickly and complaining that no prompt was found, try to increase the -value of 'geiser-repl-startup-time' to, say, twenty seconds: - - (setq geiser-repl-startup-time 20000) - -If you prefer, you can use the customize interface to, well, customise -the above variable's value. - -History -....... - -By default, Geiser won't record duplicates in your input history. If -you prefer it did, just set 'geiser-repl-history-no-dups-p' to 'nil'. -History entries are persistent across REPL sessions: they're saved in -implementation-specific files whose location is controlled by the -variable 'geiser-repl-history-filename'. For example, my Geiser -configuration includes the following line: - - (setq geiser-repl-history-filename "~/.emacs.d/geiser-history") - -which makes the files 'geiser-history.guile' and 'geiser-history.racket' -to live inside my home's '.emacs.d' directory. - -Autodoc -....... - -If you happen to love peace and quiet and prefer to keep your REPL's -echo area free from autodoc's noise, 'geiser-repl-autodoc-p' is the -customization variable for you: set it to 'nil' and autodoc will be -disabled by default in new REPLs. You can always bring the fairies -back, on a per-REPL basis, using 'C-c C-d C-a'. - -Remote connections -.................. - -When using any of the connection commands (e.g. 'geiser-connect', -'connect-to-guile', 'connect-to-racket', etc.) you'll be prompted for a -host and a port, defaulting to "localhost" and 37146. You can change -those defaults customizing 'geiser-repl-default-host' and -'geiser-repl-default-port', respectively. - -Killing REPLs -............. - -If you don't want Emacs to ask for confirmation when you're about to -kill a live REPL buffer (as will happen, for instance, if you're exiting -Emacs before closing all your REPLs), you can set the flag -'geiser-repl-query-on-kill-p' to 'nil'. On a related note, the -customizable variable 'geiser-repl-query-on-exit-p' controls whether -Geiser should ask for confirmation when you exit the REPL explicitly -(via, say, 'C-c C-q', as opposed to killing the buffer), and is set to -'nil' by default. - - -File: geiser.info, Node: Between the parens, Next: Cheat sheet, Prev: The REPL, Up: Top - -4 Between the parens -******************** - -A good REPL is a must, but just about half the story of a good Scheme -hacking environment. Well, perhaps a bit more than a half; but, at any -rate, one surely needs also a pleasant way of editing source code. -Don't pay attention to naysayers: Emacs comes with an excellent editor -included for about any language on Earth, and just the best one when -that language is sexpy (especially if you use Paredit). Geiser's -support for writing Scheme code adds to Emacs' 'scheme-mode', rather -than supplanting it; and it does so by means of a minor mode -(unimaginatively dubbed 'geiser-mode') that defines a bunch of new -commands to try and, with the help of the same Scheme process giving you -the REPL, make those Scheme buffers come to life. - -* Menu: - -* Activating Geiser:: -* The source and the REPL:: -* Documentation helpers:: -* To eval or not to eval:: -* To err perchance to debug:: -* Jumping around:: -* Geiser writes for you:: - - -File: geiser.info, Node: Activating Geiser, Next: The source and the REPL, Prev: Between the parens, Up: Between the parens - -4.1 Activating Geiser -===================== - -With Geiser installed following any of the procedures described in *note -The easy and quick way:: or *note From the source's mouth::, Emacs will -automatically activate geiser-mode when opening a Scheme buffer. Geiser -also instructs Emacs to consider files with the extension 'rkt' part of -the family, so that, in principle, there's nothing you need to do to -ensure that Geiser's extensions will be available, out of the box, when -you start editing Scheme code. - - Indications that everything is working according to plan include the -'Geiser' minor mode indicator in your mode-line and the appearance of a -new entry for Geiser in the menu bar. If, moreover, the mode-line -indicator is the name of a Scheme implementation, you're indeed in a -perfect world; otherwise, don't despair and keep on reading: i'll tell -you how to fix that in a moment. - - The menu provides a good synopsis of everything Geiser brings to the -party, including those keyboard shortcuts we Emacsers love. If you're -seeing the name of your favourite Scheme implementation in the -mode-line, have a running REPL and are comfortable with Emacs, you can -stop reading now and, instead, discover Geiser's joys by yourself. I've -tried to make Geiser as self-documenting as any self-respecting Emacs -package should be. If you follow this route, make sure to take a look -at Geiser's customization buffers ('M-x customize-group <RET> geiser'): -there's lot of fine-tuning available there. You might also want to take -a glance at the tables in *note our cheat sheet: Cheat sheet. - - Since geiser-mode is a minor mode, you can toggle it with 'M-x -geiser-mode', and control its activation in hooks with the functions -'turn-on-geiser-mode' and 'turn-off-geiser-mode'. If, for some reason i -cannot fathom, you prefer geiser-mode not to be active by default, -customizing 'geiser-mode-auto-p' to 'nil' will do the trick. - - And if you happen to use a funky extension for your Scheme files that -is not recognised as such by Emacs, just tell her about it with: - - (add-to-list 'auto-mode-alist '("\\.funky-extension\\'" . scheme-mode)) - - Now, geiser-mode is just a useless wretch unless there's a running -Scheme process backing it up. Meaning that virtually all the commands -it provides require a REPL up and running, preferably corresponding to -the correct Scheme implementation. In the following section, we'll see -how to make sure that that's actually the case. - - -File: geiser.info, Node: The source and the REPL, Next: Documentation helpers, Prev: Activating Geiser, Up: Between the parens - -4.2 The source and the REPL -=========================== - -As i've already mentioned a couple of times, geiser-mode needs a running -REPL to be operative. Thus, a common usage pattern will be for you to -first call 'run-geiser' (or one of its variants, e.g. 'run-guile'), and -then open some Scheme files; but there's nothing wrong in first opening -a couple Scheme buffers and then starting the REPL (you can even find it -more convenient, since pressing 'C-c C-z' in a Scheme buffer will start -the REPL for you). Since Geiser supports more than one Scheme -implementation, though, there's the problem of knowing which of them is -to be associated with each Scheme source file. Serviceable as it is, -geiser-mode will try to guess the correct implementation for you, -according to the algorithm described below. - -How Geiser associates a REPL to your Scheme buffer -.................................................. - -To determine what Scheme implementation corresponds to a given source -file, Geiser uses the following algorithm: - - 1. If the file-local variable 'geiser-scheme-implementation' is - defined, its value is used. A common way of setting buffer-local - variables is to put them in a comment near the beginning of the - file, surrounded by '-*-' marks, as in: - - ;; -*- geiser-scheme-implementation: guile -*- - - 2. If you've customized 'geiser-active-implementations' so that it's a - single-element list, that element is used as the chosen - implementation. - 3. The contents of the file is scanned for hints on its associated - implementation. For instance, files that contain a '#lang' - directive will be considered Racket source code, while those with a - 'define-module' form in them will be assigned to a Guile REPL. - 4. The current buffer's file name is checked against the rules given - in 'geiser-implementations-alist', and the first match is applied. - You can provide your own rules by customizing this variable, as - explained below. - 5. If we haven't been lucky this far and you have customized - 'geiser-default-implementation' to the name of a supported - implementation, we'll follow your lead. - 6. See? That's the problem of being a smart aleck: one's always - outsmarted by people around. At this point, geiser-mode will - humbly give up and ask you to explicitly choose the Scheme - implementation. - - As you can see in the list above, there are several ways to influence -Geiser's guessing by means of customizable variables. The most direct -(and most impoverishing) is probably limiting the active implementations -to a single one, while customizing 'geiser-implementations-alist' is the -most flexible (and, unsurprisingly, also the most complex). Here's the -default value for the latter variable: - - (((regexp "\\.scm$") guile) - ((regexp "\\.ss$") racket) - ((regexp "\\.rkt$") racket)) - -which describes the simple heuristic that files with '.scm' as extension -are by default associated to a Guile REPL while those ending in '.ss' or -'.rkt' correspond to Racket's implementation (with the caveat that these -rules are applied only if the previous heuristics have failed to detect -the correct implementation, and that they'll match only if the -corresponding implementation is active). You can add rules to -'geiser-implementations-alist' (or replace all of them) by customizing -it. Besides regular expressions, you can also use a directory name; for -instance, the following snippet: - - (eval-after-load "geiser-impl" - '(add-to-list 'geiser-implementations-alist - '((dir "/home/jao/prj/frob") guile))) - -will add a new rule that says that any file inside my -'/home/jao/prj/frob' directory (or, recursively, any of its children) is -to be assigned to Guile. Since rules are first matched, first served, -this new rule will take precedence over the default ones. - - A final tip: if you want Geiser to start automatically a REPL for you -if it notices that there's no one active when it enters geiser-mode, you -can customize 'geiser-mode-start-repl-p' to 't'. - -Switching between source files and the REPL -........................................... - -Once you have a working geiser-mode, you can switch from Scheme source -buffers to the REPL or 'C-c C-z'. Those shortcuts map to the -interactive command 'switch-to-geiser'. - - If you use a numeric prefix, as in 'C-u C-c C-z', besides being -teleported to the REPL, the latter will switch to the namespace of the -Scheme source file, as if you had used 'C-c C-m' in the REPL, with the -source file's module as argument; cf. discussion in *note Switching -context::. This command is also bound to 'C-c C-a'. - - Once you're in the REPL, the same 'C-c C-z' shortcut will bring you -back to the buffer you jumped from, provided you don't kill the Scheme -process in between. This is why the command is called switch-to-geiser -instead of switch-to-repl, and what makes it really handy, if you ask -me. - - If for some reason you're not happy with the Scheme implementation -that Geiser has assigned to your file, you can change it with 'C-c C-s', -and you probably should take a look at the previous subsection to make -sure that Geiser doesn't get confused again. - -A note about context -.................... - -As explained before (*note Modus operandi::), all Geiser activities take -place in the context of the current namespace, which, for Scheme -buffers, corresponds to the module that the Scheme implementation -associates to the source file at hand (for instance, in Racket, there's -a one-to-one correspondence between paths and modules, while Guile -relies on explicit 'define-module' forms in the source file). - - Now that we have 'geiser-mode' happily alive in our Scheme buffers -and communicating with the right REPL instance, let us see what it can -do for us, besides jumping to and fro. - - -File: geiser.info, Node: Documentation helpers, Next: To eval or not to eval, Prev: The source and the REPL, Up: Between the parens - -4.3 Documentation helpers -========================= - -Autodoc redux -............. - -The first thing you will notice by moving around Scheme source is that, -every now and then, the echo area lights up with the same autodoc -messages we know and love from our REPL forays. This happens every time -the Scheme process is able to recognise an identifier in the buffer, and -provide information either on its value (for variables) or on its arity -and the name of its formal arguments (for procedures and macros). That -information will only be available if the module the identifier belongs -to has been loaded in the running Scheme image. So it can be the case -that, at first, no autodoc is shown for identifiers defined in the file -you're editing. But as soon as you evaluate them (either individually -or collectively using any of the devices described in *note To eval or -not to eval::) their signatures will start appearing in the echo area. - - Autodoc activation is controlled by a minor mode, 'geiser-autodoc', -which you can toggle with 'M-x geiser-autodoc-mode', or its associated -keyboard shortcut, 'C-c C-d a'. That /A indicator in the mode-line is -telling you that autodoc is active. If you prefer that it be inactive -by default (e.g., because you're connecting to a really remote scheme -and want to minimize network exchanges), just set -'geiser-mode-autodoc-p' to 'nil' in your customization files. Even when -autodoc mode is off, you can use 'geiser-autodoc-show', bound by default -to 'C-c C-d s', to show the autodoc string for the symbol at point. - - The way autodoc displays information deserves some explanation. It -will first show the name of the module where the identifier at hand is -defined, followed by a colon and the identifier itself. If the latter -corresponds to a procedure or macro, it will be followed by a list of -argument names, starting with the ones that are required. Then there -comes a list of optional arguments, if any, enclosed in parentheses. -When an optional argument has a default value (or a form defining its -default value), autodoc will display it after the argument name. When -the optional arguments are keywords, their names are prefixed with "#:" -(i.e., their names are keywords). An ellipsis (...) serves as a marker -of an indeterminate number of parameters, as is the case with rest -arguments or when autodoc cannot fathom the exact number of arguments -(this is often the case with macros defined using 'syntax-case'). -Another way in which autodoc displays its ignorance is by using an -underscore to display parameters whose name is beyond its powers. - - It can also be the case that a function or macro has more than one -signature (e.g., functions defined using 'case-lambda', or some -'syntax-rules' macros, for which Geiser has often the black magic -necessary to retrieve their actual arities). In those cases, autodoc -shows all known signatures (using the above rules for each one) -separated by a vertical bar (|). - - As you have already noticed, the whole autodoc message is enclosed in -parentheses. After all, we're talking about Scheme here. - - Finally, life is much easier when your cursor is on a symbol -corresponding to a plain variable: you'll see in the echo area its name, -preceded by the module where it's defined, and followed by its value, -with an intervening arrow for greater effect. This time, there are no -enclosing parentheses (i hope you see the logic in my madness). - - You can change the way Geiser displays the module/identifier combo by -customizing 'geiser-autodoc-identifier-format'. For example, if you -wanted a tilde surrounded by spaces instead of a colon as a separator, -you would write something like: - - (setq geiser-autodoc-identifier-format "%s ~ %s") - -in your Emacs initialisation files. There's also a face -('geiser-font-lock-autodoc-identifier') that you can customize (for -instance, with 'M-x customize-face') to change the appearance of the -text. And another one ('geiser-font-lock-autodoc-current-arg') that -controls how the current argument position is highlighted. - -Other documentation commands -............................ - -Sometimes, autodoc won't provide enough information for you to -understand what a function does. In those cases, you can ask Geiser to -ask the running Scheme for further information on a given identifier or -module. - - For symbols, the incantation is 'M-x geiser-doc-symbol-at-point', or -'C-c C-d C-d' for short. If the associated Scheme supports docstrings -(as, for instance, Guile does), you'll be teleported to a new Emacs -buffer displaying Geiser's documentation browser, filled with -information about the identifier, including its docstring (if any; -unfortunately, that an implementation supports docstrings doesn't mean -that they're used everywhere). - - Pressing 'q' in the documentation buffer will bring you back, -enlightened, to where you were. There's also a handful of other -navigation commands available in that buffer, which you can discover by -means of its menu or via the good old 'C-h m' command. And feel free to -use the navigation buttons and hyperlinks that justify my calling this -buffer a documentation browser. - - For Racket, which does not support docstrings out of the box, this -command will provide less information, but the documentation browser -will display the corresponding contract when it's available, as well as -some other tidbits for re-exported identifiers. - - You can also ask Geiser to display information about a module, in the -form of a list of its exported identifiers, using 'C-c C-d C-m', exactly -as you would do in *note the REPL: repl-mod. - - In both cases, the documentation browser will show a couple of -buttons giving you access to further documentation. First, you'll see a -button named source: pressing it you'll jump to the symbol's definition. -The second button, dubbed manual, will open the Scheme implementation's -manual page for the symbol at hand. For Racket, that will open your web -browser displaying the corresponding reference's page (using the HTML -browser in Racket's configuration, which you can edit in DrRacket's -preferences dialog, or by setting 'plt:framework-pref:external-browser' -directly in '~/.racket/racket-prefs.rktd'), while in Guile a lookup will -be performed in the texinfo manual. - - For Guile, the manual lookup uses the info indexes in the standard -Guile info nodes, which are usually named "guile" or "guile-2.0". If -yours are named differently, just add your name to the customizable -variable 'geiser-guile-manual-lookup-nodes'. - - A list of all navigation commands in the documentation browser is -available in *note our cheat-sheet: Documentation browser. - - You can also skip the documentation browser and jump directly to the -manual page for the symbol at point with the command -'geiser-doc-look-up-manual', bound to 'C-c C-d i'. - - -File: geiser.info, Node: To eval or not to eval, Next: To err perchance to debug, Prev: Documentation helpers, Up: Between the parens - -4.4 To eval or not to eval -========================== - -One of Geiser's main goals is to facilitate incremental development. -You might have noticed that i've made a big fuss of Geiser's ability to -recognize context, by being aware of the namespace where its operations -happen. - - That awareness is especially important when evaluating code in your -scheme buffers, using the commands described below. They allow you to -send code to the running Scheme with a granularity ranging from whole -files to single s-expressions. That code will be evaluated in the -module associated with the file you're editing, allowing you to redefine -values and procedures to your heart's (and other modules') content. - - Macros are, of course, another kettle of fish: one needs to -re-evaluate uses of a macro after redefining it. That's not a -limitation imposed by Geiser, but a consequence of how macros work in -Scheme (and other Lisps). There's also the risk that you lose track of -what's actually defined and what's not during a given session. But, in -my opinion -(http://jaortega.wordpress.com/2009/03/29/from-my-cold-prying-hands/index.html), -those are limitations we lispers are aware of, and they don't force us -to throw the baby with the bathwater and ditch incremental evaluation. -Some people disagree; if you happen to find their arguments -(http://blog.racket-lang.org/2009/03/drscheme-repl-isnt-lisp-the-one-in-emacs.html) -convincing, you don't have to throw away Geiser together with the baby: -'M-x geiser-restart-repl' will let you restart the REPL as many times as -you see fit. Moreover, you can invoke 'geiser-compile-current-buffer' -and 'geiser-load-current-buffer' with a prefix argument (that'd be -something like 'C-u C-c C-k' for compilation, for instance), to tell -Geiser to restart the REPL associated with a buffer before compiling or -loading its current contents. - - For all of you bearded old lispers still with me, here are some of -the commands performing incremental evaluation in Geiser. - - 'geiser-eval-last-sexp', bound to 'C-x C-e', will eval the -s-expression just before point. If you use a prefix, as in 'C-u C-x -C-e', besides evaluating it the expression is inserted in the the -buffer. - - 'geiser-eval-definition', bound to 'C-M-x', finds the topmost -definition containing point and sends it for evaluation. The variant -'geiser-eval-definition-and-go' ('C-c M-e') works in the same way, but -it also teleports you to REPL after the evaluation. - - 'geiser-eval-region', bound to 'C-c C-r', evals the current region. -Again, there's an and-go version available, 'geiser-eval-region-and-go', -bound to 'C-c M-r'. And, if you want to extend the evaluated region to -the whole buffer, there is 'geiser-eval-buffer', bound to 'C-c C-b' and -its companion 'geiser-eval-buffer-and-go', bound to 'C-c M-b'. - - For all the commands above, the result of the evaluation is displayed -in the minibuffer, unless it causes a (Scheme-side) error (*note To err -perchance to debug::), or, for schemes supporting them (such as Racket), -the evaluation yields an image, in which case you'll see it in popping -up in the Geiser debug buffer (if your Emacs runs under the auspices of -a graphical toolkit), or via an external viewer if you set program (see -also *note Seeing is believing:: for more on image support). - - At the risk of repeating myself, i'll remind you that all these -evaluations will take place in the namespace of the module corresponding -to the Scheme file from which you're sending your code, which, in -general, will be different from the REPL's current module. And, if all -goes according to plan, (re)defined variables and procedures should be -immediately visible inside and, if exported, outside their module. - - Besides evaluating expressions, definitions and regions, you can also -macro-expand them. The corresponding key bindings start with the prefix -'C-c C-m' and end, respectively, with 'C-e', 'C-x' and 'C-r'. The -result of the macro expansion always appears in a pop up buffer. - - -File: geiser.info, Node: To err perchance to debug, Next: Jumping around, Prev: To eval or not to eval, Up: Between the parens - -4.5 To err: perchance to debug -============================== - -When an error occurs during evaluation, it will be reported according to -the capabilities of the underlying Scheme REPL. - - In Racket, you'll be presented with a backtrace, in a new buffer -where file paths locating the origin of the error are click-able (you -can navigate them using the <TAB> key, and use <RET> or the mouse to -jump to the offending spot; or invoke Emacs' stock commands 'next-error' -and 'previous-error', bound to 'M-g n' and 'M-g p' by default). - - The Racket backtrace also highlights the exception type, making it -click-able. Following the link will open the documentation -corresponding to said exception type. Both the error and exception link -faces are customizable ('geiser-font-lock-error-link' and -'geiser-font-lock-doc-link'). - - By default, Geiser will tele-transport your pointer to the debug -buffer: if you prefer to stay in the source buffer, set -'geiser-debug-jump-to-debug-p' to nil. And if, in addition, you don't -even want to see the error trace, customize 'geiser-debug-show-debug-p', -again, to nil. - - On the other hand, Guile's reaction to evaluation errors is -different: it enters the debugger in its REPL. Accordingly, the REPL -buffer will pop up if your evaluation fails in a Guile file, and the -error message and backtrace will be displayed in there, again click-able -and all. But there you have the debugger at your disposal, with the -REPL's current module set to that of the offender, and a host of special -debugging commands that are described in Guile's fine documentation. - - In addition, Guile will sometimes report warnings for otherwise -successful evaluations. In those cases, it won't enter the debugger, -and Geiser will report the warnings in a debug buffer, as it does for -Racket. You can control how picky Guile is reporting warnings by -customizing the variable 'geiser-guile-warning-level', whose detailed -docstring (which see, using, e.g. 'C-h v') allows me to offer no -further explanation here. The customization group geiser-guile is also -worth a glance, for a couple of options to fine-tune how Geiser -interacts with Guile's debugger (and more). Same thing for racketeers -and geiser-racket. - - -File: geiser.info, Node: Jumping around, Next: Geiser writes for you, Prev: To err perchance to debug, Up: Between the parens - -4.6 Jumping around -================== - -This one feature is as sweet as it is easy to explain: 'M-.' -('geiser-edit-symbol-at-point') will open the file where the identifier -around point is defined and land your point on its definition. To -return to where you were, press 'M-,' ('geiser-pop-symbol-stack'). This -command works also for module names: Geiser first tries to locate a -definition for the identifier at point and, if that fails, a module with -that name; if the latter succeeds, the file where the module is defined -will pop up. - - Sometimes, the underlying Scheme will tell Geiser only the file where -the symbol is defined, but Geiser will use some heuristics (read, -regular expressions) to locate the exact line and bring you there. -Thus, if you find Geiser systematically missing your definitions, send a -message to the mailing list <geiser-users@nongnu.org>, and we'll try to -make the algorithm smarter. - - You can control how the destination buffer pops up by setting -'geiser-edit-symbol-method' to either 'nil' (to open the file in the -current window), ''window' (other window in the same frame) or ''frame' -(in a new frame). - - -File: geiser.info, Node: Geiser writes for you, Prev: Jumping around, Up: Between the parens - -4.7 Geiser writes for you -========================= - -No self-respecting programming mode would be complete without -completion. In geiser-mode, identifier completion is bound to -'M-<TAB>', and will offer all visible identifiers starting with the -prefix before point. Visible here means all symbols imported or defined -in the current namespace plus locally bound ones. E.g., if you're at -the end of the following partial expression: - - (let ((default 42)) - (frob def - -and press 'M-<TAB>', one of the possible completions will be 'default'. - - After obtaining the list of completions from the running Scheme, -Geiser uses the standard Emacs completion machinery to display them. -That means, among other things, that partial completion is available: -just try to complete 'd-s' or 'w-o-t-s' to see why this is a good thing. -Partial completion won't work if you have disabled it globally in your -Emacs configuration: if you don't know what i'm talking about, never -mind: Geiser's partial completion will work for you out of the box. - - If you find the 'M' modifier annoying, you always have the option to -activate 'geiser-smart-tab-mode', which will make the <TAB> key double -duty as the regular Emacs indentation command (when the cursor is not -near a symbol) and Geiser's completion function. If you want this -smarty pants mode always on in Scheme buffers, customize -'geiser-mode-smart-tab-p' to 't'. - - Geiser also knows how to complete module names: if no completion for -the prefix at point is found among the currently visible bindings, it -will try to find a module name that matches it. You can also request -explicitly completion only over module names using 'M-`' (that's a -backtick). - - Besides completion, there's also this little command, -'geiser-squarify', which will toggle the delimiters of the innermost -list around point between round and square brackets. It is bound to -'C-c C-e ['. With a numeric prefix (as in, say, 'M-2 C-c C-e ['), it -will perform that many toggles, forward for positive values and backward -for negative ones. - -Caveat about completion ------------------------ - -It is possible for Geiser to hang your Emacs process when trying to -complete symbols. This can happen in the REPL itself or even in a -Scheme buffer that is attached to the REPL process. For more details on -how to fix this problem, *note Caveat about completion & the REPL: -completion-caveat. - - -File: geiser.info, Node: Cheat sheet, Next: No hacker is an island, Prev: Between the parens, Up: Top - -5 Cheat sheet -************* - -In the tables below, triple chords always accept a variant with the -third key not modified by <Control>; e.g., 'geiser-autodoc-show' is -bound both to 'C-c C-d C-s' and 'C-c C-d s'. - -* Menu: - -* Scheme buffers:: -* REPL:: -* Documentation browser:: - - -File: geiser.info, Node: Scheme buffers, Next: REPL, Prev: Cheat sheet, Up: Cheat sheet - -5.1 Scheme buffers -================== - -Key Command Description ---------------------------------------------------------------------------- -C-c C-z 'geiser-mode-switch-to-repl' Switch to REPL -C-c C-a 'geiser-mode-switch-to-repl-and-enter'Switch to REPL and current - module (also 'C-u C-c C-z') -C-c C-s 'geiser-set-scheme' Specify Scheme - implementation for buffer -M-. 'geiser-edit-symbol-at-point' Go to definition of - identifier at point -M-, 'geiser-pop-symbol-stack' Go back to where M-. was - last invoked -C-c C-e C-m 'geiser-edit-module' Ask for a module and open - its file -C-c C-e C-l 'geiser-add-to-load-path' Ask for a directory and add - to Scheme load path -C-c C-e C-[ 'geiser-squarify' Toggle between () and [] - for current form -C-c C-\ 'geiser-insert-lambda' Insert greek lambda or, - with prefix, a lambda form -C-M-x 'geiser-eval-definition' Eval definition around - point -C-c C-c 'geiser-eval-definition' Eval definition around - point -C-c M-e 'geiser-eval-definition-and-go'Eval definition around - point and switch to REPL -C-c M-c 'geiser-eval-definition-and-go'Eval definition around - point and switch to REPL -C-x C-e 'geiser-eval-last-sexp' Eval sexp before point -C-c C-r 'geiser-eval-region' Eval region -C-c M-r 'geiser-eval-region-and-go' Eval region and switch to - REPL -C-c C-b 'geiser-eval-buffer' Eval buffer -C-c M-b 'geiser-eval-buffer-and-go' Eval buffer and switch to - REPL -C-c C-m C-x 'geiser-expand-definition' Macro-expand definition - around point -C-c C-m C-e 'geiser-expand-last-sexp' Macro-expand sexp before - point -C-c C-m C-r 'geiser-expand-region' Macro-expand region -C-c C-k 'geiser-compile-current-buffer'Compile and load current - file; with prefix, restart - REPL before -C-c C-l 'geiser-load-file' Load scheme file -M-g n, C-x ' 'next-error' Jump to the location of - next error -M-g p 'previous-error' Jump to the location of - previous error -C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for - identifier at point -C-c C-d C-s 'geiser-autodoc-show' Show signature or value for - identifier at point in echo - area -C-c C-d C-m 'geiser-doc-module' See a list of a module's - exported identifiers -C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol - at point -C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode -C-c < 'geiser-xref-callers' Show callers of procedure - at point -C-c > 'geiser-xref-callees' Show callees of procedure - at point -M-TAB 'completion-at-point' Complete identifier at - point -M-', C-. 'geiser-completion--complete-module'Complete module name at - point - - -File: geiser.info, Node: REPL, Next: Documentation browser, Prev: Scheme buffers, Up: Cheat sheet - -5.2 REPL -======== - -Key Command Description ---------------------------------------------------------------------------- -C-c C-z 'switch-to-geiser' Start Scheme REPL, or jump - to previous buffer -C-c M-o 'geiser-repl-clear-buffer' Clear REPL buffer -C-c C-k 'geiser-repl-interrupt' Interrupt REPL evaluation - (signalling inferior - scheme) -C-c C-q 'geiser-repl-exit' Kill Scheme process -M-. 'geiser-edit-symbol-at-point' Edit identifier at point -C-c C-l 'geiser-load-file' Load scheme file -TAB 'geiser-repl-tab-dwim' Complete, indent, or go to - next error -S-TAB 'geiser-repl--previous-error' Go to previous error in the -(backtab) REPL buffer -M-TAB 'completion-at-point' Complete indentifier at - point -M-', C-. 'geiser-completion--complete-module'Complete module name at - point -C-c [, C-c 'geiser-squarify' Toggle between () and [] -C-[ for current form -C-c \, C-c 'geiser-insert-lambda' Insert greek lambda or, -C-\ with prefix, a lambda form -C-c C-r 'geiser-add-to-load-path' Ask for a directory and add - to Scheme load path -M-p, M-n (comint commands) Prompt history, matching - current prefix -C-c M-p, C-c (comint commands) Previous/next prompt inputs -M-n -C-c C-m 'switch-to-geiser-module' Set current module -C-c C-i 'geiser-repl-import-module' Import module into current - namespace -C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for - symbol at point -C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol - at point -C-c C-d C-m 'geiser-repl--doc-module' See documentation for - module -C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode - - -File: geiser.info, Node: Documentation browser, Prev: REPL, Up: Cheat sheet - -5.3 Documentation browser -========================= - -Key Command Description ---------------------------------------------------------------------------- -TAB, n 'forward-button' Next link -S-TAB, p 'backward-button' Previous link -N 'geiser-doc-next-section' Next section -P 'geiser-doc-previous-section' Previous section -f 'geiser-doc-next' Next page -b 'geiser-doc-previous' Previous page -k 'geiser-doc-kill-page' Kill current page and go to - previous or next -g, r 'geiser-doc-refresh' Refresh page -c 'geiser-doc-clean-history' Clear browsing history -., M-. 'geiser-doc-edit-symbol-at-point'Edit identifier at point -z 'geiser-doc-switch-to-repl' Switch to REPL -q 'View-quit' Bury buffer - - -File: geiser.info, Node: No hacker is an island, Next: Index, Prev: Cheat sheet, Up: Top - -6 No hacker is an island -************************ - -Dan Leslie, with the help of his three-months old daughter Freija, -proved there's a smidgen of sense in this madness by adding support for -Chicken to version 0.7 of Geiser, several years after it was born. And -Peter Feigl reinforced that feeling soon afterwards with his work on -supporting GNU/MIT Scheme, Chib and Chez in one fell swoop. - - Andy Wingo, Geiser's first user, has been a continuous source of -encouragement and suggestions, and keeps improving Guile and heeding my -feature requests. - - The nice thing about collaborating with Andreas Rottmann over all -these years is that he will not only make your project better with -insightful comments and prodding: he'll send you patches galore too. - - Ludovic Courtès, #geiser's citizen no. 1, joined the fun after a -while, and has since then been a continuous source of encouragement, -ideas and bug reports. - - Michael Wilber convinced me that image support for Racket was not -only fun, but easy, with the best argument: actual code! - - Daniel Hackney and Grant Rettke created the first ELPA packages for -Geiser and taught me to fish. - - Diogo F. S. Ramos is Geiser's most indefatigable user and bug -reporter, and the mailing list has been a far less lonely place since he -came. - - Aleix Conchillo has been my favourite spammer, beta tester and patch -sender during more years and for more projects than i can remember. - - Eduardo Cavazos' contagious enthusiasm has helped in many ways to -keep Geiser alive, and he's become its best evangelist in R6RS circles. - - Alex Kost has contributed with many bug reports and improved Geiser -with several patches. - - Eli Barzilay took the time to play with an early alpha and made many -valuable suggestions, besides answering all my 'how do you in PLT' -questions. - - Matthew Flatt, Robby Findler and the rest of the PLT team did not -only answer my inquiries, but provided almost instant fixes to the few -issues i found. - - Thanks also to the PLT and Guile communities, for showing me that -Geiser was not only possible, but a pleasure to hack on. And to the -Slime hackers, who led the way. - -Joining the fun -............... - - * For questions, praise, critique and anything else Geiser, do not - hesitate to drop an email to our list, (@ geiser-users (. nongnu - org)) (mailto:geiser-users@nongnu.org): no subscription required. - Check the list page - (http://lists.nongnu.org/mailman/listinfo/geiser-users) for more - information or browse the archives - (http://lists.nongnu.org/archive/html/geiser-users/). The list is - also accessible via Gmane (http://gmane.org) as - gmane.lisp.scheme.geiser - (http://dir.gmane.org/gmane.lisp.scheme.geiser). - * You can submit bug reports either to the mailing list or to our bug - tracker (https://gitlab.com/jaor/geiser/issues) over at Gitlab. - * If you only need to hear about Geiser on new releases, the News - page (http://savannah.nongnu.org/news/?group=geiser) and its Atom - feed (https://savannah.nongnu.org/news/atom.php?group=geiser) are - probably what you're looking for. - * The Freenode IRC channel #geiser is the Geiserati's meeting point - in cyberspace. - - -File: geiser.info, Node: Index, Prev: No hacker is an island, Up: Top - -Index -***** - --* Menu: - -* ,enter vs. enter!: Switching context. (line 6) -* ac-geiser: Friends. (line 9) -* ask on kill, don't: Customization and tips. - (line 129) -* autocomplete: Friends. (line 9) -* autodoc customized: Documentation helpers. - (line 64) -* autodoc explained: Documentation helpers. - (line 32) -* autodoc for variables: Documentation helpers. - (line 58) -* autodoc, disabling: Customization and tips. - (line 111) -* autodoc, in scheme buffers: Documentation helpers. - (line 9) -* autodoc, in the REPL: Autodoc and friends. (line 11) -* autostart REPL: The source and the REPL. - (line 80) -* backtraces: To err perchance to debug. - (line 6) -* bug tracker: No hacker is an island. - (line 68) -* byte-compilation: From the source's mouth. - (line 46) -* Chicken: The easy and quick way. - (line 37) -* Chicken installation: The easy and quick way. - (line 37) -* company: Friends. (line 9) -* completion for module names: Geiser writes for you. - (line 33) -* completion in scheme buffers: Geiser writes for you. - (line 6) -* completion, at the REPL: Completion and error handling. - (line 6) -* connect to server: Starting the REPL. (line 43) -* corpses: Top. (line 79) -* current module: Modus operandi. (line 15) -* current module, change: Switching context. (line 21) -* current module, in REPL: Switching context. (line 6) -* derailment: Top. (line 79) -* disabling autodoc: Documentation helpers. - (line 22) -* docstrings, maybe: Documentation helpers. - (line 85) -* documentation for symbol: Documentation helpers. - (line 85) -* ELPA: The easy and quick way. - (line 6) -* error buffer: To err perchance to debug. - (line 9) -* evaluating images: To eval or not to eval. - (line 56) -* evaluation: To eval or not to eval. - (line 37) -* external image viewer: Seeing is believing. (line 10) -* faces, in the REPL: Starting the REPL. (line 35) -* Gambit: The easy and quick way. - (line 56) -* Gambit installation: The easy and quick way. - (line 56) -* geiser-mode: Activating Geiser. (line 6) -* geiser-mode commands: Activating Geiser. (line 21) -* gmane: No hacker is an island. - (line 58) -* Guile info nodes: Documentation helpers. - (line 120) -* Guile's REPL server: Starting the REPL. (line 48) -* GUILE_LOAD_COMPILED_PATH: Customization and tips. - (line 58) -* GUILE_LOAD_PATH: Customization and tips. - (line 58) -* help on identifier: Autodoc and friends. (line 29) -* host, default: Customization and tips. - (line 120) -* image cache: Seeing is believing. (line 16) -* image display: To eval or not to eval. - (line 56) -* image support: Seeing is believing. (line 6) -* image viewer: Seeing is believing. (line 10) -* incremental development: To eval or not to eval. - (line 6) -* incremental development, evil: To eval or not to eval. - (line 18) -* incremental development, not evil: To eval or not to eval. - (line 37) -* IRC channel: No hacker is an island. - (line 74) -* jump, at the REPL: Autodoc and friends. (line 51) -* jumping customized: Jumping around. (line 22) -* jumping in scheme buffers: Jumping around. (line 6) -* mailing list: No hacker is an island. - (line 58) -* manual autodoc: Documentation helpers. - (line 22) -* module exports: Autodoc and friends. (line 39) -* modus operandi: Modus operandi. (line 6) -* news feed: No hacker is an island. - (line 70) -* opening manual pages: Documentation helpers. - (line 128) -* paredit: Friends. (line 9) -* partial completion: Geiser writes for you. - (line 18) -* peace and quiet: Customization and tips. - (line 111) -* philosophy: Top. (line 79) -* philosophy <1>: To eval or not to eval. - (line 6) -* PLTCOLLECTS: Customization and tips. - (line 58) -* port, default: Customization and tips. - (line 120) -* quack: Friends. (line 9) -* quick install: The easy and quick way. - (line 6) -* Racket's REPL server: Starting the REPL. (line 53) -* recursion: Index. (line 6) -* remote connections: Starting the REPL. (line 78) -* remote REPL: Starting the REPL. (line 43) -* REPL: Starting the REPL. (line 6) -* REPL commands: First aids. (line 6) -* REPL customization: Customization and tips. - (line 6) -* REPL, faces: Starting the REPL. (line 35) -* scheme binary: Customization and tips. - (line 38) -* scheme executable path: Customization and tips. - (line 38) -* scheme file extensions: Activating Geiser. (line 38) -* scheme implementation, choosing: Customization and tips. - (line 20) -* scheme implementation, choosing <1>: The source and the REPL. - (line 21) -* scheme init file: Customization and tips. - (line 58) -* scheme load path: Customization and tips. - (line 58) -* smart tabs: Geiser writes for you. - (line 26) -* start REPL, automatically: The source and the REPL. - (line 80) -* startup timeout: Customization and tips. - (line 82) -* supported versions: Must needs. (line 6) -* swanking: Showing off. (line 6) -* switching schemes: The source and the REPL. - (line 103) -* switching to module: The source and the REPL. - (line 91) -* switching to REPL: The source and the REPL. - (line 87) -* switching to source: The source and the REPL. - (line 87) -* thanks: No hacker is an island. - (line 6) -* timeout: Customization and tips. - (line 82) -* to err is schemey: To err perchance to debug. - (line 6) -* use the source, Luke: From the source's mouth. - (line 9) -* useless wretch: Activating Geiser. (line 43) -* Version checking: Customization and tips. - (line 50) -* versions supported: Must needs. (line 6) - - - -Tag Table: -Node: Top895 -Node: Introduction3351 -Node: Modus operandi3685 -Ref: current-module4340 -Node: Showing off5813 -Node: Installation7091 -Node: Must needs7304 -Node: The easy and quick way8411 -Node: From the source's mouth12081 -Node: Friends15611 -Ref: paredit15885 -Node: The REPL16828 -Ref: quick-start16947 -Node: Starting the REPL17338 -Node: First aids21725 -Node: Switching context23558 -Node: Completion and error handling25483 -Ref: completion-caveat27191 -Node: Autodoc and friends29105 -Ref: repl-mod31175 -Node: Seeing is believing32181 -Node: Customization and tips33193 -Ref: choosing-impl33922 -Ref: active-implementations34157 -Ref: impl-binary34539 -Node: Between the parens38895 -Node: Activating Geiser39957 -Node: The source and the REPL42567 -Ref: repl-association43611 -Ref: switching-repl-buff46879 -Node: Documentation helpers48564 -Ref: doc-browser52832 -Node: To eval or not to eval55559 -Node: To err perchance to debug59708 -Node: Jumping around62070 -Node: Geiser writes for you63347 -Node: Cheat sheet65851 -Node: Scheme buffers66235 -Node: REPL70560 -Node: Documentation browser73154 -Node: No hacker is an island74222 -Node: Index77541 - -End Tag Table diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.bci b/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.bci Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.bin b/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.bin Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.com b/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.com Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.crf b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.crf @@ -1,115 +0,0 @@ -Free References: - ->environment - ("emacs") - append-map - ("emacs") - call-with-values - ("emacs") - compiled-entry/filename-and-index - ("emacs") - compiled-procedure? - ("emacs") - entity-procedure - ("emacs") - entity? - ("emacs") - environment->package - ("emacs") - environment-bindings - ("emacs") - environment-bound? - ("emacs") - environment-lookup - ("emacs") - environment-reference-type - ("emacs") - environment-safe-lookup - ("emacs") - eval - ("emacs") - filter - ("emacs") - find-package - ("emacs") - for-each-interned-symbol - ("emacs") - format - ("emacs") - ge - ("emacs") - get-output-string - ("emacs") - list - ("emacs") - list? - ("emacs") - load - ("emacs") - load-option - ("emacs") - map - ("emacs") - name->package - ("emacs") - nearest-repl - ("emacs") - object-hash - ("emacs") - open-output-string - ("emacs") - pa - ("emacs") - package/children - ("emacs") - package/environment - ("emacs") - package/name - ("emacs") - pp - ("emacs") - procedure? - ("emacs") - read - ("emacs") - reverse - ("emacs") - set-repl/prompt! - ("emacs") - sort - ("emacs") - string - ("emacs") - string-append - ("emacs") - string-length - ("emacs") - string-null? - ("emacs") - string-prefix-ci? - ("emacs") - string-prefix? - ("emacs") - string-suffix? - ("emacs") - string-trim - ("emacs") - string<? - ("emacs") - string? - ("emacs") - substring - ("emacs") - substring? - ("emacs") - symbol-name - ("emacs") - with-input-from-string - ("emacs") - with-output-to-port - ("emacs") - with-output-to-string - ("emacs") - write - ("emacs") - write-to-string - ("emacs") diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.fre b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.fre Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.pkd b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-unx.pkd Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.crf b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.crf @@ -1,115 +0,0 @@ -Free References: - ->environment - ("emacs") - append-map - ("emacs") - call-with-values - ("emacs") - compiled-entry/filename-and-index - ("emacs") - compiled-procedure? - ("emacs") - entity-procedure - ("emacs") - entity? - ("emacs") - environment->package - ("emacs") - environment-bindings - ("emacs") - environment-bound? - ("emacs") - environment-lookup - ("emacs") - environment-reference-type - ("emacs") - environment-safe-lookup - ("emacs") - eval - ("emacs") - filter - ("emacs") - find-package - ("emacs") - for-each-interned-symbol - ("emacs") - format - ("emacs") - ge - ("emacs") - get-output-string - ("emacs") - list - ("emacs") - list? - ("emacs") - load - ("emacs") - load-option - ("emacs") - map - ("emacs") - name->package - ("emacs") - nearest-repl - ("emacs") - object-hash - ("emacs") - open-output-string - ("emacs") - pa - ("emacs") - package/children - ("emacs") - package/environment - ("emacs") - package/name - ("emacs") - pp - ("emacs") - procedure? - ("emacs") - read - ("emacs") - reverse - ("emacs") - set-repl/prompt! - ("emacs") - sort - ("emacs") - string - ("emacs") - string-append - ("emacs") - string-length - ("emacs") - string-null? - ("emacs") - string-prefix-ci? - ("emacs") - string-prefix? - ("emacs") - string-suffix? - ("emacs") - string-trim - ("emacs") - string<? - ("emacs") - string? - ("emacs") - substring - ("emacs") - substring? - ("emacs") - symbol-name - ("emacs") - with-input-from-string - ("emacs") - with-output-to-port - ("emacs") - with-output-to-string - ("emacs") - write - ("emacs") - write-to-string - ("emacs") diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.fre b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.fre Binary files differ. diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.pkd b/elpa/geiser-20200214.110/scheme/mit/geiser/geiser-w32.pkd Binary files differ. diff --git a/elpa/geiser-20200214.110/web.info b/elpa/geiser-20200214.110/web.info @@ -1,1838 +0,0 @@ -This is web.info, produced by makeinfo version 6.5 from web.texi. - - -File: web.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) - -Geiser is a collection of Emacs major and minor modes that conspire with -one or more Scheme interpreters to keep the Lisp Machine Spirit alive. -It draws inspiration (and a bit more) from environments such as Common -Lisp's Slime, Factor's FUEL, Squeak or Emacs itself, and does its best -to make Scheme hacking inside Emacs (even more) fun. - - Or, to be precise, what i (https://jao.io) consider fun. Geiser is -thus my humble contribution to the dynamic school of expression, and a -reaction against what i perceive as a derailment, in modern times, of -standard Scheme towards the static camp. Because i prefer growing and -healing to poking at corpses, the continuously running Scheme -interpreter takes the center of the stage in Geiser. A bundle of Elisp -shims orchestrates the dialog between the Scheme interpreter, Emacs and, -ultimately, the schemer, giving her access to live metadata. Here's -how. - - Version 0.11 (February 2020) for Guile 2.2 Chicken 4.8.0 GNU/MIT 9.1 -Chez 9.4 Chibi 0.7 Gambit 4.9 and Racket 6.0 -(https://gitlab.com/jaor/geiser/-/releases) - -* Menu: - -* Introduction:: -* Installation:: -* The REPL:: -* Between the parens:: -* Cheat sheet:: -* No hacker is an island:: -* Index:: - - -File: web.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top - -1 Introduction -************** - -Geiser is an Emacs environment to hack and have fun in Scheme. If -that's enough for you, see *note Installation:: to get it running and -*note The REPL:: for the fun part. - -* Menu: - -* Modus operandi:: -* Showing off:: - - -File: web.info, Node: Modus operandi, Next: Showing off, Prev: Introduction, Up: Introduction - -1.1 Modus operandi -================== - -As already mentioned, Geiser relies on a running Scheme process to -obtain the information it makes accessible to the programmer. There's -little effort, on the Elisp side, to understand, say, the module system -used by the Scheme implementation at hand; instead, a generic interface -between the two worlds is defined, and each supported Scheme includes a -library implementing that API, together with some wee shims in Elisp -allowing the reuse of the Emacs-side framework, which constitutes the -bulk of the code. - - While being as generic as possible, the Scheme-Elisp interface makes -some assumptions about the capabilities and interaction mode of the -corresponding REPL. In particular, Geiser expects the latter to support -namespaces in the form of a module system, and to provide a well-defined -way to establish the REPL's current namespace (or module), as well as -the current file's module (or namespace). Thus, all evaluations -performed by Geiser either in the REPL or in a source code buffer happen -in the context of the current namespace. Every time you switch to a -different file, you're switching namespaces automatically; at the REPL, -you must request the switch explicitly (usually just using means -provided by the Scheme implementation itself). - - If your favourite Scheme supports the above modus operandi, it has -all that's needed for a bare-bones Geiser mode. But Geiser can, and -will, use any metadata available: procedure arities and argument lists -to display interactive help, documentation strings, location information -to jump to definitions, export lists to provide completion, and so on -and so forth. Although this is not an all-or-none proposition (Geiser -can operate with just part of that functionality available), i initially -concentrated in supporting those Schemes with the richest (to my -knowledge) introspection capabilities, namely, Guile and Racket. Later -on, Dan Leslie added support for Chicken, and there's active work to add -support for scsh. - - -File: web.info, Node: Showing off, Prev: Modus operandi, Up: Introduction - -1.2 Showing off -=============== - -When working with a fully conniving Scheme, Geiser can offer the -following functionality: - - * Form evaluation in the context of the current file's module. - * Macro expansion. - * File/module loading and/or compilation. - * Namespace-aware identifier completion (including local bindings, - names visible in the current module, and module names). - * Autodoc: the echo area shows information about the signature of the - procedure/macro around point automatically. - * Jump to definition of identifier at point. - * Access to documentation (including docstrings when the - implementation provides it). - * Listings of identifiers exported by a given module. - * Listings of callers/callees of procedures. - * Rudimentary support for debugging (when the REPL provides a - debugger) and error navigation. - * Support for multiple, simultaneous REPLs. - * Support for image display in those Schemes that treat them as first - class values. - - In the following pages, i'll try to explain what these features -actually are (i'm just swanking here), and how to use them for your -profit. But, before that, let's see how to install Geiser. - - -File: web.info, Node: Installation, Next: The REPL, Prev: Introduction, Up: Top - -2 Installation -************** - -* Menu: - -* Must needs:: -* The easy and quick way:: -* From the source's mouth:: -* Friends:: - - -File: web.info, Node: Must needs, Next: The easy and quick way, Prev: Installation, Up: Installation - -2.1 Must needs -============== - -If Geiser came with any guarantees, you'd break all of them by not using -GNU Emacs 24 (or better: i regularly use it with a recent Emacs -snapshot) and at least one of the supported Schemes, namely: - - * Guile (http://www.gnu.org/software/guile) 2.2 or better - * Chicken (http://call-cc.org) 4.8.0 or better - * MIT/GNU Scheme (https://www.gnu.org/software/mit-scheme/) 9.1 or - better - * Chibi Scheme (http://synthcode.com/scheme/chibi/) 0.7 or better - * Chez Scheme (http://www.scheme.com) 9.4 or better - * Gambit (http://gambitscheme.org/wiki/index.php/Main_Page) 4.9 or - better - * Racket (http://www.racket-lang.org) 6.0 or better - - Since Geiser supports multiple REPLs, having all of them will just -add to the fun. - - You'll also need Geiser itself. The quickest installation is via its -ELPA package, as described in the next section. If you prefer to use -the source code directly, it's not that difficult either: just keep on -reading. - - -File: web.info, Node: The easy and quick way, Next: From the source's mouth, Prev: Must needs, Up: Installation - -2.2 The easy and quick way -========================== - -Did i mention that the easiest way of installing Geiser is using its -ELPA (http://emacswiki.org/emacs/ELPA) package? If you're using Emacs -24, ELPA (http://emacswiki.org/emacs/ELPA) is already there; for earlier -versions, the page i just linked to twice will tell you where to find -the goodies. - - ELPA packages live in repositories accessible via HTTP. You can find -Geiser's package in either MELPA stable -(http://stable.melpa.org/#/geiser) or, if you like living on the -bleeding edge, MELPA (http://melpa.org/#/geiser) (directly from the git -repo). To tell Emacs that an ELPA repo exists, you add it to -'package-archives': - - (require 'package) - ;;; either the stable version: - - (add-to-list 'package-archives - ;; choose either the stable or the latest git version: - ;; '("melpa-stable" . "http://stable.melpa.org/packages/") - '("melpa-unstable" . "http://melpa.org/packages/")) - - (package-initialize) - - And then installing Geiser is as easy as: - - M-x package-install RET geiser RET - - Alternatively, you can manually download the package file -(http://download-mirror.savannah.gnu.org/releases/geiser/packages/geiser-0.11.tar), -and install from your local disk with 'M-x package-install-file'. - -Chicken installation -.................... - -If you plan to use Chicken, you'll need also to fire a terminal and -configure a couple of Chicken eggs. For Chicken 4 that would be: - $ chicken-install -s apropos chicken-doc - $ cd `csi -p '(chicken-home)'` - $ curl http://3e8.org/pub/chicken-doc/chicken-doc-repo.tgz | sudo tar zx - - while Chicken 5 prefers: - $ chicken-install -s apropos chicken-doc srfi-18 srfi-1 - $ cd `csi -R chicken.platform -p '(chicken-home)'` - $ curl https://3e8.org/pub/chicken-doc/chicken-doc-repo-5.tgz | sudo tar zx - - (see also Chicken's wiki (https://wiki.call-cc.org/emacs#geiser)). - - With that, you are pretty much all set up. See *note The REPL:: to -start using Geiser. - -Gambit installation -................... - -If you plan to use Gambit, you'll also need to open a terminal and -configure a couple of awesome Gambit's features: - - SETUP : 1 - clone the last version of gambit and of this repo 2 - -configure gambit using -enable-rtlib-debug-source to activate autodoc - $ cd ~/ - $ git clone "the gambit repo current address" - $ cd gambit - $ ./configure --enable-single-host --enable-debug --enable-rtlib-debug-source - $ make bootstrap - $ make bootclean - $ make -j - $ make install - 3 - put a link to geiser/elisp/geiser.el in your init file in your -init file paste : - (load-file "~/geiser/elisp/geiser.el") - (the path is your path to geiser.el.) - - # setup REMOTE CONNECT TO A GAMBIT REPL 1 - you need to enable the -gambit/geiser module ( if you can't, substitute the command below with -the PS: at the end of the readme ) - $ mkdir ~/gambit/lib/gambit/geiser - $ cp ~/geiser/geiser-module/* ~/gambit/lib/geiser/ - 2 - now that you have the module you start gsi with it and using the --:d - $ gsi -:d gambit/geiser - - 3 - you can now open emacs and write - M-x geiser-connect gambit - Enjoy ! - - By the way, if you are unable to use gambit modules, open gsi with -the 'gambit.scm' file located in -'geiser/scheme/gambit/geiser/gambit.scm' something like : - gsi -:d ~/geiser/scheme/gambit/geiser/gambit.scm - - (Keep in mind that these paths may be a little different for you.) - - -File: web.info, Node: From the source's mouth, Next: Friends, Prev: The easy and quick way, Up: Installation - -2.3 Installing from source -========================== - -Downloading Geiser -.................. - -The latest release tarballs can be found here -(https://gitlab.com/jaor/geiser/-/releases). - - If you feel like living on the bleeding edge, just grab Geiser from -its Git repository over at Savannah -(http://git.savannah.nongnu.org/cgit/geiser.git/), either with the -following incantation: - - git clone git://git.sv.gnu.org/geiser.git - -or, if you happen to live behind a firewall, with the alternative: - - git clone http://git.sv.gnu.org/r/geiser.git - -You can also follow Geiser's development in one -(https://gitlab.com/jaor/geiser) or (http://repo.or.cz/w/geiser.git) -three (http://gitorious.org/geiser) mirrors that are kept synchronized -with the one at Savannah. - - Either way, you'll now be in possession of a copy of Geiser's libre -code. I'll follow you into its directory and the next section. - -Setting it up -............. - -Geiser is ready to be used out of the box without much more ado. For -the sake of concreteness, let's assume you put its source in the -directory '~/lisp/geiser'. All you need to do is to add the following -line to your Emacs initialisation file (be it '~/.emacs', -'~/.emacs.d/init.el' or any of its moral equivalents): - - (load-file "~/lisp/geiser/elisp/geiser.el") - -or simply evaluate that form inside Emacs (you wouldn't kill a friend -just to start using Geiser, would you?). That's it: you're ready to go -(*note The REPL::). - - What? You still here? I promise the above is all that's needed to -start using Geiser. But, in case you are missing your configure/make -all install routine, by all means, you can go through those motions to -byte compile and install Geiser too. That is, you enter the source -directory and (since we grabbed the development tree) run the customary -autogen script: - - $ cd ~/lisp/geiser - $ ./autogen.sh - -I recommend that you compile Geiser in a separate directory: - - $ mkdir build && cd build - $ ../configure - <some drivel here> - $ make all - <more of the above> - - Now you have two options: loading the byte-compiled Geiser from the -'elisp' subdirectory, or installing it system-wide. To load the -byte-code from here, add this line to your initialisation file: - - (load "~/lisp/geiser/build/elisp/geiser-load") - -and eval that form and you're done (you could also restart Emacs, but -killing your friends is widely considered bad form). Yes, that's 'load' -and 'geiser-load' instead of 'load-file' and 'geiser.el'. - - If you prefer a system-wide installation, just type: - - $ sudo make install - - With the above spell, Geiser will be compiled and installed in a safe -place inside Emacs' load path. To load it into Emacs you'll need, -instead of the 'load-file' form above, the following line in your -initialisation file: - - (require 'geiser-install) - -Please note that we're requiring 'geiser-install', and not 'geiser', and -that there's no 'load-file' to be seen this time. There are some ways -of fine-tuning this process, mainly by providing additional arguments in -the call to configure: you'll find those gory details in the file called -'INSTALL', right at the root of the source tree. The installation will -also take care of placing this manual, in Info format, where Emacs can -find it, so you can continue to learn about Geiser inside its natural -habitat. See you there and into the next chapter! - - -File: web.info, Node: Friends, Prev: From the source's mouth, Up: Installation - -2.4 Friends -=========== - -Although Geiser does not need them, it plays well with (and is enhanced -by) the following Emacs packages: - - * Paredit (http://www.emacswiki.org/emacs/ParEdit). Regardless of - whether you use Geiser or not, you shouldn't be coding in any Lisp - dialect without the aid of Taylor Campbell's structured editing - mode. - * Company (http://company-mode.github.io/). Nikolaj Schumacher's and - Dmitry Gutov's 'company-mode' provides a generic front-end for - completion engines (such as Geiser's), with pretty and automatic - completion lists. - * ac-geiser (https://github.com/xiaohanyu/ac-geiser/) If you prefer - 'auto-complete-mode' to 'company-mode', Xiao Hanyu's 'ac-geiser', - which provides a Geiser plugin for the popular Emacs Auto - Completion Mode (https://www.emacswiki.org/emacs/AutoComplete), is - the package for you. Like Geiser, 'ac-geiser' is available in - MELPA, and also as an 'el-get' package. - -You just need to install and setup them as usual, for every package's -definition of usual. Geiser will notice their presence and react -accordingly. - - -File: web.info, Node: The REPL, Next: Between the parens, Prev: Installation, Up: Top - -3 The REPL -********** - -If you've followed the instructions in *note Installation::, your Emacs -is now ready to start playing. Otherwise, i'll wait for you: when -you're ready, just come back here and proceed to the following sections. - -* Menu: - -* Starting the REPL:: -* First aids:: -* Switching context:: -* Completion and error handling:: -* Autodoc and friends:: -* Seeing is believing:: -* Customization and tips:: - - -File: web.info, Node: Starting the REPL, Next: First aids, Prev: The REPL, Up: The REPL - -3.1 Starting the REPL -===================== - -To start a Scheme REPL (meaning, a Scheme process offering you a -Read-Eval-Print Loop), Geiser provides the generic interactive command -'run-geiser'. If you invoke it (via, as is customary in Emacs, 'M-x -run-geiser'), you'll be saluted by a prompt asking which one of the -supported implementations you want to launch--yes, you can stop the -asking, see *note below: active-implementations. Tabbing for completion -will offer you, as of this writing, 'guile', 'racket', 'chicken', 'mit', -'chibi' and 'chez'. Just choose your poison, and a new REPL buffer will -pop up (by default, the REPL will appear in a new window: if that annoys -you, just set 'geiser-repl-use-other-window' to 'nil' and the current -window will be used). - - If all went according to plan, you'll be facing an -implementation-dependent banner, followed by an interactive prompt. -Going according to plan includes having the executable of the Scheme you -chose in your path. If that's not the case, you can tell Emacs where it -is, as described in *note a moment: impl-binary. Returning to our REPL, -the first thing to notice is that the funny prompt is telling you your -current module: its name is the part just after the @ sign (in Guile, -that means 'guile-user', while Racket's and Chicken's top namespaces -don't have a name; cf. discussion in *note Switching context::). Other -than that, this is pretty much equivalent to having a command-line -interpreter in a terminal, with a bunch of add-ons that we'll be -reviewing below. You can start typing sexps right there: Geiser will -only dispatch them for evaluation when they're complete, and will indent -new lines properly until then. It will also keep track of your input, -maintaining a history file that will be reloaded whenever you restart -the REPL. - - If you're not happy with the faces Geiser is using for the REPL's -prompt and evaluated input, you can customise -'geiser-font-lock-repl-prompt' and 'geiser-font-lock-repl-input' to -better-looking faces. - -Connecting to an external Scheme -................................ - -There's an alternative way of starting a Geiser REPL: you can connect to -an external Scheme process, provided it's running a REPL server at some -known port. How to make that happen depends on the Scheme -implementation. - - If you use Guile, you just need to start your Guile process (possibly -outside Emacs) passing to it the flag '--listen'. This flag accepts an -optional port as argument (as in '--listen=1969'), if you don't want to -use the default. - - In Racket, you have to use the REPL server that comes with Geiser. -To that end, put Geiser's Racket 'scheme' directory in Racket's -collection search path and invoke 'start-geiser' (a procedure in the -module 'geiser/server') somewhere in your program, passing it the -desired port and, if desired, network interface name. This procedure -will start the REPL server in a separate thread. For an example of how -to do that, see the script 'bin/geiser-racket.sh' in the source -distribution, or, if you've compiled Geiser, 'bin/geiser-racket-noinst' -in the build directory, or, if you've installed Geiser, 'geiser-racket' -in '<installation-prefix>/bin'. These scripts start a new interactive -Racket that is also running a REPL server (they also load the errortrace -library to provide better diagnostics, but that's not strictly needed). - - With your external Scheme process running and serving, come back to -Emacs and execute 'M-x geiser-connect', 'M-x connect-to-guile' or 'M-x -connect-to-racket'. You'll be asked for a host and a port, and, voila, -you'll have a Geiser REPL that is served by the remote Scheme process in -a dedicated thread, meaning that your external program can go on doing -whatever it was doing while you tinker with it from Emacs. Note, -however, that all Scheme threads share the heap, so that you'll be able -to interact with those other threads in the running Scheme from Emacs in -a variety of ways. For starters, all your (re)definitions will be -visible everywhere. That's dangerous, but will come in handy when you -need to debug your running web server. - - The connection between Emacs and the Scheme process goes over TCP, so -it can be as remote as you need, perhaps with the intervention of an SSH -tunnel. - - -File: web.info, Node: First aids, Next: Switching context, Prev: Starting the REPL, Up: The REPL - -3.2 First aids -============== - -A quick way of seeing what else Geiser's REPL can do for you, is to -display the corresponding entry up there in your menu bar. No, i don't -normally use menus either; but they can come in handy until you've -memorized Geiser's commands, as a learning device. And yes, i usually -run Emacs inside a terminal, but one can always use La Carte -(http://www.emacswiki.org/emacs/LaCarte) to access the menus in a -convenient enough fashion. - - Or just press 'C-h m' and be done with that. - - Among the commands at your disposal, we find the familiar input -navigation keys, with a couple twists. By default, 'M-p' and 'M-n' are -bound to matching items in your input history. That is, they'll find -the previous or next sexp that starts with the current input prefix -(defined as the text between the end of the prompt and your current -position, a.k.a. "point", in the buffer). For going up and down the -list unconditionally, just use 'C-c M-p' and 'C-c M-n'. In addition, -navigation is sexp-based rather than line-based. - - There are also a few commands to twiddle with the Scheme process. -'C-c C-q' will gently ask it to quit, while 'C-u C-c C-q' will -mercilessly kill the process (but not before stowing your history in the -file system). Unless you're using a remote REPL, that is, in which case -both commands will just sever the connection and leave the remote -process alone. If worse comes to worst and the process is dead, 'C-c -C-z' will restart it. However, the same shortcut, issued when the REPL -is alive, will bring you back to the buffer you came from, as explained -in *note this section: switching-repl-buff. - - The remaining commands are meatier, and deserve sections of their -own. - - -File: web.info, Node: Switching context, Next: Completion and error handling, Prev: First aids, Up: The REPL - -3.3 Switching context -===================== - -In tune with Geiser's modus operandi, evaluations in the REPL take place -in the namespace of the current module. As noted above, the REPL's -prompt tells you the name of the current module. To switch to a -different one, you can use the command 'switch-to-geiser-module', bound -to 'C-c C-m'. You'll notice that Geiser simply uses a couple of -meta-commands provided by the Scheme REPL (the stock ',m' in Guile and -Chicken and the (geiser-defined) ',enter' in Racket), and that it -doesn't even try to hide that fact. That means that you can freely use -said native ways directly at the REPL, and Geiser will be happy to -oblige. In Racket, ',enter' works like Racket's standard 'enter!' form, -but you can also provide a path string as its argument (e.g., ',enter -"/tmp/foo.rkt"' is equivalent to ',enter (file "/tmp/foo.rkt")'). Like -'enter!', ',enter' accepts also module names (as in, say, ',enter -geiser/main'). As mentioned, in Guile and Chicken, ',m' is used as is. - - Once you enter a new module, only those bindings visible in its -namespace will be available to your evaluations. All Schemes supported -by Geiser provide a way to import new modules in the current namespace. -Again, there's a Geiser command, 'geiser-repl-import-module', to invoke -such functionality, bound this time to 'C-c C-i'. And, again, you'll -see Geiser just introducing the native incantation for you, and you're -free to use such incantations by hand whenever you want. - - One convenience provided by these two Geiser commands is that -completion is available when introducing the new module name, using the -'<TAB>' key. Pressing it at the command's prompt will offer you a -prefix-aware list of available module names. - - Which brings me to the next group of REPL commands. - - -File: web.info, Node: Completion and error handling, Next: Autodoc and friends, Prev: Switching context, Up: The REPL - -3.4 Completion and error handling -================================= - -We've already seen Geiser completion of module names in action at the -minibuffer. You won't be surprised to know that it's also available at -the REPL buffer itself. There, you can use either 'C-.' or 'M-`' to -complete module names, and '<TAB>' or 'M-<TAB>' to complete identifiers. -Geiser will know what identifiers are bound in the current module and -show you a list of those starting with the prefix at point. Needless to -say, this is not a static list, and it will grow as you define or import -new bindings in the namespace at hand. If no completion is found, -'<TAB>' will try to complete the prefix after point as a module name. - - REPL buffers use Emacs' compilation mode to highlight errors reported -by the Scheme interpreter, and you can use the 'next-error' command -('M-g n') to jump to their location. By default, every time you enter a -new expression for evaluation old error messages are forgotten, so that -'M-g n' will always jump to errors related to the last evaluation -request, if any. If you prefer a not-so-forgetful REPL, set the -customization variable 'geiser-repl-forget-old-errors-p' to 'nil'. -Note, however, that even when that variable is left as 't', you can -always jump to an old error by moving to its line at the REPL and -pressing '<RET>'. When your cursor is away from the last prompt, -'<TAB>' will move to the next error in the buffer, and you can use -'<BACKTAB>' everywhere to go to the previous one. - -Caveat about completion & the REPL ----------------------------------- - -It is possible for Geiser to hang your Emacs process when trying to -complete symbols. This can happen in the REPL itself or even in a -Scheme buffer that is attached to the REPL process. If this happens, -you've probably entered a module that changes the REPL prompt from what -Geiser was expecting to see. - - Unfortunately, there's no general solution for this issue right now -(as it is a daunting task to try to make a regexp that can encompass all -possible REPL prompts). The best solution for now is to fix this issue -on a case-by-case basis by adjusting your prompt regexp variable so that -it matches the default prompt as well as your Scheme module's special -prompt. - - For example, XREPL is a Racket module that implements a better Racket -REPL. You might be interested in toying around with some of its -functions, but when you try to enter XREPL via, say, 'C-c C-m xrepl', -you'll notice that the REPL prompt has changed to something like this: - - <pkgs>/xrepl-lib/xrepl/main> - - If you start typing symbols, and then you try to auto-complete those -symbols, your Emacs process may hang. This is because Geiser expects -the REPL prompt to match this regexp (for Racket): - - "\\(mzscheme\\|racket\\)@[^ ]*> " - - Therefore, we can fix this issue by changing our default prompt -regexp like so: - - (setq geiser-racket--prompt-regexp "<pkgs>.*> \\|\\(mzscheme\\|racket\\)@[^ ]*> ") - - Note that you may have to run 'M-x geiser-reload' after setting this -variable so that your changes will take effect. - - Again, you'll have to change the regexp to fit every prompt that -causes this issue, but the only alternative (that we can think of right -now) is to create a regexp that will match every possible prompt. -Obviously, that is going to be more than a little tricky. However, if -you have a better solution than that, please share it with the Geiser -developers; we'll be more than happy to hear it. - - -File: web.info, Node: Autodoc and friends, Next: Seeing is believing, Prev: Completion and error handling, Up: The REPL - -3.5 Autodoc and friends -======================= - -Oftentimes, there's more you'll want to know about an identifier besides -its name: What module does it belong to? Is it a procedure and, if so, -what arguments does it take? Geiser tries to help you answering those -questions too. - - Actually, if you've been playing with the REPL as you read, you might -have notice some frantic activity taking place in the echo area every -now and then. That was Geiser trying to be helpful (while, hopefully, -not being clippy), or, more concretely, what i call, for want of a -better name, its "autodoc" mode. Whenever it's active (did you notice -that A in the mode-line?), Geiser's gerbils will be scanning what you -type and showing (unless you silence them with 'C-c C-d C-a') -information about the identifier nearest to point. - - If that identifier corresponds to a variable visible in the current -namespace, you'll see the module it belongs to and its value. For -procedures and macros, autodoc will display, instead of their value, the -argument names (or an underscore if Geiser cannot determine the name -used in the definition). Optional arguments are surrounded by -parentheses. When the optional argument has a default value, it's -represented by a list made up of its name and that value. When the -argument is a keyword argument, its name has "#:" as a prefix. - - If that's not enough documentation for you, 'C-c C-d d' will open a -separate documentation buffer with help on the symbol at point. This -buffer will contain implementation-specific information about the -identifier (e.g., its docstring for Guile, or its contract, if any, for -Racket), and a handy button to open the corresponding manual entry for -the symbol, which will open an HTML page (for Racket and Chicken) or the -texinfo manual (for Guile). If you'd rather go directly to the manual, -try 'C-c C-d i', which invokes 'geiser-doc-look-up-manual' as the handy -button does. - - Geiser can also produce for you a list, classified by kind, of the -identifiers exported by a given module: all you need to do is press 'C-c -C-d m', and type or complete the desired module's name. - - The list of exported bindings is shown, again, in a buffer belonging -to Geiser's documentation browser, where you have at your disposal a -bunch of navigation commands listed in *note our cheat-sheet: -Documentation browser. - - We'll have a bit more to say about the documentation browser in *note -a later section: doc-browser. - - If that's still not enough, Geiser can jump, via 'M-.', to the -symbol's definition. A buffer with the corresponding file will pop up, -with its point resting upon the identifier's defining form. When you're -done inspecting, 'M-,' will bring you back to where you were. As we -will see, these commands are also available in Scheme buffers. 'M-.' -also works for modules: if your point is on an unambiguous module name, -the file where it's defined will be opened for you. - - -File: web.info, Node: Seeing is believing, Next: Customization and tips, Prev: Autodoc and friends, Up: The REPL - -3.6 Seeing is believing -======================= - -In schemes that support images as values (currently, that means Racket), -the REPL will display them inline if you're using them in a -graphics-aware Emacs. - - For the terminal, images will appear as buttons: press return on them -to invoke an external viewer (configurable via 'geiser-image-viewer') -that will show you the image at hand. You can also ask for the same -behaviour on all emacsen by customising 'geiser-repl-inline-images-p' to -'nil'. - - Geiser keeps a cache of the last displayed images in the directory -'geiser-image-cache-dir', which defaults to the system's temp directory, -with up to 'geiser-image-cache-keep-last' files. You can invoke the -external image viewer on any of them with 'M-x geiser-view-last-image', -which takes a prefix argument to indicate which image number you want, 0 -corresponding to the newest one. - - -File: web.info, Node: Customization and tips, Prev: Seeing is believing, Up: The REPL - -3.7 Customization and tips -========================== - -The looks and ways of the REPL can be fine-tuned via a bunch of -customization variables. You can see and modify them all in the -corresponding customization group (by using the menu entry or the good -old 'M-x customize-group geiser-repl'), or by setting them in your Emacs -initialisation files (as a rule, all knobs in Geiser are tunable this -way: you don't need to use customization buffers if you don't like -them). - - I'm documenting below a proper subset of those settings, together -with some related tips. - -Choosing a Scheme implementation -................................ - -Instead of using the generic 'run-geiser' command, you can directly -start your Scheme of choice using any of the following commands: - * 'run-racket' - * 'run-guile' - * 'run-chicken' - * 'run-mit' - * 'run-chibi' - * 'run-chez' - In addition, the variable 'geiser-active-implementations' contains a -list of those Schemes Geiser should be aware of. Thus, if you happen to -be, say, a racketeer not to be beguiled by other schemes, you can tell -Geiser to forget about the richness of the Scheme ecosystem with -something like: - - (setq geiser-active-implementations '(racket)) - -in your initialisation files. - - When starting a new REPL, Geiser assumes, by default, that the -corresponding Scheme binary is in your path. If that's not the case, -the variables to tweak are (depending on which Scheme you choose): - * 'geiser-guile-binary' - * 'geiser-racket-binary' - * 'geiser-chicken-binary' - * 'geiser-mit-binary' - * 'geiser-chibi-binary' - * 'geiser-chez-binary' - They should be set to a string with the full path to the requisite -binary. - - Before starting the REPL, Geiser will check wether the version of -your Scheme interpreter is good enough. This means that it will spend a -couple tenths of a second launching and quickly discarding a Scheme -process, but also that the error message you'll get if you're on the -wrong Scheme version will be much more informative. If you one to avoid -version checks, just check 'geiser-repl-skip-version-check-p' to 't' in -your configuration. - - You can also specify a couple more initialisation parameters. For -Guile, 'geiser-guile-load-path' is a list of paths to add to its load -path (and its compiled load path) when it's started, while -'geiser-guile-init-file' is the path to an initialisation file to be -loaded on start-up. The equivalent variables for Racket are -'geiser-racket-collects' and 'geiser-racket-init-file'. - - Note, however, that specifying 'geiser-guile-init-file' is not -equivalent to changing Guile's initialization file ('~/.guile'), because -the former is loaded using the '-l' flag, together with '-q' to disable -loading the second. But there are subtle differences in the way Guile -loads the initialization file versus how it loads a file specified via -the '-l' flag. If what you want is just loading '~/.guile', leave -'geiser-guile-init-file' alone and set 'geiser-guile-load-init-file-p' -to 't' instead. - - These variables controlling your scheme's initialisation process are -good candidates for an entry in a project's '.dir-locals.el' file, so -that they are automatically set to a sensible value whenever you start a -REPL in the project's directory. - -Racket startup time -................... - -When starting Racket in little computers, Geiser might have to wait a -bit more than it expects (which is ten seconds, or ten thousand -milliseconds, by default). If you find that Geiser is giving up too -quickly and complaining that no prompt was found, try to increase the -value of 'geiser-repl-startup-time' to, say, twenty seconds: - - (setq geiser-repl-startup-time 20000) - -If you prefer, you can use the customize interface to, well, customise -the above variable's value. - -History -....... - -By default, Geiser won't record duplicates in your input history. If -you prefer it did, just set 'geiser-repl-history-no-dups-p' to 'nil'. -History entries are persistent across REPL sessions: they're saved in -implementation-specific files whose location is controlled by the -variable 'geiser-repl-history-filename'. For example, my Geiser -configuration includes the following line: - - (setq geiser-repl-history-filename "~/.emacs.d/geiser-history") - -which makes the files 'geiser-history.guile' and 'geiser-history.racket' -to live inside my home's '.emacs.d' directory. - -Autodoc -....... - -If you happen to love peace and quiet and prefer to keep your REPL's -echo area free from autodoc's noise, 'geiser-repl-autodoc-p' is the -customization variable for you: set it to 'nil' and autodoc will be -disabled by default in new REPLs. You can always bring the fairies -back, on a per-REPL basis, using 'C-c C-d C-a'. - -Remote connections -.................. - -When using any of the connection commands (e.g. 'geiser-connect', -'connect-to-guile', 'connect-to-racket', etc.) you'll be prompted for a -host and a port, defaulting to "localhost" and 37146. You can change -those defaults customizing 'geiser-repl-default-host' and -'geiser-repl-default-port', respectively. - -Killing REPLs -............. - -If you don't want Emacs to ask for confirmation when you're about to -kill a live REPL buffer (as will happen, for instance, if you're exiting -Emacs before closing all your REPLs), you can set the flag -'geiser-repl-query-on-kill-p' to 'nil'. On a related note, the -customizable variable 'geiser-repl-query-on-exit-p' controls whether -Geiser should ask for confirmation when you exit the REPL explicitly -(via, say, 'C-c C-q', as opposed to killing the buffer), and is set to -'nil' by default. - - -File: web.info, Node: Between the parens, Next: Cheat sheet, Prev: The REPL, Up: Top - -4 Between the parens -******************** - -A good REPL is a must, but just about half the story of a good Scheme -hacking environment. Well, perhaps a bit more than a half; but, at any -rate, one surely needs also a pleasant way of editing source code. -Don't pay attention to naysayers: Emacs comes with an excellent editor -included for about any language on Earth, and just the best one when -that language is sexpy (especially if you use Paredit). Geiser's -support for writing Scheme code adds to Emacs' 'scheme-mode', rather -than supplanting it; and it does so by means of a minor mode -(unimaginatively dubbed 'geiser-mode') that defines a bunch of new -commands to try and, with the help of the same Scheme process giving you -the REPL, make those Scheme buffers come to life. - -* Menu: - -* Activating Geiser:: -* The source and the REPL:: -* Documentation helpers:: -* To eval or not to eval:: -* To err perchance to debug:: -* Jumping around:: -* Geiser writes for you:: - - -File: web.info, Node: Activating Geiser, Next: The source and the REPL, Prev: Between the parens, Up: Between the parens - -4.1 Activating Geiser -===================== - -With Geiser installed following any of the procedures described in *note -The easy and quick way:: or *note From the source's mouth::, Emacs will -automatically activate geiser-mode when opening a Scheme buffer. Geiser -also instructs Emacs to consider files with the extension 'rkt' part of -the family, so that, in principle, there's nothing you need to do to -ensure that Geiser's extensions will be available, out of the box, when -you start editing Scheme code. - - Indications that everything is working according to plan include the -'Geiser' minor mode indicator in your mode-line and the appearance of a -new entry for Geiser in the menu bar. If, moreover, the mode-line -indicator is the name of a Scheme implementation, you're indeed in a -perfect world; otherwise, don't despair and keep on reading: i'll tell -you how to fix that in a moment. - - The menu provides a good synopsis of everything Geiser brings to the -party, including those keyboard shortcuts we Emacsers love. If you're -seeing the name of your favourite Scheme implementation in the -mode-line, have a running REPL and are comfortable with Emacs, you can -stop reading now and, instead, discover Geiser's joys by yourself. I've -tried to make Geiser as self-documenting as any self-respecting Emacs -package should be. If you follow this route, make sure to take a look -at Geiser's customization buffers ('M-x customize-group <RET> geiser'): -there's lot of fine-tuning available there. You might also want to take -a glance at the tables in *note our cheat sheet: Cheat sheet. - - Since geiser-mode is a minor mode, you can toggle it with 'M-x -geiser-mode', and control its activation in hooks with the functions -'turn-on-geiser-mode' and 'turn-off-geiser-mode'. If, for some reason i -cannot fathom, you prefer geiser-mode not to be active by default, -customizing 'geiser-mode-auto-p' to 'nil' will do the trick. - - And if you happen to use a funky extension for your Scheme files that -is not recognised as such by Emacs, just tell her about it with: - - (add-to-list 'auto-mode-alist '("\\.funky-extension\\'" . scheme-mode)) - - Now, geiser-mode is just a useless wretch unless there's a running -Scheme process backing it up. Meaning that virtually all the commands -it provides require a REPL up and running, preferably corresponding to -the correct Scheme implementation. In the following section, we'll see -how to make sure that that's actually the case. - - -File: web.info, Node: The source and the REPL, Next: Documentation helpers, Prev: Activating Geiser, Up: Between the parens - -4.2 The source and the REPL -=========================== - -As i've already mentioned a couple of times, geiser-mode needs a running -REPL to be operative. Thus, a common usage pattern will be for you to -first call 'run-geiser' (or one of its variants, e.g. 'run-guile'), and -then open some Scheme files; but there's nothing wrong in first opening -a couple Scheme buffers and then starting the REPL (you can even find it -more convenient, since pressing 'C-c C-z' in a Scheme buffer will start -the REPL for you). Since Geiser supports more than one Scheme -implementation, though, there's the problem of knowing which of them is -to be associated with each Scheme source file. Serviceable as it is, -geiser-mode will try to guess the correct implementation for you, -according to the algorithm described below. - -How Geiser associates a REPL to your Scheme buffer -.................................................. - -To determine what Scheme implementation corresponds to a given source -file, Geiser uses the following algorithm: - - 1. If the file-local variable 'geiser-scheme-implementation' is - defined, its value is used. A common way of setting buffer-local - variables is to put them in a comment near the beginning of the - file, surrounded by '-*-' marks, as in: - - ;; -*- geiser-scheme-implementation: guile -*- - - 2. If you've customized 'geiser-active-implementations' so that it's a - single-element list, that element is used as the chosen - implementation. - 3. The contents of the file is scanned for hints on its associated - implementation. For instance, files that contain a '#lang' - directive will be considered Racket source code, while those with a - 'define-module' form in them will be assigned to a Guile REPL. - 4. The current buffer's file name is checked against the rules given - in 'geiser-implementations-alist', and the first match is applied. - You can provide your own rules by customizing this variable, as - explained below. - 5. If we haven't been lucky this far and you have customized - 'geiser-default-implementation' to the name of a supported - implementation, we'll follow your lead. - 6. See? That's the problem of being a smart aleck: one's always - outsmarted by people around. At this point, geiser-mode will - humbly give up and ask you to explicitly choose the Scheme - implementation. - - As you can see in the list above, there are several ways to influence -Geiser's guessing by means of customizable variables. The most direct -(and most impoverishing) is probably limiting the active implementations -to a single one, while customizing 'geiser-implementations-alist' is the -most flexible (and, unsurprisingly, also the most complex). Here's the -default value for the latter variable: - - (((regexp "\\.scm$") guile) - ((regexp "\\.ss$") racket) - ((regexp "\\.rkt$") racket)) - -which describes the simple heuristic that files with '.scm' as extension -are by default associated to a Guile REPL while those ending in '.ss' or -'.rkt' correspond to Racket's implementation (with the caveat that these -rules are applied only if the previous heuristics have failed to detect -the correct implementation, and that they'll match only if the -corresponding implementation is active). You can add rules to -'geiser-implementations-alist' (or replace all of them) by customizing -it. Besides regular expressions, you can also use a directory name; for -instance, the following snippet: - - (eval-after-load "geiser-impl" - '(add-to-list 'geiser-implementations-alist - '((dir "/home/jao/prj/frob") guile))) - -will add a new rule that says that any file inside my -'/home/jao/prj/frob' directory (or, recursively, any of its children) is -to be assigned to Guile. Since rules are first matched, first served, -this new rule will take precedence over the default ones. - - A final tip: if you want Geiser to start automatically a REPL for you -if it notices that there's no one active when it enters geiser-mode, you -can customize 'geiser-mode-start-repl-p' to 't'. - -Switching between source files and the REPL -........................................... - -Once you have a working geiser-mode, you can switch from Scheme source -buffers to the REPL or 'C-c C-z'. Those shortcuts map to the -interactive command 'switch-to-geiser'. - - If you use a numeric prefix, as in 'C-u C-c C-z', besides being -teleported to the REPL, the latter will switch to the namespace of the -Scheme source file, as if you had used 'C-c C-m' in the REPL, with the -source file's module as argument; cf. discussion in *note Switching -context::. This command is also bound to 'C-c C-a'. - - Once you're in the REPL, the same 'C-c C-z' shortcut will bring you -back to the buffer you jumped from, provided you don't kill the Scheme -process in between. This is why the command is called switch-to-geiser -instead of switch-to-repl, and what makes it really handy, if you ask -me. - - If for some reason you're not happy with the Scheme implementation -that Geiser has assigned to your file, you can change it with 'C-c C-s', -and you probably should take a look at the previous subsection to make -sure that Geiser doesn't get confused again. - -A note about context -.................... - -As explained before (*note Modus operandi::), all Geiser activities take -place in the context of the current namespace, which, for Scheme -buffers, corresponds to the module that the Scheme implementation -associates to the source file at hand (for instance, in Racket, there's -a one-to-one correspondence between paths and modules, while Guile -relies on explicit 'define-module' forms in the source file). - - Now that we have 'geiser-mode' happily alive in our Scheme buffers -and communicating with the right REPL instance, let us see what it can -do for us, besides jumping to and fro. - - -File: web.info, Node: Documentation helpers, Next: To eval or not to eval, Prev: The source and the REPL, Up: Between the parens - -4.3 Documentation helpers -========================= - -Autodoc redux -............. - -The first thing you will notice by moving around Scheme source is that, -every now and then, the echo area lights up with the same autodoc -messages we know and love from our REPL forays. This happens every time -the Scheme process is able to recognise an identifier in the buffer, and -provide information either on its value (for variables) or on its arity -and the name of its formal arguments (for procedures and macros). That -information will only be available if the module the identifier belongs -to has been loaded in the running Scheme image. So it can be the case -that, at first, no autodoc is shown for identifiers defined in the file -you're editing. But as soon as you evaluate them (either individually -or collectively using any of the devices described in *note To eval or -not to eval::) their signatures will start appearing in the echo area. - - Autodoc activation is controlled by a minor mode, 'geiser-autodoc', -which you can toggle with 'M-x geiser-autodoc-mode', or its associated -keyboard shortcut, 'C-c C-d a'. That /A indicator in the mode-line is -telling you that autodoc is active. If you prefer that it be inactive -by default (e.g., because you're connecting to a really remote scheme -and want to minimize network exchanges), just set -'geiser-mode-autodoc-p' to 'nil' in your customization files. Even when -autodoc mode is off, you can use 'geiser-autodoc-show', bound by default -to 'C-c C-d s', to show the autodoc string for the symbol at point. - - The way autodoc displays information deserves some explanation. It -will first show the name of the module where the identifier at hand is -defined, followed by a colon and the identifier itself. If the latter -corresponds to a procedure or macro, it will be followed by a list of -argument names, starting with the ones that are required. Then there -comes a list of optional arguments, if any, enclosed in parentheses. -When an optional argument has a default value (or a form defining its -default value), autodoc will display it after the argument name. When -the optional arguments are keywords, their names are prefixed with "#:" -(i.e., their names are keywords). An ellipsis (...) serves as a marker -of an indeterminate number of parameters, as is the case with rest -arguments or when autodoc cannot fathom the exact number of arguments -(this is often the case with macros defined using 'syntax-case'). -Another way in which autodoc displays its ignorance is by using an -underscore to display parameters whose name is beyond its powers. - - It can also be the case that a function or macro has more than one -signature (e.g., functions defined using 'case-lambda', or some -'syntax-rules' macros, for which Geiser has often the black magic -necessary to retrieve their actual arities). In those cases, autodoc -shows all known signatures (using the above rules for each one) -separated by a vertical bar (|). - - As you have already noticed, the whole autodoc message is enclosed in -parentheses. After all, we're talking about Scheme here. - - Finally, life is much easier when your cursor is on a symbol -corresponding to a plain variable: you'll see in the echo area its name, -preceded by the module where it's defined, and followed by its value, -with an intervening arrow for greater effect. This time, there are no -enclosing parentheses (i hope you see the logic in my madness). - - You can change the way Geiser displays the module/identifier combo by -customizing 'geiser-autodoc-identifier-format'. For example, if you -wanted a tilde surrounded by spaces instead of a colon as a separator, -you would write something like: - - (setq geiser-autodoc-identifier-format "%s ~ %s") - -in your Emacs initialisation files. There's also a face -('geiser-font-lock-autodoc-identifier') that you can customize (for -instance, with 'M-x customize-face') to change the appearance of the -text. And another one ('geiser-font-lock-autodoc-current-arg') that -controls how the current argument position is highlighted. - -Other documentation commands -............................ - -Sometimes, autodoc won't provide enough information for you to -understand what a function does. In those cases, you can ask Geiser to -ask the running Scheme for further information on a given identifier or -module. - - For symbols, the incantation is 'M-x geiser-doc-symbol-at-point', or -'C-c C-d C-d' for short. If the associated Scheme supports docstrings -(as, for instance, Guile does), you'll be teleported to a new Emacs -buffer displaying Geiser's documentation browser, filled with -information about the identifier, including its docstring (if any; -unfortunately, that an implementation supports docstrings doesn't mean -that they're used everywhere). - - Pressing 'q' in the documentation buffer will bring you back, -enlightened, to where you were. There's also a handful of other -navigation commands available in that buffer, which you can discover by -means of its menu or via the good old 'C-h m' command. And feel free to -use the navigation buttons and hyperlinks that justify my calling this -buffer a documentation browser. - - For Racket, which does not support docstrings out of the box, this -command will provide less information, but the documentation browser -will display the corresponding contract when it's available, as well as -some other tidbits for re-exported identifiers. - - You can also ask Geiser to display information about a module, in the -form of a list of its exported identifiers, using 'C-c C-d C-m', exactly -as you would do in *note the REPL: repl-mod. - - In both cases, the documentation browser will show a couple of -buttons giving you access to further documentation. First, you'll see a -button named source: pressing it you'll jump to the symbol's definition. -The second button, dubbed manual, will open the Scheme implementation's -manual page for the symbol at hand. For Racket, that will open your web -browser displaying the corresponding reference's page (using the HTML -browser in Racket's configuration, which you can edit in DrRacket's -preferences dialog, or by setting 'plt:framework-pref:external-browser' -directly in '~/.racket/racket-prefs.rktd'), while in Guile a lookup will -be performed in the texinfo manual. - - For Guile, the manual lookup uses the info indexes in the standard -Guile info nodes, which are usually named "guile" or "guile-2.0". If -yours are named differently, just add your name to the customizable -variable 'geiser-guile-manual-lookup-nodes'. - - A list of all navigation commands in the documentation browser is -available in *note our cheat-sheet: Documentation browser. - - You can also skip the documentation browser and jump directly to the -manual page for the symbol at point with the command -'geiser-doc-look-up-manual', bound to 'C-c C-d i'. - - -File: web.info, Node: To eval or not to eval, Next: To err perchance to debug, Prev: Documentation helpers, Up: Between the parens - -4.4 To eval or not to eval -========================== - -One of Geiser's main goals is to facilitate incremental development. -You might have noticed that i've made a big fuss of Geiser's ability to -recognize context, by being aware of the namespace where its operations -happen. - - That awareness is especially important when evaluating code in your -scheme buffers, using the commands described below. They allow you to -send code to the running Scheme with a granularity ranging from whole -files to single s-expressions. That code will be evaluated in the -module associated with the file you're editing, allowing you to redefine -values and procedures to your heart's (and other modules') content. - - Macros are, of course, another kettle of fish: one needs to -re-evaluate uses of a macro after redefining it. That's not a -limitation imposed by Geiser, but a consequence of how macros work in -Scheme (and other Lisps). There's also the risk that you lose track of -what's actually defined and what's not during a given session. But, in -my opinion -(http://jaortega.wordpress.com/2009/03/29/from-my-cold-prying-hands/index.html), -those are limitations we lispers are aware of, and they don't force us -to throw the baby with the bathwater and ditch incremental evaluation. -Some people disagree; if you happen to find their arguments -(http://blog.racket-lang.org/2009/03/drscheme-repl-isnt-lisp-the-one-in-emacs.html) -convincing, you don't have to throw away Geiser together with the baby: -'M-x geiser-restart-repl' will let you restart the REPL as many times as -you see fit. Moreover, you can invoke 'geiser-compile-current-buffer' -and 'geiser-load-current-buffer' with a prefix argument (that'd be -something like 'C-u C-c C-k' for compilation, for instance), to tell -Geiser to restart the REPL associated with a buffer before compiling or -loading its current contents. - - For all of you bearded old lispers still with me, here are some of -the commands performing incremental evaluation in Geiser. - - 'geiser-eval-last-sexp', bound to 'C-x C-e', will eval the -s-expression just before point. If you use a prefix, as in 'C-u C-x -C-e', besides evaluating it the expression is inserted in the the -buffer. - - 'geiser-eval-definition', bound to 'C-M-x', finds the topmost -definition containing point and sends it for evaluation. The variant -'geiser-eval-definition-and-go' ('C-c M-e') works in the same way, but -it also teleports you to REPL after the evaluation. - - 'geiser-eval-region', bound to 'C-c C-r', evals the current region. -Again, there's an and-go version available, 'geiser-eval-region-and-go', -bound to 'C-c M-r'. And, if you want to extend the evaluated region to -the whole buffer, there is 'geiser-eval-buffer', bound to 'C-c C-b' and -its companion 'geiser-eval-buffer-and-go', bound to 'C-c M-b'. - - For all the commands above, the result of the evaluation is displayed -in the minibuffer, unless it causes a (Scheme-side) error (*note To err -perchance to debug::), or, for schemes supporting them (such as Racket), -the evaluation yields an image, in which case you'll see it in popping -up in the Geiser debug buffer (if your Emacs runs under the auspices of -a graphical toolkit), or via an external viewer if you set program (see -also *note Seeing is believing:: for more on image support). - - At the risk of repeating myself, i'll remind you that all these -evaluations will take place in the namespace of the module corresponding -to the Scheme file from which you're sending your code, which, in -general, will be different from the REPL's current module. And, if all -goes according to plan, (re)defined variables and procedures should be -immediately visible inside and, if exported, outside their module. - - Besides evaluating expressions, definitions and regions, you can also -macro-expand them. The corresponding key bindings start with the prefix -'C-c C-m' and end, respectively, with 'C-e', 'C-x' and 'C-r'. The -result of the macro expansion always appears in a pop up buffer. - - -File: web.info, Node: To err perchance to debug, Next: Jumping around, Prev: To eval or not to eval, Up: Between the parens - -4.5 To err: perchance to debug -============================== - -When an error occurs during evaluation, it will be reported according to -the capabilities of the underlying Scheme REPL. - - In Racket, you'll be presented with a backtrace, in a new buffer -where file paths locating the origin of the error are click-able (you -can navigate them using the <TAB> key, and use <RET> or the mouse to -jump to the offending spot; or invoke Emacs' stock commands 'next-error' -and 'previous-error', bound to 'M-g n' and 'M-g p' by default). - - The Racket backtrace also highlights the exception type, making it -click-able. Following the link will open the documentation -corresponding to said exception type. Both the error and exception link -faces are customizable ('geiser-font-lock-error-link' and -'geiser-font-lock-doc-link'). - - By default, Geiser will tele-transport your pointer to the debug -buffer: if you prefer to stay in the source buffer, set -'geiser-debug-jump-to-debug-p' to nil. And if, in addition, you don't -even want to see the error trace, customize 'geiser-debug-show-debug-p', -again, to nil. - - On the other hand, Guile's reaction to evaluation errors is -different: it enters the debugger in its REPL. Accordingly, the REPL -buffer will pop up if your evaluation fails in a Guile file, and the -error message and backtrace will be displayed in there, again click-able -and all. But there you have the debugger at your disposal, with the -REPL's current module set to that of the offender, and a host of special -debugging commands that are described in Guile's fine documentation. - - In addition, Guile will sometimes report warnings for otherwise -successful evaluations. In those cases, it won't enter the debugger, -and Geiser will report the warnings in a debug buffer, as it does for -Racket. You can control how picky Guile is reporting warnings by -customizing the variable 'geiser-guile-warning-level', whose detailed -docstring (which see, using, e.g. 'C-h v') allows me to offer no -further explanation here. The customization group geiser-guile is also -worth a glance, for a couple of options to fine-tune how Geiser -interacts with Guile's debugger (and more). Same thing for racketeers -and geiser-racket. - - -File: web.info, Node: Jumping around, Next: Geiser writes for you, Prev: To err perchance to debug, Up: Between the parens - -4.6 Jumping around -================== - -This one feature is as sweet as it is easy to explain: 'M-.' -('geiser-edit-symbol-at-point') will open the file where the identifier -around point is defined and land your point on its definition. To -return to where you were, press 'M-,' ('geiser-pop-symbol-stack'). This -command works also for module names: Geiser first tries to locate a -definition for the identifier at point and, if that fails, a module with -that name; if the latter succeeds, the file where the module is defined -will pop up. - - Sometimes, the underlying Scheme will tell Geiser only the file where -the symbol is defined, but Geiser will use some heuristics (read, -regular expressions) to locate the exact line and bring you there. -Thus, if you find Geiser systematically missing your definitions, send a -message to the mailing list <geiser-users@nongnu.org>, and we'll try to -make the algorithm smarter. - - You can control how the destination buffer pops up by setting -'geiser-edit-symbol-method' to either 'nil' (to open the file in the -current window), ''window' (other window in the same frame) or ''frame' -(in a new frame). - - -File: web.info, Node: Geiser writes for you, Prev: Jumping around, Up: Between the parens - -4.7 Geiser writes for you -========================= - -No self-respecting programming mode would be complete without -completion. In geiser-mode, identifier completion is bound to -'M-<TAB>', and will offer all visible identifiers starting with the -prefix before point. Visible here means all symbols imported or defined -in the current namespace plus locally bound ones. E.g., if you're at -the end of the following partial expression: - - (let ((default 42)) - (frob def - -and press 'M-<TAB>', one of the possible completions will be 'default'. - - After obtaining the list of completions from the running Scheme, -Geiser uses the standard Emacs completion machinery to display them. -That means, among other things, that partial completion is available: -just try to complete 'd-s' or 'w-o-t-s' to see why this is a good thing. -Partial completion won't work if you have disabled it globally in your -Emacs configuration: if you don't know what i'm talking about, never -mind: Geiser's partial completion will work for you out of the box. - - If you find the 'M' modifier annoying, you always have the option to -activate 'geiser-smart-tab-mode', which will make the <TAB> key double -duty as the regular Emacs indentation command (when the cursor is not -near a symbol) and Geiser's completion function. If you want this -smarty pants mode always on in Scheme buffers, customize -'geiser-mode-smart-tab-p' to 't'. - - Geiser also knows how to complete module names: if no completion for -the prefix at point is found among the currently visible bindings, it -will try to find a module name that matches it. You can also request -explicitly completion only over module names using 'M-`' (that's a -backtick). - - Besides completion, there's also this little command, -'geiser-squarify', which will toggle the delimiters of the innermost -list around point between round and square brackets. It is bound to -'C-c C-e ['. With a numeric prefix (as in, say, 'M-2 C-c C-e ['), it -will perform that many toggles, forward for positive values and backward -for negative ones. - -Caveat about completion ------------------------ - -It is possible for Geiser to hang your Emacs process when trying to -complete symbols. This can happen in the REPL itself or even in a -Scheme buffer that is attached to the REPL process. For more details on -how to fix this problem, *note Caveat about completion & the REPL: -completion-caveat. - - -File: web.info, Node: Cheat sheet, Next: No hacker is an island, Prev: Between the parens, Up: Top - -5 Cheat sheet -************* - -In the tables below, triple chords always accept a variant with the -third key not modified by <Control>; e.g., 'geiser-autodoc-show' is -bound both to 'C-c C-d C-s' and 'C-c C-d s'. - -* Menu: - -* Scheme buffers:: -* REPL:: -* Documentation browser:: - - -File: web.info, Node: Scheme buffers, Next: REPL, Prev: Cheat sheet, Up: Cheat sheet - -5.1 Scheme buffers -================== - -Key Command Description ---------------------------------------------------------------------------- -C-c C-z 'geiser-mode-switch-to-repl' Switch to REPL -C-c C-a 'geiser-mode-switch-to-repl-and-enter'Switch to REPL and current - module (also 'C-u C-c C-z') -C-c C-s 'geiser-set-scheme' Specify Scheme - implementation for buffer -M-. 'geiser-edit-symbol-at-point' Go to definition of - identifier at point -M-, 'geiser-pop-symbol-stack' Go back to where M-. was - last invoked -C-c C-e C-m 'geiser-edit-module' Ask for a module and open - its file -C-c C-e C-l 'geiser-add-to-load-path' Ask for a directory and add - to Scheme load path -C-c C-e C-[ 'geiser-squarify' Toggle between () and [] - for current form -C-c C-\ 'geiser-insert-lambda' Insert greek lambda or, - with prefix, a lambda form -C-M-x 'geiser-eval-definition' Eval definition around - point -C-c C-c 'geiser-eval-definition' Eval definition around - point -C-c M-e 'geiser-eval-definition-and-go'Eval definition around - point and switch to REPL -C-c M-c 'geiser-eval-definition-and-go'Eval definition around - point and switch to REPL -C-x C-e 'geiser-eval-last-sexp' Eval sexp before point -C-c C-r 'geiser-eval-region' Eval region -C-c M-r 'geiser-eval-region-and-go' Eval region and switch to - REPL -C-c C-b 'geiser-eval-buffer' Eval buffer -C-c M-b 'geiser-eval-buffer-and-go' Eval buffer and switch to - REPL -C-c C-m C-x 'geiser-expand-definition' Macro-expand definition - around point -C-c C-m C-e 'geiser-expand-last-sexp' Macro-expand sexp before - point -C-c C-m C-r 'geiser-expand-region' Macro-expand region -C-c C-k 'geiser-compile-current-buffer'Compile and load current - file; with prefix, restart - REPL before -C-c C-l 'geiser-load-file' Load scheme file -M-g n, C-x ' 'next-error' Jump to the location of - next error -M-g p 'previous-error' Jump to the location of - previous error -C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for - identifier at point -C-c C-d C-s 'geiser-autodoc-show' Show signature or value for - identifier at point in echo - area -C-c C-d C-m 'geiser-doc-module' See a list of a module's - exported identifiers -C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol - at point -C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode -C-c < 'geiser-xref-callers' Show callers of procedure - at point -C-c > 'geiser-xref-callees' Show callees of procedure - at point -M-TAB 'completion-at-point' Complete identifier at - point -M-', C-. 'geiser-completion--complete-module'Complete module name at - point - - -File: web.info, Node: REPL, Next: Documentation browser, Prev: Scheme buffers, Up: Cheat sheet - -5.2 REPL -======== - -Key Command Description ---------------------------------------------------------------------------- -C-c C-z 'switch-to-geiser' Start Scheme REPL, or jump - to previous buffer -C-c M-o 'geiser-repl-clear-buffer' Clear REPL buffer -C-c C-k 'geiser-repl-interrupt' Interrupt REPL evaluation - (signalling inferior - scheme) -C-c C-q 'geiser-repl-exit' Kill Scheme process -M-. 'geiser-edit-symbol-at-point' Edit identifier at point -C-c C-l 'geiser-load-file' Load scheme file -TAB 'geiser-repl-tab-dwim' Complete, indent, or go to - next error -S-TAB 'geiser-repl--previous-error' Go to previous error in the -(backtab) REPL buffer -M-TAB 'completion-at-point' Complete indentifier at - point -M-', C-. 'geiser-completion--complete-module'Complete module name at - point -C-c [, C-c 'geiser-squarify' Toggle between () and [] -C-[ for current form -C-c \, C-c 'geiser-insert-lambda' Insert greek lambda or, -C-\ with prefix, a lambda form -C-c C-r 'geiser-add-to-load-path' Ask for a directory and add - to Scheme load path -M-p, M-n (comint commands) Prompt history, matching - current prefix -C-c M-p, C-c (comint commands) Previous/next prompt inputs -M-n -C-c C-m 'switch-to-geiser-module' Set current module -C-c C-i 'geiser-repl-import-module' Import module into current - namespace -C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for - symbol at point -C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol - at point -C-c C-d C-m 'geiser-repl--doc-module' See documentation for - module -C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode - - -File: web.info, Node: Documentation browser, Prev: REPL, Up: Cheat sheet - -5.3 Documentation browser -========================= - -Key Command Description ---------------------------------------------------------------------------- -TAB, n 'forward-button' Next link -S-TAB, p 'backward-button' Previous link -N 'geiser-doc-next-section' Next section -P 'geiser-doc-previous-section' Previous section -f 'geiser-doc-next' Next page -b 'geiser-doc-previous' Previous page -k 'geiser-doc-kill-page' Kill current page and go to - previous or next -g, r 'geiser-doc-refresh' Refresh page -c 'geiser-doc-clean-history' Clear browsing history -., M-. 'geiser-doc-edit-symbol-at-point'Edit identifier at point -z 'geiser-doc-switch-to-repl' Switch to REPL -q 'View-quit' Bury buffer - - -File: web.info, Node: No hacker is an island, Next: Index, Prev: Cheat sheet, Up: Top - -6 No hacker is an island -************************ - -Dan Leslie, with the help of his three-months old daughter Freija, -proved there's a smidgen of sense in this madness by adding support for -Chicken to version 0.7 of Geiser, several years after it was born. And -Peter Feigl reinforced that feeling soon afterwards with his work on -supporting GNU/MIT Scheme, Chib and Chez in one fell swoop. - - Andy Wingo, Geiser's first user, has been a continuous source of -encouragement and suggestions, and keeps improving Guile and heeding my -feature requests. - - The nice thing about collaborating with Andreas Rottmann over all -these years is that he will not only make your project better with -insightful comments and prodding: he'll send you patches galore too. - - Ludovic Courtès, #geiser's citizen no. 1, joined the fun after a -while, and has since then been a continuous source of encouragement, -ideas and bug reports. - - Michael Wilber convinced me that image support for Racket was not -only fun, but easy, with the best argument: actual code! - - Daniel Hackney and Grant Rettke created the first ELPA packages for -Geiser and taught me to fish. - - Diogo F. S. Ramos is Geiser's most indefatigable user and bug -reporter, and the mailing list has been a far less lonely place since he -came. - - Aleix Conchillo has been my favourite spammer, beta tester and patch -sender during more years and for more projects than i can remember. - - Eduardo Cavazos' contagious enthusiasm has helped in many ways to -keep Geiser alive, and he's become its best evangelist in R6RS circles. - - Alex Kost has contributed with many bug reports and improved Geiser -with several patches. - - Eli Barzilay took the time to play with an early alpha and made many -valuable suggestions, besides answering all my 'how do you in PLT' -questions. - - Matthew Flatt, Robby Findler and the rest of the PLT team did not -only answer my inquiries, but provided almost instant fixes to the few -issues i found. - - Thanks also to the PLT and Guile communities, for showing me that -Geiser was not only possible, but a pleasure to hack on. And to the -Slime hackers, who led the way. - -Joining the fun -............... - - * For questions, praise, critique and anything else Geiser, do not - hesitate to drop an email to our list, (@ geiser-users (. nongnu - org)) (mailto:geiser-users@nongnu.org): no subscription required. - Check the list page - (http://lists.nongnu.org/mailman/listinfo/geiser-users) for more - information or browse the archives - (http://lists.nongnu.org/archive/html/geiser-users/). The list is - also accessible via Gmane (http://gmane.org) as - gmane.lisp.scheme.geiser - (http://dir.gmane.org/gmane.lisp.scheme.geiser). - * You can submit bug reports either to the mailing list or to our bug - tracker (https://gitlab.com/jaor/geiser/issues) over at Gitlab. - * If you only need to hear about Geiser on new releases, the News - page (http://savannah.nongnu.org/news/?group=geiser) and its Atom - feed (https://savannah.nongnu.org/news/atom.php?group=geiser) are - probably what you're looking for. - * The Freenode IRC channel #geiser is the Geiserati's meeting point - in cyberspace. - - -File: web.info, Node: Index, Prev: No hacker is an island, Up: Top - -Index -***** - --* Menu: - -* ,enter vs. enter!: Switching context. (line 6) -* ac-geiser: Friends. (line 9) -* ask on kill, don't: Customization and tips. - (line 129) -* autocomplete: Friends. (line 9) -* autodoc customized: Documentation helpers. - (line 64) -* autodoc explained: Documentation helpers. - (line 32) -* autodoc for variables: Documentation helpers. - (line 58) -* autodoc, disabling: Customization and tips. - (line 111) -* autodoc, in scheme buffers: Documentation helpers. - (line 9) -* autodoc, in the REPL: Autodoc and friends. (line 11) -* autostart REPL: The source and the REPL. - (line 80) -* backtraces: To err perchance to debug. - (line 6) -* bug tracker: No hacker is an island. - (line 68) -* byte-compilation: From the source's mouth. - (line 46) -* Chicken: The easy and quick way. - (line 37) -* Chicken installation: The easy and quick way. - (line 37) -* company: Friends. (line 9) -* completion for module names: Geiser writes for you. - (line 33) -* completion in scheme buffers: Geiser writes for you. - (line 6) -* completion, at the REPL: Completion and error handling. - (line 6) -* connect to server: Starting the REPL. (line 43) -* corpses: Top. (line 9) -* current module: Modus operandi. (line 15) -* current module, change: Switching context. (line 21) -* current module, in REPL: Switching context. (line 6) -* derailment: Top. (line 9) -* disabling autodoc: Documentation helpers. - (line 22) -* docstrings, maybe: Documentation helpers. - (line 85) -* documentation for symbol: Documentation helpers. - (line 85) -* ELPA: The easy and quick way. - (line 6) -* error buffer: To err perchance to debug. - (line 9) -* evaluating images: To eval or not to eval. - (line 56) -* evaluation: To eval or not to eval. - (line 37) -* external image viewer: Seeing is believing. (line 10) -* faces, in the REPL: Starting the REPL. (line 35) -* Gambit: The easy and quick way. - (line 56) -* Gambit installation: The easy and quick way. - (line 56) -* geiser-mode: Activating Geiser. (line 6) -* geiser-mode commands: Activating Geiser. (line 21) -* gmane: No hacker is an island. - (line 58) -* Guile info nodes: Documentation helpers. - (line 120) -* Guile's REPL server: Starting the REPL. (line 48) -* GUILE_LOAD_COMPILED_PATH: Customization and tips. - (line 58) -* GUILE_LOAD_PATH: Customization and tips. - (line 58) -* help on identifier: Autodoc and friends. (line 29) -* host, default: Customization and tips. - (line 120) -* image cache: Seeing is believing. (line 16) -* image display: To eval or not to eval. - (line 56) -* image support: Seeing is believing. (line 6) -* image viewer: Seeing is believing. (line 10) -* incremental development: To eval or not to eval. - (line 6) -* incremental development, evil: To eval or not to eval. - (line 18) -* incremental development, not evil: To eval or not to eval. - (line 37) -* IRC channel: No hacker is an island. - (line 74) -* jump, at the REPL: Autodoc and friends. (line 51) -* jumping customized: Jumping around. (line 22) -* jumping in scheme buffers: Jumping around. (line 6) -* mailing list: No hacker is an island. - (line 58) -* manual autodoc: Documentation helpers. - (line 22) -* module exports: Autodoc and friends. (line 39) -* modus operandi: Modus operandi. (line 6) -* news feed: No hacker is an island. - (line 70) -* opening manual pages: Documentation helpers. - (line 128) -* paredit: Friends. (line 9) -* partial completion: Geiser writes for you. - (line 18) -* peace and quiet: Customization and tips. - (line 111) -* philosophy: Top. (line 9) -* philosophy <1>: To eval or not to eval. - (line 6) -* PLTCOLLECTS: Customization and tips. - (line 58) -* port, default: Customization and tips. - (line 120) -* quack: Friends. (line 9) -* quick install: The easy and quick way. - (line 6) -* Racket's REPL server: Starting the REPL. (line 53) -* recursion: Index. (line 6) -* remote connections: Starting the REPL. (line 78) -* remote REPL: Starting the REPL. (line 43) -* REPL: Starting the REPL. (line 6) -* REPL commands: First aids. (line 6) -* REPL customization: Customization and tips. - (line 6) -* REPL, faces: Starting the REPL. (line 35) -* scheme binary: Customization and tips. - (line 38) -* scheme executable path: Customization and tips. - (line 38) -* scheme file extensions: Activating Geiser. (line 38) -* scheme implementation, choosing: Customization and tips. - (line 20) -* scheme implementation, choosing <1>: The source and the REPL. - (line 21) -* scheme init file: Customization and tips. - (line 58) -* scheme load path: Customization and tips. - (line 58) -* smart tabs: Geiser writes for you. - (line 26) -* start REPL, automatically: The source and the REPL. - (line 80) -* startup timeout: Customization and tips. - (line 82) -* supported versions: Must needs. (line 6) -* swanking: Showing off. (line 6) -* switching schemes: The source and the REPL. - (line 103) -* switching to module: The source and the REPL. - (line 91) -* switching to REPL: The source and the REPL. - (line 87) -* switching to source: The source and the REPL. - (line 87) -* thanks: No hacker is an island. - (line 6) -* timeout: Customization and tips. - (line 82) -* to err is schemey: To err perchance to debug. - (line 6) -* use the source, Luke: From the source's mouth. - (line 9) -* useless wretch: Activating Geiser. (line 43) -* Version checking: Customization and tips. - (line 50) -* versions supported: Must needs. (line 6) - - - -Tag Table: -Node: Top67 -Node: Introduction1344 -Node: Modus operandi1675 -Ref: current-module2327 -Node: Showing off3800 -Node: Installation5075 -Node: Must needs5285 -Node: The easy and quick way6389 -Node: From the source's mouth10056 -Node: Friends13583 -Ref: paredit13854 -Node: The REPL14797 -Ref: quick-start14913 -Node: Starting the REPL15304 -Node: First aids19688 -Node: Switching context21518 -Node: Completion and error handling23440 -Ref: completion-caveat25145 -Node: Autodoc and friends27059 -Ref: repl-mod29126 -Node: Seeing is believing30132 -Node: Customization and tips31141 -Ref: choosing-impl31867 -Ref: active-implementations32102 -Ref: impl-binary32484 -Node: Between the parens36840 -Node: Activating Geiser37899 -Node: The source and the REPL40506 -Ref: repl-association41547 -Ref: switching-repl-buff44815 -Node: Documentation helpers46500 -Ref: doc-browser50765 -Node: To eval or not to eval53492 -Node: To err perchance to debug57638 -Node: Jumping around59997 -Node: Geiser writes for you61271 -Node: Cheat sheet63772 -Node: Scheme buffers64153 -Node: REPL68475 -Node: Documentation browser71066 -Node: No hacker is an island72131 -Node: Index75447 - -End Tag Table diff --git a/elpa/geiser-20200214.110/bin/geiser-racket.sh b/elpa/geiser-20200225.1423/bin/geiser-racket.sh diff --git a/elpa/geiser-20200214.110/dir b/elpa/geiser-20200225.1423/dir diff --git a/elpa/geiser-20200214.110/geiser-autodoc.el b/elpa/geiser-20200225.1423/geiser-autodoc.el diff --git a/elpa/geiser-20200214.110/geiser-autodoc.elc b/elpa/geiser-20200225.1423/geiser-autodoc.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-autoloads.el b/elpa/geiser-20200225.1423/geiser-autoloads.el diff --git a/elpa/geiser-20200214.110/geiser-base.el b/elpa/geiser-20200225.1423/geiser-base.el diff --git a/elpa/geiser-20200214.110/geiser-base.elc b/elpa/geiser-20200225.1423/geiser-base.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-chez.el b/elpa/geiser-20200225.1423/geiser-chez.el diff --git a/elpa/geiser-20200214.110/geiser-chez.elc b/elpa/geiser-20200225.1423/geiser-chez.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-chibi.el b/elpa/geiser-20200225.1423/geiser-chibi.el diff --git a/elpa/geiser-20200214.110/geiser-chibi.elc b/elpa/geiser-20200225.1423/geiser-chibi.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-chicken.el b/elpa/geiser-20200225.1423/geiser-chicken.el diff --git a/elpa/geiser-20200214.110/geiser-chicken.elc b/elpa/geiser-20200225.1423/geiser-chicken.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-company.el b/elpa/geiser-20200225.1423/geiser-company.el diff --git a/elpa/geiser-20200214.110/geiser-company.elc b/elpa/geiser-20200225.1423/geiser-company.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-compile.el b/elpa/geiser-20200225.1423/geiser-compile.el diff --git a/elpa/geiser-20200214.110/geiser-compile.elc b/elpa/geiser-20200225.1423/geiser-compile.elc Binary files differ. diff --git a/elpa/geiser-20200225.1423/geiser-completion.el b/elpa/geiser-20200225.1423/geiser-completion.el @@ -0,0 +1,198 @@ +;;; geiser-completion.el -- tab completion + +;; Copyright (C) 2009, 2010, 2011, 2012, 2018, 2020 Jose Antonio Ortega Ruiz + +;; This program is free software; you can redistribute it and/or +;; modify it under the terms of the Modified BSD License. You should +;; have received a copy of the license along with this program. If +;; not, see <http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5>. + +;; Start date: Mon Feb 09, 2009 22:21 + + + +(require 'geiser-impl) +(require 'geiser-eval) +(require 'geiser-log) +(require 'geiser-syntax) +(require 'geiser-base) + +(require 'comint) +(require 'minibuffer) + + +;;; Minibuffer maps: + +(defvar geiser-completion--minibuffer-map + (let ((map (make-keymap))) + (set-keymap-parent map minibuffer-local-completion-map) + (define-key map "?" 'self-insert-command) + map)) + +(defvar geiser-completion--module-minibuffer-map + (let ((map (make-keymap))) + (set-keymap-parent map minibuffer-local-completion-map) + (define-key map " " 'self-insert-command) + (define-key map "?" 'self-insert-command) + map)) + + +;;; Completion functionality: + +(defvar geiser-completion--binding-forms nil) +(geiser-impl--register-local-variable + 'geiser-completion--binding-forms 'binding-forms nil + "A list of forms introducing local bindings, a la let or lambda.") + +(defvar geiser-completion--binding-forms* nil) +(geiser-impl--register-local-variable + 'geiser-completion--binding-forms* 'binding-forms* nil + "A list of forms introducing nested local bindings, a la let*.") + +(defsubst geiser-completion--locals () + (geiser-syntax--locals-around-point geiser-completion--binding-forms + geiser-completion--binding-forms*)) + +(defun geiser-completion--symbol-list (prefix) + (geiser--del-dups + (append (all-completions prefix (geiser-completion--locals)) + (geiser-eval--send/result `(:eval (:ge completions ,prefix)))))) + +(defsubst geiser-completion--module-list (prefix) + (geiser-eval--send/result `(:eval (:ge module-completions ,prefix)))) + +(defvar geiser-completion-module-list-func + (if (= emacs-major-version 25) + (completion-table-dynamic 'geiser-completion--module-list t) + (completion-table-dynamic 'geiser-completion--module-list))) + +(defvar geiser-completion-symbol-list-func + (if (< emacs-major-version 25) + (completion-table-dynamic 'geiser-completion--symbol-list t))) + +(defun geiser-completion--complete (prefix modules) + (if modules (geiser-completion--module-list prefix) + (geiser-completion--symbol-list prefix))) + +(defvar geiser-completion--symbol-history nil) + +(defun geiser-completion--read-symbol (prompt &optional default history) + (let ((minibuffer-local-completion-map geiser-completion--minibuffer-map)) + (make-symbol (completing-read prompt + geiser-completion-symbol-list-func + nil nil nil + (or history + geiser-completion--symbol-history) + (or default (geiser--symbol-at-point)))))) + +(defvar geiser-completion--module-history nil) + +(defun geiser-completion--read-module (&optional prompt default history) + (let ((minibuffer-local-completion-map + geiser-completion--module-minibuffer-map)) + (completing-read (or prompt "Module name: ") + geiser-completion-module-list-func + nil nil nil + (or history geiser-completion--module-history) + default))) + +(defvar geiser-completion--symbol-begin-function nil) + +(defun geiser-completion--def-symbol-begin (module) + (save-excursion (skip-syntax-backward "^-()>") (point))) + +(geiser-impl--register-local-method + 'geiser-completion--symbol-begin-function 'find-symbol-begin + 'geiser-completion--def-symbol-begin + "An optional function finding the position of the beginning of +the identifier around point. Takes a boolean, indicating whether +we're looking for a module name.") + +(defun geiser-completion--symbol-begin (module) + (funcall geiser-completion--symbol-begin-function module)) + +(defun geiser-completion--module-at-point () + (save-excursion + (goto-char (geiser-completion--symbol-begin t)) + (ignore-errors (thing-at-point 'sexp)))) + +(defsubst geiser-completion--prefix (module) + (buffer-substring-no-properties (geiser-completion--symbol-begin module) + (point))) + +(defsubst geiser-completion--prefix-end (beg mod) + (unless (or (eq beg (point-max)) + (member (char-syntax (char-after beg)) + (if mod '(?\" ?\)) '(?\" ?\( ?\))))) + (let ((pos (point))) + (condition-case nil + (save-excursion + (goto-char beg) + (forward-sexp 1) + (when (>= (point) pos) + (point))) + (scan-error pos))))) + +(defun geiser-completion--thing-at-point (module &optional predicate) + (with-syntax-table scheme-mode-syntax-table + (let* ((beg (geiser-completion--symbol-begin module)) + (end (or (geiser-completion--prefix-end beg module) beg)) + (prefix (and (> end beg) (buffer-substring-no-properties beg end))) + (prefix (and prefix + (if (string-match "\\([^-]+\\)-" prefix) + (match-string 1 prefix) + prefix))) + (cmps (and prefix (geiser-completion--complete prefix module)))) + (and cmps (list beg end cmps))))) + +(defun geiser-completion--for-symbol (&optional predicate) + (geiser-completion--thing-at-point nil predicate)) + +(defun geiser-completion--for-module (&optional predicate) + (geiser-completion--thing-at-point t predicate)) + +(defun geiser-completion--for-filename () + (when (geiser-syntax--in-string-p) + (let ((comint-completion-addsuffix "\"")) + (comint-dynamic-complete-filename)))) + +(defun geiser-completion--setup (enable) + (set (make-local-variable 'completion-at-point-functions) + (if enable + '(geiser-completion--for-symbol + geiser-completion--for-module + geiser-completion--for-filename) + (default-value 'completion-at-point-functions)))) + +(defun geiser-completion--complete-module () + "Complete module name at point." + (interactive) + (let ((completion-at-point-functions '(geiser-completion--for-module))) + (call-interactively 'completion-at-point))) + + +;;; Smart tab mode: + +(make-variable-buffer-local + (defvar geiser-smart-tab-mode-string " SmartTab" + "Modeline indicator for geiser-smart-tab-mode")) + +(define-minor-mode geiser-smart-tab-mode + "Toggle smart tab mode. +With no argument, this command toggles the mode. +Non-null prefix argument turns on the mode. +Null prefix argument turns off the mode. + +When this mode is enable, TAB will indent if at point is at +beginning of line or after a white space or closing parenthesis, +and will try completing symbol at point otherwise." + :init-value nil + :lighter geiser-smart-tab-mode-string + :group 'geiser-mode + (set (make-local-variable 'tab-always-indent) + (if geiser-smart-tab-mode + 'complete + (default-value 'tab-always-indent)))) + + +(provide 'geiser-completion) diff --git a/elpa/geiser-20200225.1423/geiser-completion.elc b/elpa/geiser-20200225.1423/geiser-completion.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-connection.el b/elpa/geiser-20200225.1423/geiser-connection.el diff --git a/elpa/geiser-20200214.110/geiser-connection.elc b/elpa/geiser-20200225.1423/geiser-connection.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-custom.el b/elpa/geiser-20200225.1423/geiser-custom.el diff --git a/elpa/geiser-20200214.110/geiser-custom.elc b/elpa/geiser-20200225.1423/geiser-custom.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-debug.el b/elpa/geiser-20200225.1423/geiser-debug.el diff --git a/elpa/geiser-20200214.110/geiser-debug.elc b/elpa/geiser-20200225.1423/geiser-debug.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-doc.el b/elpa/geiser-20200225.1423/geiser-doc.el diff --git a/elpa/geiser-20200214.110/geiser-doc.elc b/elpa/geiser-20200225.1423/geiser-doc.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-edit.el b/elpa/geiser-20200225.1423/geiser-edit.el diff --git a/elpa/geiser-20200214.110/geiser-edit.elc b/elpa/geiser-20200225.1423/geiser-edit.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-eval.el b/elpa/geiser-20200225.1423/geiser-eval.el diff --git a/elpa/geiser-20200214.110/geiser-eval.elc b/elpa/geiser-20200225.1423/geiser-eval.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-gambit.el b/elpa/geiser-20200225.1423/geiser-gambit.el diff --git a/elpa/geiser-20200214.110/geiser-gambit.elc b/elpa/geiser-20200225.1423/geiser-gambit.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-guile.el b/elpa/geiser-20200225.1423/geiser-guile.el diff --git a/elpa/geiser-20200214.110/geiser-guile.elc b/elpa/geiser-20200225.1423/geiser-guile.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-image.el b/elpa/geiser-20200225.1423/geiser-image.el diff --git a/elpa/geiser-20200214.110/geiser-image.elc b/elpa/geiser-20200225.1423/geiser-image.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-impl.el b/elpa/geiser-20200225.1423/geiser-impl.el diff --git a/elpa/geiser-20200214.110/geiser-impl.elc b/elpa/geiser-20200225.1423/geiser-impl.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-log.el b/elpa/geiser-20200225.1423/geiser-log.el diff --git a/elpa/geiser-20200214.110/geiser-log.elc b/elpa/geiser-20200225.1423/geiser-log.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-menu.el b/elpa/geiser-20200225.1423/geiser-menu.el diff --git a/elpa/geiser-20200214.110/geiser-menu.elc b/elpa/geiser-20200225.1423/geiser-menu.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-mit.el b/elpa/geiser-20200225.1423/geiser-mit.el diff --git a/elpa/geiser-20200214.110/geiser-mit.elc b/elpa/geiser-20200225.1423/geiser-mit.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-mode.el b/elpa/geiser-20200225.1423/geiser-mode.el diff --git a/elpa/geiser-20200214.110/geiser-mode.elc b/elpa/geiser-20200225.1423/geiser-mode.elc Binary files differ. diff --git a/elpa/geiser-20200225.1423/geiser-pkg.el b/elpa/geiser-20200225.1423/geiser-pkg.el @@ -0,0 +1,4 @@ +(define-package "geiser" "20200225.1423" "GNU Emacs and Scheme talk to each other" 'nil :url "http://www.nongnu.org/geiser/") +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/elpa/geiser-20200214.110/geiser-popup.el b/elpa/geiser-20200225.1423/geiser-popup.el diff --git a/elpa/geiser-20200214.110/geiser-popup.elc b/elpa/geiser-20200225.1423/geiser-popup.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-racket.el b/elpa/geiser-20200225.1423/geiser-racket.el diff --git a/elpa/geiser-20200214.110/geiser-racket.elc b/elpa/geiser-20200225.1423/geiser-racket.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-reload.el b/elpa/geiser-20200225.1423/geiser-reload.el diff --git a/elpa/geiser-20200214.110/geiser-reload.elc b/elpa/geiser-20200225.1423/geiser-reload.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-repl.el b/elpa/geiser-20200225.1423/geiser-repl.el diff --git a/elpa/geiser-20200214.110/geiser-repl.elc b/elpa/geiser-20200225.1423/geiser-repl.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-syntax.el b/elpa/geiser-20200225.1423/geiser-syntax.el diff --git a/elpa/geiser-20200214.110/geiser-syntax.elc b/elpa/geiser-20200225.1423/geiser-syntax.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-table.el b/elpa/geiser-20200225.1423/geiser-table.el diff --git a/elpa/geiser-20200214.110/geiser-table.elc b/elpa/geiser-20200225.1423/geiser-table.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-version.el b/elpa/geiser-20200225.1423/geiser-version.el diff --git a/elpa/geiser-20200214.110/geiser-version.elc b/elpa/geiser-20200225.1423/geiser-version.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser-xref.el b/elpa/geiser-20200225.1423/geiser-xref.el diff --git a/elpa/geiser-20200214.110/geiser-xref.elc b/elpa/geiser-20200225.1423/geiser-xref.elc Binary files differ. diff --git a/elpa/geiser-20200214.110/geiser.el b/elpa/geiser-20200225.1423/geiser.el diff --git a/elpa/geiser-20200214.110/geiser.elc b/elpa/geiser-20200225.1423/geiser.elc Binary files differ. diff --git a/elpa/geiser-20200225.1423/geiser.info b/elpa/geiser-20200225.1423/geiser.info @@ -0,0 +1,1925 @@ +This is geiser.info, produced by makeinfo version 6.5 from geiser.texi. + +This manual documents Geiser, an Emacs environment to hack in Scheme. + + Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018, 2020 +Jose Antonio Ortega Ruiz + + Permission is granted to copy, distribute and/or modify this + document under the terms of the GNU Free Documentation License, + Version 1.3 or any later version published by the Free Software + Foundation; with no Invariant Sections, no Front-Cover Texts, and + no Back-Cover Texts. A copy of the license is available from the + Free Software Foundation Web site at + <http://www.gnu.org/licenses/fdl.html>. + + The document was typeset with GNU Texinfo +(http://www.gnu.org/software/texinfo/index.html). +INFO-DIR-SECTION Emacs +START-INFO-DIR-ENTRY +* Geiser: (geiser). Emacs environment for Scheme hacking. +END-INFO-DIR-ENTRY + + +File: geiser.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) + +Geiser +****** + +This manual documents Geiser, an Emacs environment to hack in Scheme. + + Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2018, 2020 +Jose Antonio Ortega Ruiz + + Permission is granted to copy, distribute and/or modify this + document under the terms of the GNU Free Documentation License, + Version 1.3 or any later version published by the Free Software + Foundation; with no Invariant Sections, no Front-Cover Texts, and + no Back-Cover Texts. A copy of the license is available from the + Free Software Foundation Web site at + <http://www.gnu.org/licenses/fdl.html>. + + The document was typeset with GNU Texinfo +(http://www.gnu.org/software/texinfo/index.html). + +* Menu: + +* Introduction:: +* Installation:: +* The REPL:: +* Between the parens:: +* Cheat sheet:: +* No hacker is an island:: +* Index:: + + -- The Detailed Node Listing -- + +Introduction + +* Modus operandi:: +* Showing off:: + +Installation + +* Must needs:: +* The easy and quick way:: +* From the source's mouth:: +* Chicken installation:: +* Gambit installation:: +* Friends:: + +The REPL + +* Starting the REPL:: +* First aids:: +* Switching context:: +* Completion and error handling:: +* Autodoc and friends:: +* Seeing is believing:: +* Customization and tips:: + +Between the parens + +* Activating Geiser:: +* The source and the REPL:: +* Documentation helpers:: +* To eval or not to eval:: +* To err perchance to debug:: +* Jumping around:: +* Geiser writes for you:: + +Cheat sheet + +* Scheme buffers:: +* REPL:: +* Documentation browser:: + + + Geiser is a collection of Emacs major and minor modes that conspire +with one or more Scheme interpreters to keep the Lisp Machine Spirit +alive. It draws inspiration (and a bit more) from environments such as +Common Lisp's Slime, Factor's FUEL, Squeak or Emacs itself, and does its +best to make Scheme hacking inside Emacs (even more) fun. + + Or, to be precise, what i (https://jao.io) consider fun. Geiser is +thus my humble contribution to the dynamic school of expression, and a +reaction against what i perceive as a derailment, in modern times, of +standard Scheme towards the static camp. Because i prefer growing and +healing to poking at corpses, the continuously running Scheme +interpreter takes the center of the stage in Geiser. A bundle of Elisp +shims orchestrates the dialog between the Scheme interpreter, Emacs and, +ultimately, the schemer, giving her access to live metadata. Here's +how. + + +File: geiser.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top + +1 Introduction +************** + +Geiser is an Emacs environment to hack and have fun in Scheme. If +that's enough for you, see *note Installation:: to get it running and +*note The REPL:: for the fun part. + +* Menu: + +* Modus operandi:: +* Showing off:: + + +File: geiser.info, Node: Modus operandi, Next: Showing off, Prev: Introduction, Up: Introduction + +1.1 Modus operandi +================== + +As already mentioned, Geiser relies on a running Scheme process to +obtain the information it makes accessible to the programmer. There's +little effort, on the Elisp side, to understand, say, the module system +used by the Scheme implementation at hand; instead, a generic interface +between the two worlds is defined, and each supported Scheme includes a +library implementing that API, together with some wee shims in Elisp +allowing the reuse of the Emacs-side framework, which constitutes the +bulk of the code. + + While being as generic as possible, the Scheme-Elisp interface makes +some assumptions about the capabilities and interaction mode of the +corresponding REPL. In particular, Geiser expects the latter to support +namespaces in the form of a module system, and to provide a well-defined +way to establish the REPL's current namespace (or module), as well as +the current file's module (or namespace). Thus, all evaluations +performed by Geiser either in the REPL or in a source code buffer happen +in the context of the current namespace. Every time you switch to a +different file, you're switching namespaces automatically; at the REPL, +you must request the switch explicitly (usually just using means +provided by the Scheme implementation itself). + + If your favourite Scheme supports the above modus operandi, it has +all that's needed for a bare-bones Geiser mode. But Geiser can, and +will, use any metadata available: procedure arities and argument lists +to display interactive help, documentation strings, location information +to jump to definitions, export lists to provide completion, and so on +and so forth. Although this is not an all-or-none proposition (Geiser +can operate with just part of that functionality available), i initially +concentrated in supporting those Schemes with the richest (to my +knowledge) introspection capabilities, namely, Guile and Racket. Later +on, Dan Leslie added support for Chicken, and there's active work to add +support for scsh. + + +File: geiser.info, Node: Showing off, Prev: Modus operandi, Up: Introduction + +1.2 Showing off +=============== + +When working with a fully conniving Scheme, Geiser can offer the +following functionality: + + * Form evaluation in the context of the current file's module. + * Macro expansion. + * File/module loading and/or compilation. + * Namespace-aware identifier completion (including local bindings, + names visible in the current module, and module names). + * Autodoc: the echo area shows information about the signature of the + procedure/macro around point automatically. + * Jump to definition of identifier at point. + * Access to documentation (including docstrings when the + implementation provides it). + * Listings of identifiers exported by a given module. + * Listings of callers/callees of procedures. + * Rudimentary support for debugging (when the REPL provides a + debugger) and error navigation. + * Support for multiple, simultaneous REPLs. + * Support for image display in those Schemes that treat them as first + class values. + + In the following pages, i'll try to explain what these features +actually are (i'm just swanking here), and how to use them for your +profit. But, before that, let's see how to install Geiser. + + +File: geiser.info, Node: Installation, Next: The REPL, Prev: Introduction, Up: Top + +2 Installation +************** + +* Menu: + +* Must needs:: +* The easy and quick way:: +* Chicken installation:: +* Gambit installation:: +* From the source's mouth:: +* Friends:: + + +File: geiser.info, Node: Must needs, Next: The easy and quick way, Prev: Installation, Up: Installation + +2.1 Must needs +============== + +If Geiser came with any guarantees, you'd break all of them by not using +GNU Emacs 24 (or better: i regularly use it with a recent Emacs +snapshot) and at least one of the supported Schemes, namely: + + * Guile (http://www.gnu.org/software/guile) 2.2 or better + * Chicken (http://call-cc.org) 4.8.0 or better + * MIT/GNU Scheme (https://www.gnu.org/software/mit-scheme/) 9.1 or + better + * Chibi Scheme (http://synthcode.com/scheme/chibi/) 0.7 or better + * Chez Scheme (http://www.scheme.com) 9.4 or better + * Gambit (http://gambitscheme.org/wiki/index.php/Main_Page) 4.9 or + better + * Racket (http://www.racket-lang.org) 6.0 or better + + Since Geiser supports multiple REPLs, having all of them will just +add to the fun. + + You'll also need Geiser itself. The quickest installation is via its +ELPA package, as described in the next section. If you prefer to use +the source code directly, it's not that difficult either: just keep on +reading. + + +File: geiser.info, Node: The easy and quick way, Next: Chicken installation, Prev: Must needs, Up: Installation + +2.2 The easy and quick way +========================== + +Did i mention that the easiest way of installing Geiser is using its +ELPA (http://emacswiki.org/emacs/ELPA) package? If you're using Emacs +24, ELPA (http://emacswiki.org/emacs/ELPA) is already there; for earlier +versions, the page i just linked to twice will tell you where to find +the goodies. + + ELPA packages live in repositories accessible via HTTP. You can find +Geiser's package in either MELPA stable +(http://stable.melpa.org/#/geiser) or, if you like living on the +bleeding edge, MELPA (http://melpa.org/#/geiser) (directly from the git +repo). To tell Emacs that an ELPA repo exists, you add it to +'package-archives': + + (require 'package) + ;;; either the stable version: + + (add-to-list 'package-archives + ;; choose either the stable or the latest git version: + ;; '("melpa-stable" . "http://stable.melpa.org/packages/") + '("melpa-unstable" . "http://melpa.org/packages/")) + + (package-initialize) + + And then installing Geiser is as easy as: + + M-x package-install RET geiser RET + + Unless you are using Gambit or Chicken, with that, you are pretty +much all set up. See *note The REPL:: to start using Geiser. If you +plan to use Chicken or Gambit, just keep reading below for a few +additional instructions to set up your environment. + + +File: geiser.info, Node: Chicken installation, Next: Gambit installation, Prev: The easy and quick way, Up: Installation + +2.3 Chicken installation +======================== + +If you plan to use Chicken, you'll need also to fire a terminal and +configure a couple of Chicken eggs. For Chicken 4 that would be: + $ chicken-install -s apropos chicken-doc + $ cd `csi -p '(chicken-home)'` + $ curl http://3e8.org/pub/chicken-doc/chicken-doc-repo.tgz | sudo tar zx + + while Chicken 5 prefers: + $ chicken-install -s apropos chicken-doc srfi-18 srfi-1 + $ cd `csi -R chicken.platform -p '(chicken-home)'` + $ curl https://3e8.org/pub/chicken-doc/chicken-doc-repo-5.tgz | sudo tar zx + + (see also Chicken's wiki (https://wiki.call-cc.org/emacs#geiser)). + + +File: geiser.info, Node: Gambit installation, Next: From the source's mouth, Prev: Chicken installation, Up: Installation + +2.4 Gambit installation +======================= + +If you plan to use Gambit, you'll also need to open a terminal and +configure a couple of awesome Gambit's features: + + 1. Clone the last version of gambit and of this repo + 2. Configure Gambit using '--enable-rtlib-debug-source' to activate + autodoc + $ cd ~/ + $ git clone "the gambit repo current address" + $ cd gambit + $ ./configure --enable-single-host --enable-debug --enable-rtlib-debug-source + $ make bootstrap + $ make bootclean + $ make -j + $ make install + 3. Put a link to 'geiser/elisp/geiser.el' in your init file in your + init file paste : + (load-file "~/geiser/elisp/geiser.el") + (the path is your path to geiser.el.) + + And, if you also want to use a remote Gambit REPL: + + 1. Enable the gambit/geiser module: + $ mkdir ~/gambit/lib/gambit/geiser + $ cp ~/geiser/geiser-module/* ~/gambit/lib/geiser/ + 2. Now that you have the module you start gsi with it and using the + '-:d' option: + $ gsi -:d gambit/geiser - + 3. You can now open emacs and call + M-x geiser-connect gambit + Enjoy! + + By the way, if you are unable to use gambit modules, open gsi with +the 'gambit.scm' file located in +'geiser/scheme/gambit/geiser/gambit.scm'; something like: + gsi -:d ~/geiser/scheme/gambit/geiser/gambit.scm - + (Keep in mind that these paths may be a little different for you.) + + +File: geiser.info, Node: From the source's mouth, Next: Friends, Prev: Gambit installation, Up: Installation + +2.5 Installing from source +========================== + +Downloading Geiser +.................. + +The latest release tarballs can be found here +(https://gitlab.com/jaor/geiser/-/releases). + + If you feel like living on the bleeding edge, just grab Geiser from +its Git repository over at Savannah +(http://git.savannah.nongnu.org/cgit/geiser.git/), either with the +following incantation: + + git clone git://git.sv.gnu.org/geiser.git + +or, if you happen to live behind a firewall, with the alternative: + + git clone http://git.sv.gnu.org/r/geiser.git + +You can also follow Geiser's development in one +(https://gitlab.com/jaor/geiser) or (http://repo.or.cz/w/geiser.git) +three (http://gitorious.org/geiser) mirrors that are kept synchronized +with the one at Savannah. + + Either way, you'll now be in possession of a copy of Geiser's libre +code. I'll follow you into its directory and the next section. + +Setting it up +............. + +Geiser is ready to be used out of the box without much more ado. For +the sake of concreteness, let's assume you put its source in the +directory '~/lisp/geiser'. All you need to do is to add the following +line to your Emacs initialisation file (be it '~/.emacs', +'~/.emacs.d/init.el' or any of its moral equivalents): + + (load-file "~/lisp/geiser/elisp/geiser.el") + +or simply evaluate that form inside Emacs (you wouldn't kill a friend +just to start using Geiser, would you?). That's it: you're ready to go +(*note The REPL::). + + What? You still here? I promise the above is all that's needed to +start using Geiser. But, in case you are missing your configure/make +all install routine, by all means, you can go through those motions to +byte compile and install Geiser too. That is, you enter the source +directory and (since we grabbed the development tree) run the customary +autogen script: + + $ cd ~/lisp/geiser + $ ./autogen.sh + +I recommend that you compile Geiser in a separate directory: + + $ mkdir build && cd build + $ ../configure + <some drivel here> + $ make all + <more of the above> + + Now you have two options: loading the byte-compiled Geiser from the +'elisp' subdirectory, or installing it system-wide. To load the +byte-code from here, add this line to your initialisation file: + + (load "~/lisp/geiser/build/elisp/geiser-load") + +and eval that form and you're done (you could also restart Emacs, but +killing your friends is widely considered bad form). Yes, that's 'load' +and 'geiser-load' instead of 'load-file' and 'geiser.el'. + + If you prefer a system-wide installation, just type: + + $ sudo make install + + With the above spell, Geiser will be compiled and installed in a safe +place inside Emacs' load path. To load it into Emacs you'll need, +instead of the 'load-file' form above, the following line in your +initialisation file: + + (require 'geiser-install) + +Please note that we're requiring 'geiser-install', and not 'geiser', and +that there's no 'load-file' to be seen this time. There are some ways +of fine-tuning this process, mainly by providing additional arguments in +the call to configure: you'll find those gory details in the file called +'INSTALL', right at the root of the source tree. The installation will +also take care of placing this manual, in Info format, where Emacs can +find it, so you can continue to learn about Geiser inside its natural +habitat. See you there and into the next chapter! + + +File: geiser.info, Node: Friends, Prev: From the source's mouth, Up: Installation + +2.6 Friends +=========== + +Although Geiser does not need them, it plays well with (and is enhanced +by) the following Emacs packages: + + * Paredit (http://www.emacswiki.org/emacs/ParEdit). Regardless of + whether you use Geiser or not, you shouldn't be coding in any Lisp + dialect without the aid of Taylor Campbell's structured editing + mode. + * Company (http://company-mode.github.io/). Nikolaj Schumacher's and + Dmitry Gutov's 'company-mode' provides a generic front-end for + completion engines (such as Geiser's), with pretty and automatic + completion lists. + * ac-geiser (https://github.com/xiaohanyu/ac-geiser/) If you prefer + 'auto-complete-mode' to 'company-mode', Xiao Hanyu's 'ac-geiser', + which provides a Geiser plugin for the popular Emacs Auto + Completion Mode (https://www.emacswiki.org/emacs/AutoComplete), is + the package for you. Like Geiser, 'ac-geiser' is available in + MELPA, and also as an 'el-get' package. + +You just need to install and setup them as usual, for every package's +definition of usual. Geiser will notice their presence and react +accordingly. + + +File: geiser.info, Node: The REPL, Next: Between the parens, Prev: Installation, Up: Top + +3 The REPL +********** + +If you've followed the instructions in *note Installation::, your Emacs +is now ready to start playing. Otherwise, i'll wait for you: when +you're ready, just come back here and proceed to the following sections. + +* Menu: + +* Starting the REPL:: +* First aids:: +* Switching context:: +* Completion and error handling:: +* Autodoc and friends:: +* Seeing is believing:: +* Customization and tips:: + + +File: geiser.info, Node: Starting the REPL, Next: First aids, Prev: The REPL, Up: The REPL + +3.1 Starting the REPL +===================== + +To start a Scheme REPL (meaning, a Scheme process offering you a +Read-Eval-Print Loop), Geiser provides the generic interactive command +'run-geiser'. If you invoke it (via, as is customary in Emacs, 'M-x +run-geiser'), you'll be saluted by a prompt asking which one of the +supported implementations you want to launch--yes, you can stop the +asking, see *note below: active-implementations. Tabbing for completion +will offer you, as of this writing, 'guile', 'racket', 'chicken', 'mit', +'chibi' and 'chez'. Just choose your poison, and a new REPL buffer will +pop up (by default, the REPL will appear in a new window: if that annoys +you, just set 'geiser-repl-use-other-window' to 'nil' and the current +window will be used). + + If all went according to plan, you'll be facing an +implementation-dependent banner, followed by an interactive prompt. +Going according to plan includes having the executable of the Scheme you +chose in your path. If that's not the case, you can tell Emacs where it +is, as described in *note a moment: impl-binary. Returning to our REPL, +the first thing to notice is that the funny prompt is telling you your +current module: its name is the part just after the @ sign (in Guile, +that means 'guile-user', while Racket's and Chicken's top namespaces +don't have a name; cf. discussion in *note Switching context::). Other +than that, this is pretty much equivalent to having a command-line +interpreter in a terminal, with a bunch of add-ons that we'll be +reviewing below. You can start typing sexps right there: Geiser will +only dispatch them for evaluation when they're complete, and will indent +new lines properly until then. It will also keep track of your input, +maintaining a history file that will be reloaded whenever you restart +the REPL. + + If you're not happy with the faces Geiser is using for the REPL's +prompt and evaluated input, you can customise +'geiser-font-lock-repl-prompt' and 'geiser-font-lock-repl-input' to +better-looking faces. + +Connecting to an external Scheme +................................ + +There's an alternative way of starting a Geiser REPL: you can connect to +an external Scheme process, provided it's running a REPL server at some +known port. How to make that happen depends on the Scheme +implementation. + + If you use Guile, you just need to start your Guile process (possibly +outside Emacs) passing to it the flag '--listen'. This flag accepts an +optional port as argument (as in '--listen=1969'), if you don't want to +use the default. + + In Racket, you have to use the REPL server that comes with Geiser. +To that end, put Geiser's Racket 'scheme' directory in Racket's +collection search path and invoke 'start-geiser' (a procedure in the +module 'geiser/server') somewhere in your program, passing it the +desired port and, if desired, network interface name. This procedure +will start the REPL server in a separate thread. For an example of how +to do that, see the script 'bin/geiser-racket.sh' in the source +distribution, or, if you've compiled Geiser, 'bin/geiser-racket-noinst' +in the build directory, or, if you've installed Geiser, 'geiser-racket' +in '<installation-prefix>/bin'. These scripts start a new interactive +Racket that is also running a REPL server (they also load the errortrace +library to provide better diagnostics, but that's not strictly needed). + + With your external Scheme process running and serving, come back to +Emacs and execute 'M-x geiser-connect', 'M-x connect-to-guile' or 'M-x +connect-to-racket'. You'll be asked for a host and a port, and, voila, +you'll have a Geiser REPL that is served by the remote Scheme process in +a dedicated thread, meaning that your external program can go on doing +whatever it was doing while you tinker with it from Emacs. Note, +however, that all Scheme threads share the heap, so that you'll be able +to interact with those other threads in the running Scheme from Emacs in +a variety of ways. For starters, all your (re)definitions will be +visible everywhere. That's dangerous, but will come in handy when you +need to debug your running web server. + + The connection between Emacs and the Scheme process goes over TCP, so +it can be as remote as you need, perhaps with the intervention of an SSH +tunnel. + + +File: geiser.info, Node: First aids, Next: Switching context, Prev: Starting the REPL, Up: The REPL + +3.2 First aids +============== + +A quick way of seeing what else Geiser's REPL can do for you, is to +display the corresponding entry up there in your menu bar. No, i don't +normally use menus either; but they can come in handy until you've +memorized Geiser's commands, as a learning device. And yes, i usually +run Emacs inside a terminal, but one can always use La Carte +(http://www.emacswiki.org/emacs/LaCarte) to access the menus in a +convenient enough fashion. + + Or just press 'C-h m' and be done with that. + + Among the commands at your disposal, we find the familiar input +navigation keys, with a couple twists. By default, 'M-p' and 'M-n' are +bound to matching items in your input history. That is, they'll find +the previous or next sexp that starts with the current input prefix +(defined as the text between the end of the prompt and your current +position, a.k.a. "point", in the buffer). For going up and down the +list unconditionally, just use 'C-c M-p' and 'C-c M-n'. In addition, +navigation is sexp-based rather than line-based. + + There are also a few commands to twiddle with the Scheme process. +'C-c C-q' will gently ask it to quit, while 'C-u C-c C-q' will +mercilessly kill the process (but not before stowing your history in the +file system). Unless you're using a remote REPL, that is, in which case +both commands will just sever the connection and leave the remote +process alone. If worse comes to worst and the process is dead, 'C-c +C-z' will restart it. However, the same shortcut, issued when the REPL +is alive, will bring you back to the buffer you came from, as explained +in *note this section: switching-repl-buff. + + The remaining commands are meatier, and deserve sections of their +own. + + +File: geiser.info, Node: Switching context, Next: Completion and error handling, Prev: First aids, Up: The REPL + +3.3 Switching context +===================== + +In tune with Geiser's modus operandi, evaluations in the REPL take place +in the namespace of the current module. As noted above, the REPL's +prompt tells you the name of the current module. To switch to a +different one, you can use the command 'switch-to-geiser-module', bound +to 'C-c C-m'. You'll notice that Geiser simply uses a couple of +meta-commands provided by the Scheme REPL (the stock ',m' in Guile and +Chicken and the (geiser-defined) ',enter' in Racket), and that it +doesn't even try to hide that fact. That means that you can freely use +said native ways directly at the REPL, and Geiser will be happy to +oblige. In Racket, ',enter' works like Racket's standard 'enter!' form, +but you can also provide a path string as its argument (e.g., ',enter +"/tmp/foo.rkt"' is equivalent to ',enter (file "/tmp/foo.rkt")'). Like +'enter!', ',enter' accepts also module names (as in, say, ',enter +geiser/main'). As mentioned, in Guile and Chicken, ',m' is used as is. + + Once you enter a new module, only those bindings visible in its +namespace will be available to your evaluations. All Schemes supported +by Geiser provide a way to import new modules in the current namespace. +Again, there's a Geiser command, 'geiser-repl-import-module', to invoke +such functionality, bound this time to 'C-c C-i'. And, again, you'll +see Geiser just introducing the native incantation for you, and you're +free to use such incantations by hand whenever you want. + + One convenience provided by these two Geiser commands is that +completion is available when introducing the new module name, using the +'<TAB>' key. Pressing it at the command's prompt will offer you a +prefix-aware list of available module names. + + Which brings me to the next group of REPL commands. + + +File: geiser.info, Node: Completion and error handling, Next: Autodoc and friends, Prev: Switching context, Up: The REPL + +3.4 Completion and error handling +================================= + +We've already seen Geiser completion of module names in action at the +minibuffer. You won't be surprised to know that it's also available at +the REPL buffer itself. There, you can use either 'C-.' or 'M-`' to +complete module names, and '<TAB>' or 'M-<TAB>' to complete identifiers. +Geiser will know what identifiers are bound in the current module and +show you a list of those starting with the prefix at point. Needless to +say, this is not a static list, and it will grow as you define or import +new bindings in the namespace at hand. If no completion is found, +'<TAB>' will try to complete the prefix after point as a module name. + + REPL buffers use Emacs' compilation mode to highlight errors reported +by the Scheme interpreter, and you can use the 'next-error' command +('M-g n') to jump to their location. By default, every time you enter a +new expression for evaluation old error messages are forgotten, so that +'M-g n' will always jump to errors related to the last evaluation +request, if any. If you prefer a not-so-forgetful REPL, set the +customization variable 'geiser-repl-forget-old-errors-p' to 'nil'. +Note, however, that even when that variable is left as 't', you can +always jump to an old error by moving to its line at the REPL and +pressing '<RET>'. When your cursor is away from the last prompt, +'<TAB>' will move to the next error in the buffer, and you can use +'<BACKTAB>' everywhere to go to the previous one. + +Caveat about completion & the REPL +---------------------------------- + +It is possible for Geiser to hang your Emacs process when trying to +complete symbols. This can happen in the REPL itself or even in a +Scheme buffer that is attached to the REPL process. If this happens, +you've probably entered a module that changes the REPL prompt from what +Geiser was expecting to see. + + Unfortunately, there's no general solution for this issue right now +(as it is a daunting task to try to make a regexp that can encompass all +possible REPL prompts). The best solution for now is to fix this issue +on a case-by-case basis by adjusting your prompt regexp variable so that +it matches the default prompt as well as your Scheme module's special +prompt. + + For example, XREPL is a Racket module that implements a better Racket +REPL. You might be interested in toying around with some of its +functions, but when you try to enter XREPL via, say, 'C-c C-m xrepl', +you'll notice that the REPL prompt has changed to something like this: + + <pkgs>/xrepl-lib/xrepl/main> + + If you start typing symbols, and then you try to auto-complete those +symbols, your Emacs process may hang. This is because Geiser expects +the REPL prompt to match this regexp (for Racket): + + "\\(mzscheme\\|racket\\)@[^ ]*> " + + Therefore, we can fix this issue by changing our default prompt +regexp like so: + + (setq geiser-racket--prompt-regexp "<pkgs>.*> \\|\\(mzscheme\\|racket\\)@[^ ]*> ") + + Note that you may have to run 'M-x geiser-reload' after setting this +variable so that your changes will take effect. + + Again, you'll have to change the regexp to fit every prompt that +causes this issue, but the only alternative (that we can think of right +now) is to create a regexp that will match every possible prompt. +Obviously, that is going to be more than a little tricky. However, if +you have a better solution than that, please share it with the Geiser +developers; we'll be more than happy to hear it. + + +File: geiser.info, Node: Autodoc and friends, Next: Seeing is believing, Prev: Completion and error handling, Up: The REPL + +3.5 Autodoc and friends +======================= + +Oftentimes, there's more you'll want to know about an identifier besides +its name: What module does it belong to? Is it a procedure and, if so, +what arguments does it take? Geiser tries to help you answering those +questions too. + + Actually, if you've been playing with the REPL as you read, you might +have notice some frantic activity taking place in the echo area every +now and then. That was Geiser trying to be helpful (while, hopefully, +not being clippy), or, more concretely, what i call, for want of a +better name, its "autodoc" mode. Whenever it's active (did you notice +that A in the mode-line?), Geiser's gerbils will be scanning what you +type and showing (unless you silence them with 'C-c C-d C-a') +information about the identifier nearest to point. + + If that identifier corresponds to a variable visible in the current +namespace, you'll see the module it belongs to and its value. For +procedures and macros, autodoc will display, instead of their value, the +argument names (or an underscore if Geiser cannot determine the name +used in the definition). Optional arguments are surrounded by +parentheses. When the optional argument has a default value, it's +represented by a list made up of its name and that value. When the +argument is a keyword argument, its name has "#:" as a prefix. + + If that's not enough documentation for you, 'C-c C-d d' will open a +separate documentation buffer with help on the symbol at point. This +buffer will contain implementation-specific information about the +identifier (e.g., its docstring for Guile, or its contract, if any, for +Racket), and a handy button to open the corresponding manual entry for +the symbol, which will open an HTML page (for Racket and Chicken) or the +texinfo manual (for Guile). If you'd rather go directly to the manual, +try 'C-c C-d i', which invokes 'geiser-doc-look-up-manual' as the handy +button does. + + Geiser can also produce for you a list, classified by kind, of the +identifiers exported by a given module: all you need to do is press 'C-c +C-d m', and type or complete the desired module's name. + + The list of exported bindings is shown, again, in a buffer belonging +to Geiser's documentation browser, where you have at your disposal a +bunch of navigation commands listed in *note our cheat-sheet: +Documentation browser. + + We'll have a bit more to say about the documentation browser in *note +a later section: doc-browser. + + If that's still not enough, Geiser can jump, via 'M-.', to the +symbol's definition. A buffer with the corresponding file will pop up, +with its point resting upon the identifier's defining form. When you're +done inspecting, 'M-,' will bring you back to where you were. As we +will see, these commands are also available in Scheme buffers. 'M-.' +also works for modules: if your point is on an unambiguous module name, +the file where it's defined will be opened for you. + + +File: geiser.info, Node: Seeing is believing, Next: Customization and tips, Prev: Autodoc and friends, Up: The REPL + +3.6 Seeing is believing +======================= + +In schemes that support images as values (currently, that means Racket), +the REPL will display them inline if you're using them in a +graphics-aware Emacs. + + For the terminal, images will appear as buttons: press return on them +to invoke an external viewer (configurable via 'geiser-image-viewer') +that will show you the image at hand. You can also ask for the same +behaviour on all emacsen by customising 'geiser-repl-inline-images-p' to +'nil'. + + Geiser keeps a cache of the last displayed images in the directory +'geiser-image-cache-dir', which defaults to the system's temp directory, +with up to 'geiser-image-cache-keep-last' files. You can invoke the +external image viewer on any of them with 'M-x geiser-view-last-image', +which takes a prefix argument to indicate which image number you want, 0 +corresponding to the newest one. + + +File: geiser.info, Node: Customization and tips, Prev: Seeing is believing, Up: The REPL + +3.7 Customization and tips +========================== + +The looks and ways of the REPL can be fine-tuned via a bunch of +customization variables. You can see and modify them all in the +corresponding customization group (by using the menu entry or the good +old 'M-x customize-group geiser-repl'), or by setting them in your Emacs +initialisation files (as a rule, all knobs in Geiser are tunable this +way: you don't need to use customization buffers if you don't like +them). + + I'm documenting below a proper subset of those settings, together +with some related tips. + +Choosing a Scheme implementation +................................ + +Instead of using the generic 'run-geiser' command, you can directly +start your Scheme of choice using any of the following commands: + * 'run-racket' + * 'run-guile' + * 'run-chicken' + * 'run-mit' + * 'run-chibi' + * 'run-chez' + In addition, the variable 'geiser-active-implementations' contains a +list of those Schemes Geiser should be aware of. Thus, if you happen to +be, say, a racketeer not to be beguiled by other schemes, you can tell +Geiser to forget about the richness of the Scheme ecosystem with +something like: + + (setq geiser-active-implementations '(racket)) + +in your initialisation files. + + When starting a new REPL, Geiser assumes, by default, that the +corresponding Scheme binary is in your path. If that's not the case, +the variables to tweak are (depending on which Scheme you choose): + * 'geiser-guile-binary' + * 'geiser-racket-binary' + * 'geiser-chicken-binary' + * 'geiser-mit-binary' + * 'geiser-chibi-binary' + * 'geiser-chez-binary' + They should be set to a string with the full path to the requisite +binary. + + Before starting the REPL, Geiser will check wether the version of +your Scheme interpreter is good enough. This means that it will spend a +couple tenths of a second launching and quickly discarding a Scheme +process, but also that the error message you'll get if you're on the +wrong Scheme version will be much more informative. If you one to avoid +version checks, just check 'geiser-repl-skip-version-check-p' to 't' in +your configuration. + + You can also specify a couple more initialisation parameters. For +Guile, 'geiser-guile-load-path' is a list of paths to add to its load +path (and its compiled load path) when it's started, while +'geiser-guile-init-file' is the path to an initialisation file to be +loaded on start-up. The equivalent variables for Racket are +'geiser-racket-collects' and 'geiser-racket-init-file'. + + Note, however, that specifying 'geiser-guile-init-file' is not +equivalent to changing Guile's initialization file ('~/.guile'), because +the former is loaded using the '-l' flag, together with '-q' to disable +loading the second. But there are subtle differences in the way Guile +loads the initialization file versus how it loads a file specified via +the '-l' flag. If what you want is just loading '~/.guile', leave +'geiser-guile-init-file' alone and set 'geiser-guile-load-init-file-p' +to 't' instead. + + These variables controlling your scheme's initialisation process are +good candidates for an entry in a project's '.dir-locals.el' file, so +that they are automatically set to a sensible value whenever you start a +REPL in the project's directory. + +Racket startup time +................... + +When starting Racket in little computers, Geiser might have to wait a +bit more than it expects (which is ten seconds, or ten thousand +milliseconds, by default). If you find that Geiser is giving up too +quickly and complaining that no prompt was found, try to increase the +value of 'geiser-repl-startup-time' to, say, twenty seconds: + + (setq geiser-repl-startup-time 20000) + +If you prefer, you can use the customize interface to, well, customise +the above variable's value. + +History +....... + +By default, Geiser won't record duplicates in your input history. If +you prefer it did, just set 'geiser-repl-history-no-dups-p' to 'nil'. +History entries are persistent across REPL sessions: they're saved in +implementation-specific files whose location is controlled by the +variable 'geiser-repl-history-filename'. For example, my Geiser +configuration includes the following line: + + (setq geiser-repl-history-filename "~/.emacs.d/geiser-history") + +which makes the files 'geiser-history.guile' and 'geiser-history.racket' +to live inside my home's '.emacs.d' directory. + +Autodoc +....... + +If you happen to love peace and quiet and prefer to keep your REPL's +echo area free from autodoc's noise, 'geiser-repl-autodoc-p' is the +customization variable for you: set it to 'nil' and autodoc will be +disabled by default in new REPLs. You can always bring the fairies +back, on a per-REPL basis, using 'C-c C-d C-a'. + +Remote connections +.................. + +When using any of the connection commands (e.g. 'geiser-connect', +'connect-to-guile', 'connect-to-racket', etc.) you'll be prompted for a +host and a port, defaulting to "localhost" and 37146. You can change +those defaults customizing 'geiser-repl-default-host' and +'geiser-repl-default-port', respectively. + +Killing REPLs +............. + +If you don't want Emacs to ask for confirmation when you're about to +kill a live REPL buffer (as will happen, for instance, if you're exiting +Emacs before closing all your REPLs), you can set the flag +'geiser-repl-query-on-kill-p' to 'nil'. On a related note, the +customizable variable 'geiser-repl-query-on-exit-p' controls whether +Geiser should ask for confirmation when you exit the REPL explicitly +(via, say, 'C-c C-q', as opposed to killing the buffer), and is set to +'nil' by default. + + +File: geiser.info, Node: Between the parens, Next: Cheat sheet, Prev: The REPL, Up: Top + +4 Between the parens +******************** + +A good REPL is a must, but just about half the story of a good Scheme +hacking environment. Well, perhaps a bit more than a half; but, at any +rate, one surely needs also a pleasant way of editing source code. +Don't pay attention to naysayers: Emacs comes with an excellent editor +included for about any language on Earth, and just the best one when +that language is sexpy (especially if you use Paredit). Geiser's +support for writing Scheme code adds to Emacs' 'scheme-mode', rather +than supplanting it; and it does so by means of a minor mode +(unimaginatively dubbed 'geiser-mode') that defines a bunch of new +commands to try and, with the help of the same Scheme process giving you +the REPL, make those Scheme buffers come to life. + +* Menu: + +* Activating Geiser:: +* The source and the REPL:: +* Documentation helpers:: +* To eval or not to eval:: +* To err perchance to debug:: +* Jumping around:: +* Geiser writes for you:: + + +File: geiser.info, Node: Activating Geiser, Next: The source and the REPL, Prev: Between the parens, Up: Between the parens + +4.1 Activating Geiser +===================== + +With Geiser installed following any of the procedures described in *note +The easy and quick way:: or *note From the source's mouth::, Emacs will +automatically activate geiser-mode when opening a Scheme buffer. Geiser +also instructs Emacs to consider files with the extension 'rkt' part of +the family, so that, in principle, there's nothing you need to do to +ensure that Geiser's extensions will be available, out of the box, when +you start editing Scheme code. + + Indications that everything is working according to plan include the +'Geiser' minor mode indicator in your mode-line and the appearance of a +new entry for Geiser in the menu bar. If, moreover, the mode-line +indicator is the name of a Scheme implementation, you're indeed in a +perfect world; otherwise, don't despair and keep on reading: i'll tell +you how to fix that in a moment. + + The menu provides a good synopsis of everything Geiser brings to the +party, including those keyboard shortcuts we Emacsers love. If you're +seeing the name of your favourite Scheme implementation in the +mode-line, have a running REPL and are comfortable with Emacs, you can +stop reading now and, instead, discover Geiser's joys by yourself. I've +tried to make Geiser as self-documenting as any self-respecting Emacs +package should be. If you follow this route, make sure to take a look +at Geiser's customization buffers ('M-x customize-group <RET> geiser'): +there's lot of fine-tuning available there. You might also want to take +a glance at the tables in *note our cheat sheet: Cheat sheet. + + Since geiser-mode is a minor mode, you can toggle it with 'M-x +geiser-mode', and control its activation in hooks with the functions +'turn-on-geiser-mode' and 'turn-off-geiser-mode'. If, for some reason i +cannot fathom, you prefer geiser-mode not to be active by default, +customizing 'geiser-mode-auto-p' to 'nil' will do the trick. + + And if you happen to use a funky extension for your Scheme files that +is not recognised as such by Emacs, just tell her about it with: + + (add-to-list 'auto-mode-alist '("\\.funky-extension\\'" . scheme-mode)) + + Now, geiser-mode is just a useless wretch unless there's a running +Scheme process backing it up. Meaning that virtually all the commands +it provides require a REPL up and running, preferably corresponding to +the correct Scheme implementation. In the following section, we'll see +how to make sure that that's actually the case. + + +File: geiser.info, Node: The source and the REPL, Next: Documentation helpers, Prev: Activating Geiser, Up: Between the parens + +4.2 The source and the REPL +=========================== + +As i've already mentioned a couple of times, geiser-mode needs a running +REPL to be operative. Thus, a common usage pattern will be for you to +first call 'run-geiser' (or one of its variants, e.g. 'run-guile'), and +then open some Scheme files; but there's nothing wrong in first opening +a couple Scheme buffers and then starting the REPL (you can even find it +more convenient, since pressing 'C-c C-z' in a Scheme buffer will start +the REPL for you). Since Geiser supports more than one Scheme +implementation, though, there's the problem of knowing which of them is +to be associated with each Scheme source file. Serviceable as it is, +geiser-mode will try to guess the correct implementation for you, +according to the algorithm described below. + +How Geiser associates a REPL to your Scheme buffer +.................................................. + +To determine what Scheme implementation corresponds to a given source +file, Geiser uses the following algorithm: + + 1. If the file-local variable 'geiser-scheme-implementation' is + defined, its value is used. A common way of setting buffer-local + variables is to put them in a comment near the beginning of the + file, surrounded by '-*-' marks, as in: + + ;; -*- geiser-scheme-implementation: guile -*- + + 2. If you've customized 'geiser-active-implementations' so that it's a + single-element list, that element is used as the chosen + implementation. + 3. The contents of the file is scanned for hints on its associated + implementation. For instance, files that contain a '#lang' + directive will be considered Racket source code, while those with a + 'define-module' form in them will be assigned to a Guile REPL. + 4. The current buffer's file name is checked against the rules given + in 'geiser-implementations-alist', and the first match is applied. + You can provide your own rules by customizing this variable, as + explained below. + 5. If we haven't been lucky this far and you have customized + 'geiser-default-implementation' to the name of a supported + implementation, we'll follow your lead. + 6. See? That's the problem of being a smart aleck: one's always + outsmarted by people around. At this point, geiser-mode will + humbly give up and ask you to explicitly choose the Scheme + implementation. + + As you can see in the list above, there are several ways to influence +Geiser's guessing by means of customizable variables. The most direct +(and most impoverishing) is probably limiting the active implementations +to a single one, while customizing 'geiser-implementations-alist' is the +most flexible (and, unsurprisingly, also the most complex). Here's the +default value for the latter variable: + + (((regexp "\\.scm$") guile) + ((regexp "\\.ss$") racket) + ((regexp "\\.rkt$") racket)) + +which describes the simple heuristic that files with '.scm' as extension +are by default associated to a Guile REPL while those ending in '.ss' or +'.rkt' correspond to Racket's implementation (with the caveat that these +rules are applied only if the previous heuristics have failed to detect +the correct implementation, and that they'll match only if the +corresponding implementation is active). You can add rules to +'geiser-implementations-alist' (or replace all of them) by customizing +it. Besides regular expressions, you can also use a directory name; for +instance, the following snippet: + + (eval-after-load "geiser-impl" + '(add-to-list 'geiser-implementations-alist + '((dir "/home/jao/prj/frob") guile))) + +will add a new rule that says that any file inside my +'/home/jao/prj/frob' directory (or, recursively, any of its children) is +to be assigned to Guile. Since rules are first matched, first served, +this new rule will take precedence over the default ones. + + A final tip: if you want Geiser to start automatically a REPL for you +if it notices that there's no one active when it enters geiser-mode, you +can customize 'geiser-mode-start-repl-p' to 't'. + +Switching between source files and the REPL +........................................... + +Once you have a working geiser-mode, you can switch from Scheme source +buffers to the REPL or 'C-c C-z'. Those shortcuts map to the +interactive command 'switch-to-geiser'. + + If you use a numeric prefix, as in 'C-u C-c C-z', besides being +teleported to the REPL, the latter will switch to the namespace of the +Scheme source file, as if you had used 'C-c C-m' in the REPL, with the +source file's module as argument; cf. discussion in *note Switching +context::. This command is also bound to 'C-c C-a'. + + Once you're in the REPL, the same 'C-c C-z' shortcut will bring you +back to the buffer you jumped from, provided you don't kill the Scheme +process in between. This is why the command is called switch-to-geiser +instead of switch-to-repl, and what makes it really handy, if you ask +me. + + If for some reason you're not happy with the Scheme implementation +that Geiser has assigned to your file, you can change it with 'C-c C-s', +and you probably should take a look at the previous subsection to make +sure that Geiser doesn't get confused again. + +A note about context +.................... + +As explained before (*note Modus operandi::), all Geiser activities take +place in the context of the current namespace, which, for Scheme +buffers, corresponds to the module that the Scheme implementation +associates to the source file at hand (for instance, in Racket, there's +a one-to-one correspondence between paths and modules, while Guile +relies on explicit 'define-module' forms in the source file). + + Now that we have 'geiser-mode' happily alive in our Scheme buffers +and communicating with the right REPL instance, let us see what it can +do for us, besides jumping to and fro. + + +File: geiser.info, Node: Documentation helpers, Next: To eval or not to eval, Prev: The source and the REPL, Up: Between the parens + +4.3 Documentation helpers +========================= + +Autodoc redux +............. + +The first thing you will notice by moving around Scheme source is that, +every now and then, the echo area lights up with the same autodoc +messages we know and love from our REPL forays. This happens every time +the Scheme process is able to recognise an identifier in the buffer, and +provide information either on its value (for variables) or on its arity +and the name of its formal arguments (for procedures and macros). That +information will only be available if the module the identifier belongs +to has been loaded in the running Scheme image. So it can be the case +that, at first, no autodoc is shown for identifiers defined in the file +you're editing. But as soon as you evaluate them (either individually +or collectively using any of the devices described in *note To eval or +not to eval::) their signatures will start appearing in the echo area. + + Autodoc activation is controlled by a minor mode, 'geiser-autodoc', +which you can toggle with 'M-x geiser-autodoc-mode', or its associated +keyboard shortcut, 'C-c C-d a'. That /A indicator in the mode-line is +telling you that autodoc is active. If you prefer that it be inactive +by default (e.g., because you're connecting to a really remote scheme +and want to minimize network exchanges), just set +'geiser-mode-autodoc-p' to 'nil' in your customization files. Even when +autodoc mode is off, you can use 'geiser-autodoc-show', bound by default +to 'C-c C-d s', to show the autodoc string for the symbol at point. + + The way autodoc displays information deserves some explanation. It +will first show the name of the module where the identifier at hand is +defined, followed by a colon and the identifier itself. If the latter +corresponds to a procedure or macro, it will be followed by a list of +argument names, starting with the ones that are required. Then there +comes a list of optional arguments, if any, enclosed in parentheses. +When an optional argument has a default value (or a form defining its +default value), autodoc will display it after the argument name. When +the optional arguments are keywords, their names are prefixed with "#:" +(i.e., their names are keywords). An ellipsis (...) serves as a marker +of an indeterminate number of parameters, as is the case with rest +arguments or when autodoc cannot fathom the exact number of arguments +(this is often the case with macros defined using 'syntax-case'). +Another way in which autodoc displays its ignorance is by using an +underscore to display parameters whose name is beyond its powers. + + It can also be the case that a function or macro has more than one +signature (e.g., functions defined using 'case-lambda', or some +'syntax-rules' macros, for which Geiser has often the black magic +necessary to retrieve their actual arities). In those cases, autodoc +shows all known signatures (using the above rules for each one) +separated by a vertical bar (|). + + As you have already noticed, the whole autodoc message is enclosed in +parentheses. After all, we're talking about Scheme here. + + Finally, life is much easier when your cursor is on a symbol +corresponding to a plain variable: you'll see in the echo area its name, +preceded by the module where it's defined, and followed by its value, +with an intervening arrow for greater effect. This time, there are no +enclosing parentheses (i hope you see the logic in my madness). + + You can change the way Geiser displays the module/identifier combo by +customizing 'geiser-autodoc-identifier-format'. For example, if you +wanted a tilde surrounded by spaces instead of a colon as a separator, +you would write something like: + + (setq geiser-autodoc-identifier-format "%s ~ %s") + +in your Emacs initialisation files. There's also a face +('geiser-font-lock-autodoc-identifier') that you can customize (for +instance, with 'M-x customize-face') to change the appearance of the +text. And another one ('geiser-font-lock-autodoc-current-arg') that +controls how the current argument position is highlighted. + +Other documentation commands +............................ + +Sometimes, autodoc won't provide enough information for you to +understand what a function does. In those cases, you can ask Geiser to +ask the running Scheme for further information on a given identifier or +module. + + For symbols, the incantation is 'M-x geiser-doc-symbol-at-point', or +'C-c C-d C-d' for short. If the associated Scheme supports docstrings +(as, for instance, Guile does), you'll be teleported to a new Emacs +buffer displaying Geiser's documentation browser, filled with +information about the identifier, including its docstring (if any; +unfortunately, that an implementation supports docstrings doesn't mean +that they're used everywhere). + + Pressing 'q' in the documentation buffer will bring you back, +enlightened, to where you were. There's also a handful of other +navigation commands available in that buffer, which you can discover by +means of its menu or via the good old 'C-h m' command. And feel free to +use the navigation buttons and hyperlinks that justify my calling this +buffer a documentation browser. + + For Racket, which does not support docstrings out of the box, this +command will provide less information, but the documentation browser +will display the corresponding contract when it's available, as well as +some other tidbits for re-exported identifiers. + + You can also ask Geiser to display information about a module, in the +form of a list of its exported identifiers, using 'C-c C-d C-m', exactly +as you would do in *note the REPL: repl-mod. + + In both cases, the documentation browser will show a couple of +buttons giving you access to further documentation. First, you'll see a +button named source: pressing it you'll jump to the symbol's definition. +The second button, dubbed manual, will open the Scheme implementation's +manual page for the symbol at hand. For Racket, that will open your web +browser displaying the corresponding reference's page (using the HTML +browser in Racket's configuration, which you can edit in DrRacket's +preferences dialog, or by setting 'plt:framework-pref:external-browser' +directly in '~/.racket/racket-prefs.rktd'), while in Guile a lookup will +be performed in the texinfo manual. + + For Guile, the manual lookup uses the info indexes in the standard +Guile info nodes, which are usually named "guile" or "guile-2.0". If +yours are named differently, just add your name to the customizable +variable 'geiser-guile-manual-lookup-nodes'. + + A list of all navigation commands in the documentation browser is +available in *note our cheat-sheet: Documentation browser. + + You can also skip the documentation browser and jump directly to the +manual page for the symbol at point with the command +'geiser-doc-look-up-manual', bound to 'C-c C-d i'. + + +File: geiser.info, Node: To eval or not to eval, Next: To err perchance to debug, Prev: Documentation helpers, Up: Between the parens + +4.4 To eval or not to eval +========================== + +One of Geiser's main goals is to facilitate incremental development. +You might have noticed that i've made a big fuss of Geiser's ability to +recognize context, by being aware of the namespace where its operations +happen. + + That awareness is especially important when evaluating code in your +scheme buffers, using the commands described below. They allow you to +send code to the running Scheme with a granularity ranging from whole +files to single s-expressions. That code will be evaluated in the +module associated with the file you're editing, allowing you to redefine +values and procedures to your heart's (and other modules') content. + + Macros are, of course, another kettle of fish: one needs to +re-evaluate uses of a macro after redefining it. That's not a +limitation imposed by Geiser, but a consequence of how macros work in +Scheme (and other Lisps). There's also the risk that you lose track of +what's actually defined and what's not during a given session. But, in +my opinion +(http://jaortega.wordpress.com/2009/03/29/from-my-cold-prying-hands/index.html), +those are limitations we lispers are aware of, and they don't force us +to throw the baby with the bathwater and ditch incremental evaluation. +Some people disagree; if you happen to find their arguments +(http://blog.racket-lang.org/2009/03/drscheme-repl-isnt-lisp-the-one-in-emacs.html) +convincing, you don't have to throw away Geiser together with the baby: +'M-x geiser-restart-repl' will let you restart the REPL as many times as +you see fit. Moreover, you can invoke 'geiser-compile-current-buffer' +and 'geiser-load-current-buffer' with a prefix argument (that'd be +something like 'C-u C-c C-k' for compilation, for instance), to tell +Geiser to restart the REPL associated with a buffer before compiling or +loading its current contents. + + For all of you bearded old lispers still with me, here are some of +the commands performing incremental evaluation in Geiser. + + 'geiser-eval-last-sexp', bound to 'C-x C-e', will eval the +s-expression just before point. If you use a prefix, as in 'C-u C-x +C-e', besides evaluating it the expression is inserted in the the +buffer. + + 'geiser-eval-definition', bound to 'C-M-x', finds the topmost +definition containing point and sends it for evaluation. The variant +'geiser-eval-definition-and-go' ('C-c M-e') works in the same way, but +it also teleports you to REPL after the evaluation. + + 'geiser-eval-region', bound to 'C-c C-r', evals the current region. +Again, there's an and-go version available, 'geiser-eval-region-and-go', +bound to 'C-c M-r'. And, if you want to extend the evaluated region to +the whole buffer, there is 'geiser-eval-buffer', bound to 'C-c C-b' and +its companion 'geiser-eval-buffer-and-go', bound to 'C-c M-b'. + + For all the commands above, the result of the evaluation is displayed +in the minibuffer, unless it causes a (Scheme-side) error (*note To err +perchance to debug::), or, for schemes supporting them (such as Racket), +the evaluation yields an image, in which case you'll see it in popping +up in the Geiser debug buffer (if your Emacs runs under the auspices of +a graphical toolkit), or via an external viewer if you set program (see +also *note Seeing is believing:: for more on image support). + + At the risk of repeating myself, i'll remind you that all these +evaluations will take place in the namespace of the module corresponding +to the Scheme file from which you're sending your code, which, in +general, will be different from the REPL's current module. And, if all +goes according to plan, (re)defined variables and procedures should be +immediately visible inside and, if exported, outside their module. + + Besides evaluating expressions, definitions and regions, you can also +macro-expand them. The corresponding key bindings start with the prefix +'C-c C-m' and end, respectively, with 'C-e', 'C-x' and 'C-r'. The +result of the macro expansion always appears in a pop up buffer. + + +File: geiser.info, Node: To err perchance to debug, Next: Jumping around, Prev: To eval or not to eval, Up: Between the parens + +4.5 To err: perchance to debug +============================== + +When an error occurs during evaluation, it will be reported according to +the capabilities of the underlying Scheme REPL. + + In Racket, you'll be presented with a backtrace, in a new buffer +where file paths locating the origin of the error are click-able (you +can navigate them using the <TAB> key, and use <RET> or the mouse to +jump to the offending spot; or invoke Emacs' stock commands 'next-error' +and 'previous-error', bound to 'M-g n' and 'M-g p' by default). + + The Racket backtrace also highlights the exception type, making it +click-able. Following the link will open the documentation +corresponding to said exception type. Both the error and exception link +faces are customizable ('geiser-font-lock-error-link' and +'geiser-font-lock-doc-link'). + + By default, Geiser will tele-transport your pointer to the debug +buffer: if you prefer to stay in the source buffer, set +'geiser-debug-jump-to-debug-p' to nil. And if, in addition, you don't +even want to see the error trace, customize 'geiser-debug-show-debug-p', +again, to nil. + + On the other hand, Guile's reaction to evaluation errors is +different: it enters the debugger in its REPL. Accordingly, the REPL +buffer will pop up if your evaluation fails in a Guile file, and the +error message and backtrace will be displayed in there, again click-able +and all. But there you have the debugger at your disposal, with the +REPL's current module set to that of the offender, and a host of special +debugging commands that are described in Guile's fine documentation. + + In addition, Guile will sometimes report warnings for otherwise +successful evaluations. In those cases, it won't enter the debugger, +and Geiser will report the warnings in a debug buffer, as it does for +Racket. You can control how picky Guile is reporting warnings by +customizing the variable 'geiser-guile-warning-level', whose detailed +docstring (which see, using, e.g. 'C-h v') allows me to offer no +further explanation here. The customization group geiser-guile is also +worth a glance, for a couple of options to fine-tune how Geiser +interacts with Guile's debugger (and more). Same thing for racketeers +and geiser-racket. + + +File: geiser.info, Node: Jumping around, Next: Geiser writes for you, Prev: To err perchance to debug, Up: Between the parens + +4.6 Jumping around +================== + +This one feature is as sweet as it is easy to explain: 'M-.' +('geiser-edit-symbol-at-point') will open the file where the identifier +around point is defined and land your point on its definition. To +return to where you were, press 'M-,' ('geiser-pop-symbol-stack'). This +command works also for module names: Geiser first tries to locate a +definition for the identifier at point and, if that fails, a module with +that name; if the latter succeeds, the file where the module is defined +will pop up. + + Sometimes, the underlying Scheme will tell Geiser only the file where +the symbol is defined, but Geiser will use some heuristics (read, +regular expressions) to locate the exact line and bring you there. +Thus, if you find Geiser systematically missing your definitions, send a +message to the mailing list <geiser-users@nongnu.org>, and we'll try to +make the algorithm smarter. + + You can control how the destination buffer pops up by setting +'geiser-edit-symbol-method' to either 'nil' (to open the file in the +current window), ''window' (other window in the same frame) or ''frame' +(in a new frame). + + +File: geiser.info, Node: Geiser writes for you, Prev: Jumping around, Up: Between the parens + +4.7 Geiser writes for you +========================= + +No self-respecting programming mode would be complete without +completion. In geiser-mode, identifier completion is bound to +'M-<TAB>', and will offer all visible identifiers starting with the +prefix before point. Visible here means all symbols imported or defined +in the current namespace plus locally bound ones. E.g., if you're at +the end of the following partial expression: + + (let ((default 42)) + (frob def + +and press 'M-<TAB>', one of the possible completions will be 'default'. + + After obtaining the list of completions from the running Scheme, +Geiser uses the standard Emacs completion machinery to display them. +That means, among other things, that partial completion is available: +just try to complete 'd-s' or 'w-o-t-s' to see why this is a good thing. +Partial completion won't work if you have disabled it globally in your +Emacs configuration: if you don't know what i'm talking about, never +mind: Geiser's partial completion will work for you out of the box. + + If you find the 'M' modifier annoying, you always have the option to +activate 'geiser-smart-tab-mode', which will make the <TAB> key double +duty as the regular Emacs indentation command (when the cursor is not +near a symbol) and Geiser's completion function. If you want this +smarty pants mode always on in Scheme buffers, customize +'geiser-mode-smart-tab-p' to 't'. + + Geiser also knows how to complete module names: if no completion for +the prefix at point is found among the currently visible bindings, it +will try to find a module name that matches it. You can also request +explicitly completion only over module names using 'M-`' (that's a +backtick). + + Besides completion, there's also this little command, +'geiser-squarify', which will toggle the delimiters of the innermost +list around point between round and square brackets. It is bound to +'C-c C-e ['. With a numeric prefix (as in, say, 'M-2 C-c C-e ['), it +will perform that many toggles, forward for positive values and backward +for negative ones. + +Caveat about completion +----------------------- + +It is possible for Geiser to hang your Emacs process when trying to +complete symbols. This can happen in the REPL itself or even in a +Scheme buffer that is attached to the REPL process. For more details on +how to fix this problem, *note Caveat about completion & the REPL: +completion-caveat. + + +File: geiser.info, Node: Cheat sheet, Next: No hacker is an island, Prev: Between the parens, Up: Top + +5 Cheat sheet +************* + +In the tables below, triple chords always accept a variant with the +third key not modified by <Control>; e.g., 'geiser-autodoc-show' is +bound both to 'C-c C-d C-s' and 'C-c C-d s'. + +* Menu: + +* Scheme buffers:: +* REPL:: +* Documentation browser:: + + +File: geiser.info, Node: Scheme buffers, Next: REPL, Prev: Cheat sheet, Up: Cheat sheet + +5.1 Scheme buffers +================== + +Key Command Description +--------------------------------------------------------------------------- +C-c C-z 'geiser-mode-switch-to-repl' Switch to REPL +C-c C-a 'geiser-mode-switch-to-repl-and-enter'Switch to REPL and current + module (also 'C-u C-c C-z') +C-c C-s 'geiser-set-scheme' Specify Scheme + implementation for buffer +M-. 'geiser-edit-symbol-at-point' Go to definition of + identifier at point +M-, 'geiser-pop-symbol-stack' Go back to where M-. was + last invoked +C-c C-e C-m 'geiser-edit-module' Ask for a module and open + its file +C-c C-e C-l 'geiser-add-to-load-path' Ask for a directory and add + to Scheme load path +C-c C-e C-[ 'geiser-squarify' Toggle between () and [] + for current form +C-c C-\ 'geiser-insert-lambda' Insert greek lambda or, + with prefix, a lambda form +C-M-x 'geiser-eval-definition' Eval definition around + point +C-c C-c 'geiser-eval-definition' Eval definition around + point +C-c M-e 'geiser-eval-definition-and-go'Eval definition around + point and switch to REPL +C-c M-c 'geiser-eval-definition-and-go'Eval definition around + point and switch to REPL +C-x C-e 'geiser-eval-last-sexp' Eval sexp before point +C-c C-r 'geiser-eval-region' Eval region +C-c M-r 'geiser-eval-region-and-go' Eval region and switch to + REPL +C-c C-b 'geiser-eval-buffer' Eval buffer +C-c M-b 'geiser-eval-buffer-and-go' Eval buffer and switch to + REPL +C-c C-m C-x 'geiser-expand-definition' Macro-expand definition + around point +C-c C-m C-e 'geiser-expand-last-sexp' Macro-expand sexp before + point +C-c C-m C-r 'geiser-expand-region' Macro-expand region +C-c C-k 'geiser-compile-current-buffer'Compile and load current + file; with prefix, restart + REPL before +C-c C-l 'geiser-load-file' Load scheme file +M-g n, C-x ' 'next-error' Jump to the location of + next error +M-g p 'previous-error' Jump to the location of + previous error +C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for + identifier at point +C-c C-d C-s 'geiser-autodoc-show' Show signature or value for + identifier at point in echo + area +C-c C-d C-m 'geiser-doc-module' See a list of a module's + exported identifiers +C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol + at point +C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode +C-c < 'geiser-xref-callers' Show callers of procedure + at point +C-c > 'geiser-xref-callees' Show callees of procedure + at point +M-TAB 'completion-at-point' Complete identifier at + point +M-', C-. 'geiser-completion--complete-module'Complete module name at + point + + +File: geiser.info, Node: REPL, Next: Documentation browser, Prev: Scheme buffers, Up: Cheat sheet + +5.2 REPL +======== + +Key Command Description +--------------------------------------------------------------------------- +C-c C-z 'switch-to-geiser' Start Scheme REPL, or jump + to previous buffer +C-c M-o 'geiser-repl-clear-buffer' Clear REPL buffer +C-c C-k 'geiser-repl-interrupt' Interrupt REPL evaluation + (signalling inferior + scheme) +C-c C-q 'geiser-repl-exit' Kill Scheme process +M-. 'geiser-edit-symbol-at-point' Edit identifier at point +C-c C-l 'geiser-load-file' Load scheme file +TAB 'geiser-repl-tab-dwim' Complete, indent, or go to + next error +S-TAB 'geiser-repl--previous-error' Go to previous error in the +(backtab) REPL buffer +M-TAB 'completion-at-point' Complete indentifier at + point +M-', C-. 'geiser-completion--complete-module'Complete module name at + point +C-c [, C-c 'geiser-squarify' Toggle between () and [] +C-[ for current form +C-c \, C-c 'geiser-insert-lambda' Insert greek lambda or, +C-\ with prefix, a lambda form +C-c C-r 'geiser-add-to-load-path' Ask for a directory and add + to Scheme load path +M-p, M-n (comint commands) Prompt history, matching + current prefix +C-c M-p, C-c (comint commands) Previous/next prompt inputs +M-n +C-c C-m 'switch-to-geiser-module' Set current module +C-c C-i 'geiser-repl-import-module' Import module into current + namespace +C-c C-d C-d 'geiser-doc-symbol-at-point' See documentation for + symbol at point +C-c C-d C-i 'geiser-doc-look-up-manual' Look up manual for symbol + at point +C-c C-d C-m 'geiser-repl--doc-module' See documentation for + module +C-c C-d C-a 'geiser-autodoc-mode' Toggle autodoc mode + + +File: geiser.info, Node: Documentation browser, Prev: REPL, Up: Cheat sheet + +5.3 Documentation browser +========================= + +Key Command Description +--------------------------------------------------------------------------- +TAB, n 'forward-button' Next link +S-TAB, p 'backward-button' Previous link +N 'geiser-doc-next-section' Next section +P 'geiser-doc-previous-section' Previous section +f 'geiser-doc-next' Next page +b 'geiser-doc-previous' Previous page +k 'geiser-doc-kill-page' Kill current page and go to + previous or next +g, r 'geiser-doc-refresh' Refresh page +c 'geiser-doc-clean-history' Clear browsing history +., M-. 'geiser-doc-edit-symbol-at-point'Edit identifier at point +z 'geiser-doc-switch-to-repl' Switch to REPL +q 'View-quit' Bury buffer + + +File: geiser.info, Node: No hacker is an island, Next: Index, Prev: Cheat sheet, Up: Top + +6 No hacker is an island +************************ + +Dan Leslie, with the help of his three-months old daughter Freija, +proved there's a smidgen of sense in this madness by adding support for +Chicken to version 0.7 of Geiser, several years after it was born. And +Peter Feigl reinforced that feeling soon afterwards with his work on +supporting GNU/MIT Scheme, Chib and Chez in one fell swoop. + + Andy Wingo, Geiser's first user, has been a continuous source of +encouragement and suggestions, and keeps improving Guile and heeding my +feature requests. + + The nice thing about collaborating with Andreas Rottmann over all +these years is that he will not only make your project better with +insightful comments and prodding: he'll send you patches galore too. + + Ludovic Courtès, #geiser's citizen no. 1, joined the fun after a +while, and has since then been a continuous source of encouragement, +ideas and bug reports. + + Michael Wilber convinced me that image support for Racket was not +only fun, but easy, with the best argument: actual code! + + Daniel Hackney and Grant Rettke created the first ELPA packages for +Geiser and taught me to fish. + + Diogo F. S. Ramos is Geiser's most indefatigable user and bug +reporter, and the mailing list has been a far less lonely place since he +came. + + Aleix Conchillo has been my favourite spammer, beta tester and patch +sender during more years and for more projects than i can remember. + + Eduardo Cavazos' contagious enthusiasm has helped in many ways to +keep Geiser alive, and he's become its best evangelist in R6RS circles. + + Alex Kost has contributed with many bug reports and improved Geiser +with several patches. + + Eli Barzilay took the time to play with an early alpha and made many +valuable suggestions, besides answering all my 'how do you in PLT' +questions. + + Matthew Flatt, Robby Findler and the rest of the PLT team did not +only answer my inquiries, but provided almost instant fixes to the few +issues i found. + + Thanks also to the PLT and Guile communities, for showing me that +Geiser was not only possible, but a pleasure to hack on. And to the +Slime hackers, who led the way. + +Joining the fun +............... + + * For questions, praise, critique and anything else Geiser, do not + hesitate to drop an email to our list, (@ geiser-users (. nongnu + org)) (mailto:geiser-users@nongnu.org): no subscription required. + Check the list page + (http://lists.nongnu.org/mailman/listinfo/geiser-users) for more + information or browse the archives + (http://lists.nongnu.org/archive/html/geiser-users/). The list is + also accessible via Gmane (http://gmane.org) as + gmane.lisp.scheme.geiser + (http://dir.gmane.org/gmane.lisp.scheme.geiser). + * You can submit bug reports either to the mailing list or to our bug + tracker (https://gitlab.com/jaor/geiser/issues) over at Gitlab. + * If you only need to hear about Geiser on new releases, the News + page (http://savannah.nongnu.org/news/?group=geiser) and its Atom + feed (https://savannah.nongnu.org/news/atom.php?group=geiser) are + probably what you're looking for. + * The Freenode IRC channel #geiser is the Geiserati's meeting point + in cyberspace. + + +File: geiser.info, Node: Index, Prev: No hacker is an island, Up: Top + +Index +***** + ++* Menu: + +* ,enter vs. enter!: Switching context. (line 6) +* ac-geiser: Friends. (line 9) +* ask on kill, don't: Customization and tips. + (line 129) +* autocomplete: Friends. (line 9) +* autodoc customized: Documentation helpers. + (line 64) +* autodoc explained: Documentation helpers. + (line 32) +* autodoc for variables: Documentation helpers. + (line 58) +* autodoc, disabling: Customization and tips. + (line 111) +* autodoc, in scheme buffers: Documentation helpers. + (line 9) +* autodoc, in the REPL: Autodoc and friends. (line 11) +* autostart REPL: The source and the REPL. + (line 80) +* backtraces: To err perchance to debug. + (line 6) +* bug tracker: No hacker is an island. + (line 68) +* byte-compilation: From the source's mouth. + (line 46) +* Chicken: The easy and quick way. + (line 38) +* Chicken installation: The easy and quick way. + (line 37) +* company: Friends. (line 9) +* completion for module names: Geiser writes for you. + (line 33) +* completion in scheme buffers: Geiser writes for you. + (line 6) +* completion, at the REPL: Completion and error handling. + (line 6) +* connect to server: Starting the REPL. (line 43) +* corpses: Top. (line 81) +* current module: Modus operandi. (line 15) +* current module, change: Switching context. (line 21) +* current module, in REPL: Switching context. (line 6) +* derailment: Top. (line 81) +* disabling autodoc: Documentation helpers. + (line 22) +* docstrings, maybe: Documentation helpers. + (line 85) +* documentation for symbol: Documentation helpers. + (line 85) +* ELPA: The easy and quick way. + (line 6) +* error buffer: To err perchance to debug. + (line 9) +* evaluating images: To eval or not to eval. + (line 56) +* evaluation: To eval or not to eval. + (line 37) +* external image viewer: Seeing is believing. (line 10) +* faces, in the REPL: Starting the REPL. (line 35) +* Gambit: Chicken installation. + (line 19) +* Gambit installation: Chicken installation. + (line 18) +* geiser-mode: Activating Geiser. (line 6) +* geiser-mode commands: Activating Geiser. (line 21) +* gmane: No hacker is an island. + (line 58) +* Guile info nodes: Documentation helpers. + (line 120) +* Guile's REPL server: Starting the REPL. (line 48) +* GUILE_LOAD_COMPILED_PATH: Customization and tips. + (line 58) +* GUILE_LOAD_PATH: Customization and tips. + (line 58) +* help on identifier: Autodoc and friends. (line 29) +* host, default: Customization and tips. + (line 120) +* image cache: Seeing is believing. (line 16) +* image display: To eval or not to eval. + (line 56) +* image support: Seeing is believing. (line 6) +* image viewer: Seeing is believing. (line 10) +* incremental development: To eval or not to eval. + (line 6) +* incremental development, evil: To eval or not to eval. + (line 18) +* incremental development, not evil: To eval or not to eval. + (line 37) +* IRC channel: No hacker is an island. + (line 74) +* jump, at the REPL: Autodoc and friends. (line 51) +* jumping customized: Jumping around. (line 22) +* jumping in scheme buffers: Jumping around. (line 6) +* mailing list: No hacker is an island. + (line 58) +* manual autodoc: Documentation helpers. + (line 22) +* module exports: Autodoc and friends. (line 39) +* modus operandi: Modus operandi. (line 6) +* news feed: No hacker is an island. + (line 70) +* opening manual pages: Documentation helpers. + (line 128) +* paredit: Friends. (line 9) +* partial completion: Geiser writes for you. + (line 18) +* peace and quiet: Customization and tips. + (line 111) +* philosophy: Top. (line 81) +* philosophy <1>: To eval or not to eval. + (line 6) +* PLTCOLLECTS: Customization and tips. + (line 58) +* port, default: Customization and tips. + (line 120) +* quack: Friends. (line 9) +* quick install: The easy and quick way. + (line 6) +* Racket's REPL server: Starting the REPL. (line 53) +* recursion: Index. (line 6) +* remote connections: Starting the REPL. (line 78) +* remote REPL: Starting the REPL. (line 43) +* REPL: Starting the REPL. (line 6) +* REPL commands: First aids. (line 6) +* REPL customization: Customization and tips. + (line 6) +* REPL, faces: Starting the REPL. (line 35) +* scheme binary: Customization and tips. + (line 38) +* scheme executable path: Customization and tips. + (line 38) +* scheme file extensions: Activating Geiser. (line 38) +* scheme implementation, choosing: Customization and tips. + (line 20) +* scheme implementation, choosing <1>: The source and the REPL. + (line 21) +* scheme init file: Customization and tips. + (line 58) +* scheme load path: Customization and tips. + (line 58) +* smart tabs: Geiser writes for you. + (line 26) +* start REPL, automatically: The source and the REPL. + (line 80) +* startup timeout: Customization and tips. + (line 82) +* supported versions: Must needs. (line 6) +* swanking: Showing off. (line 6) +* switching schemes: The source and the REPL. + (line 103) +* switching to module: The source and the REPL. + (line 91) +* switching to REPL: The source and the REPL. + (line 87) +* switching to source: The source and the REPL. + (line 87) +* thanks: No hacker is an island. + (line 6) +* timeout: Customization and tips. + (line 82) +* to err is schemey: To err perchance to debug. + (line 6) +* use the source, Luke: From the source's mouth. + (line 9) +* useless wretch: Activating Geiser. (line 43) +* Version checking: Customization and tips. + (line 50) +* versions supported: Must needs. (line 6) + + + +Tag Table: +Node: Top901 +Node: Introduction3412 +Node: Modus operandi3746 +Ref: current-module4401 +Node: Showing off5874 +Node: Installation7152 +Node: Must needs7414 +Node: The easy and quick way8521 +Node: Chicken installation9980 +Node: Gambit installation10752 +Node: From the source's mouth12412 +Node: Friends15939 +Ref: paredit16213 +Node: The REPL17156 +Ref: quick-start17275 +Node: Starting the REPL17666 +Node: First aids22053 +Node: Switching context23886 +Node: Completion and error handling25811 +Ref: completion-caveat27519 +Node: Autodoc and friends29433 +Ref: repl-mod31503 +Node: Seeing is believing32509 +Node: Customization and tips33521 +Ref: choosing-impl34250 +Ref: active-implementations34485 +Ref: impl-binary34867 +Node: Between the parens39223 +Node: Activating Geiser40285 +Node: The source and the REPL42895 +Ref: repl-association43939 +Ref: switching-repl-buff47207 +Node: Documentation helpers48892 +Ref: doc-browser53160 +Node: To eval or not to eval55887 +Node: To err perchance to debug60036 +Node: Jumping around62398 +Node: Geiser writes for you63675 +Node: Cheat sheet66179 +Node: Scheme buffers66563 +Node: REPL70888 +Node: Documentation browser73482 +Node: No hacker is an island74550 +Node: Index77869 + +End Tag Table diff --git a/elpa/geiser-20200214.110/macros.info b/elpa/geiser-20200225.1423/macros.info diff --git a/elpa/geiser-20200214.110/scheme/chez/geiser/geiser.ss b/elpa/geiser-20200225.1423/scheme/chez/geiser/geiser.ss diff --git a/elpa/geiser-20200214.110/scheme/chez/geiser/test.ss b/elpa/geiser-20200225.1423/scheme/chez/geiser/test.ss diff --git a/elpa/geiser-20200214.110/scheme/chibi/geiser/geiser.scm b/elpa/geiser-20200225.1423/scheme/chibi/geiser/geiser.scm diff --git a/elpa/geiser-20200214.110/scheme/chibi/geiser/geiser.sld b/elpa/geiser-20200225.1423/scheme/chibi/geiser/geiser.sld diff --git a/elpa/geiser-20200214.110/scheme/chicken/geiser/chicken4.scm b/elpa/geiser-20200225.1423/scheme/chicken/geiser/chicken4.scm diff --git a/elpa/geiser-20200214.110/scheme/chicken/geiser/chicken5.scm b/elpa/geiser-20200225.1423/scheme/chicken/geiser/chicken5.scm diff --git a/elpa/geiser-20200214.110/scheme/gambit/geiser/gambit.scm b/elpa/geiser-20200225.1423/scheme/gambit/geiser/gambit.scm diff --git a/elpa/geiser-20200214.110/scheme/gambit/geiser/gambit_procedures.scm b/elpa/geiser-20200225.1423/scheme/gambit/geiser/gambit_procedures.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/completion.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/completion.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/doc.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/doc.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/emacs.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/emacs.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/evaluation.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/evaluation.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/modules.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/modules.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/utils.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/utils.scm diff --git a/elpa/geiser-20200214.110/scheme/guile/geiser/xref.scm b/elpa/geiser-20200225.1423/scheme/guile/geiser/xref.scm diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/compile.scm b/elpa/geiser-20200225.1423/scheme/mit/geiser/compile.scm diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/emacs.scm b/elpa/geiser-20200225.1423/scheme/mit/geiser/emacs.scm diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/geiser.pkg b/elpa/geiser-20200225.1423/scheme/mit/geiser/geiser.pkg diff --git a/elpa/geiser-20200214.110/scheme/mit/geiser/load.scm b/elpa/geiser-20200225.1423/scheme/mit/geiser/load.scm diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/autodoc.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/autodoc.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/completions.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/completions.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/enter.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/enter.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/eval.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/eval.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/images.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/images.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/locations.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/locations.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/main.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/main.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/modules.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/modules.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/server.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/server.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/startup.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/startup.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/user.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/user.rkt diff --git a/elpa/geiser-20200214.110/scheme/racket/geiser/utils.rkt b/elpa/geiser-20200225.1423/scheme/racket/geiser/utils.rkt diff --git a/elpa/geiser-20200214.110/top.info b/elpa/geiser-20200225.1423/top.info diff --git a/elpa/geiser-20200225.1423/web.info b/elpa/geiser-20200225.1423/web.info @@ -0,0 +1,1847 @@ +This is web.info, produced by makeinfo version 6.5 from web.texi. + + +File: web.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir) + +Geiser is a collection of Emacs major and minor modes that conspire with +one or more Scheme interpreters to keep the Lisp Machine Spirit alive. +It draws inspiration (and a bit more) from environments such as Common +Lisp's Slime, Factor's FUEL, Squeak or Emacs itself, and does its best +to make Scheme hacking inside Emacs (even more) fun. + + Or, to be precise, what i (https://jao.io) consider fun. Geiser is +thus my humble contribution to the dynamic school of expression, and a +reaction against what i perceive as a derailment, in modern times, of +standard Scheme towards the static camp. Because i prefer growing and +healing to poking at corpses, the continuously running Scheme +interpreter takes the center of the stage in Geiser. A bundle of Elisp +shims orchestrates the dialog between the Scheme interpreter, Emacs and, +ultimately, the schemer, giving her access to live metadata. Here's +how. + + Version 0.11.2 (February 2020) for Guile 2.2 Chicken 4.8.0 GNU/MIT +9.1 Chez 9.4 Chibi 0.7 Gambit 4.9 and Racket 6.0 +(https://gitlab.com/jaor/geiser/-/releases) + +* Menu: + +* Introduction:: +* Installation:: +* The REPL:: +* Between the parens:: +* Cheat sheet:: +* No hacker is an island:: +* Index:: + + +File: web.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top + +1 Introduction +************** + +Geiser is an Emacs environment to hack and have fun in Scheme. If +that's enough for you, see *note Installation:: to get it running and +*note The REPL:: for the fun part. + +* Menu: + +* Modus operandi:: +* Showing off:: + + +File: web.info, Node: Modus operandi, Next: Showing off, Prev: Introduction, Up: Introduction + +1.1 Modus operandi +================== + +As already mentioned, Geiser relies on a running Scheme process to +obtain the information it makes accessible to the programmer. There's +little effort, on the Elisp side, to understand, say, the module system +used by the Scheme implementation at hand; instead, a generic interface +between the two worlds is defined, and each supported Scheme includes a +library implementing that API, together with some wee shims in Elisp +allowing the reuse of the Emacs-side framework, which constitutes the +bulk of the code. + + While being as generic as possible, the Scheme-Elisp interface makes +some assumptions about the capabilities and interaction mode of the +corresponding REPL. In particular, Geiser expects the latter to support +namespaces in the form of a module system, and to provide a well-defined +way to establish the REPL's current namespace (or module), as well as +the current file's module (or namespace). Thus, all evaluations +performed by Geiser either in the REPL or in a source code buffer happen +in the context of the current namespace. Every time you switch to a +different file, you're switching namespaces automatically; at the REPL, +you must request the switch explicitly (usually just using means +provided by the Scheme implementation itself). + + If your favourite Scheme supports the above modus operandi, it has +all that's needed for a bare-bones Geiser mode. But Geiser can, and +will, use any metadata available: procedure arities and argument lists +to display interactive help, documentation strings, location information +to jump to definitions, export lists to provide completion, and so on +and so forth. Although this is not an all-or-none proposition (Geiser +can operate with just part of that functionality available), i initially +concentrated in supporting those Schemes with the richest (to my +knowledge) introspection capabilities, namely, Guile and Racket. Later +on, Dan Leslie added support for Chicken, and there's active work to add +support for scsh. + + +File: web.info, Node: Showing off, Prev: Modus operandi, Up: Introduction + +1.2 Showing off +=============== + +When working with a fully conniving Scheme, Geiser can offer the +following functionality: + + * Form evaluation in the context of the current file's module. + * Macro expansion. + * File/module loading and/or compilation. + * Namespace-aware identifier completion (including local bindings, + names visible in the current module, and module names). + * Autodoc: the echo area shows information about the signature of the + procedure/macro around point automatically. + * Jump to definition of identifier at point. + * Access to documentation (including docstrings when the + implementation provides it). + * Listings of identifiers exported by a given module. + * Listings of callers/callees of procedures. + * Rudimentary support for debugging (when the REPL provides a + debugger) and error navigation. + * Support for multiple, simultaneous REPLs. + * Support for image display in those Schemes that treat them as first + class values. + + In the following pages, i'll try to explain what these features +actually are (i'm just swanking here), and how to use them for your +profit. But, before that, let's see how to install Geiser. + + +File: web.info, Node: Installation, Next: The REPL, Prev: Introduction, Up: Top + +2 Installation +************** + +* Menu: + +* Must needs:: +* The easy and quick way:: +* Chicken installation:: +* Gambit installation:: +* From the source's mouth:: +* Friends:: + + +File: web.info, Node: Must needs, Next: The easy and quick way, Prev: Installation, Up: Installation + +2.1 Must needs +============== + +If Geiser came with any guarantees, you'd break all of them by not using +GNU Emacs 24 (or better: i regularly use it with a recent Emacs +snapshot) and at least one of the supported Schemes, namely: + + * Guile (http://www.gnu.org/software/guile) 2.2 or better + * Chicken (http://call-cc.org) 4.8.0 or better + * MIT/GNU Scheme (https://www.gnu.org/software/mit-scheme/) 9.1 or + better + * Chibi Scheme (http://synthcode.com/scheme/chibi/) 0.7 or better + * Chez Scheme (http://www.scheme.com) 9.4 or better + * Gambit (http://gambitscheme.org/wiki/index.php/Main_Page) 4.9 or + better + * Racket (http://www.racket-lang.org) 6.0 or better + + Since Geiser supports multiple REPLs, having all of them will just +add to the fun. + + You'll also need Geiser itself. The quickest installation is via its +ELPA package, as described in the next section. If you prefer to use +the source code directly, it's not that difficult either: just keep on +reading. + + +File: web.info, Node: The easy and quick way, Next: Chicken installation, Prev: Must needs, Up: Installation + +2.2 The easy and quick way +========================== + +Did i mention that the easiest way of installing Geiser is using its +ELPA (http://emacswiki.org/emacs/ELPA) package? If you're using Emacs +24, ELPA (http://emacswiki.org/emacs/ELPA) is already there; for earlier +versions, the page i just linked to twice will tell you where to find +the goodies. + + ELPA packages live in repositories accessible via HTTP. You can find +Geiser's package in either MELPA stable +(http://stable.melpa.org/#/geiser) or, if you like living on the +bleeding edge, MELPA (http://melpa.org/#/geiser) (directly from the git +repo). To tell Emacs that an ELPA repo exists, you add it to +'package-archives': + + (require 'package) + ;;; either the stable version: + + (add-to-list 'package-archives + ;; choose either the stable or the latest git version: + ;; '("melpa-stable" . "http://stable.melpa.org/packages/") + '("melpa-unstable" . "http://melpa.org/packages/")) + + (package-initialize) + + And then installing Geiser is as easy as: + + M-x package-install RET geiser RET + + Unless you are using Gambit or Chicken, with that, you are pretty +much all set up. See *note The REPL:: to start using Geiser. If you +plan to use Chicken or Gambit, just keep reading below for a few +additional instructions to set up your environment. + + +File: web.info, Node: Chicken installation, Next: Gambit installation, Prev: The easy and quick way, Up: Installation + +2.3 Chicken installation +======================== + +If you plan to use Chicken, you'll need also to fire a terminal and +configure a couple of Chicken eggs. For Chicken 4 that would be: + $ chicken-install -s apropos chicken-doc + $ cd `csi -p '(chicken-home)'` + $ curl http://3e8.org/pub/chicken-doc/chicken-doc-repo.tgz | sudo tar zx + + while Chicken 5 prefers: + $ chicken-install -s apropos chicken-doc srfi-18 srfi-1 + $ cd `csi -R chicken.platform -p '(chicken-home)'` + $ curl https://3e8.org/pub/chicken-doc/chicken-doc-repo-5.tgz | sudo tar zx + + (see also Chicken's wiki (https://wiki.call-cc.org/emacs#geiser)). + + +File: web.info, Node: Gambit installation, Next: From the source's mouth, Prev: Chicken installation, Up: Installation + +2.4 Gambit installation +======================= + +If you plan to use Gambit, you'll also need to open a terminal and +configure a couple of awesome Gambit's features: + + 1. Clone the last version of gambit and of this repo + 2. Configure Gambit using '--enable-rtlib-debug-source' to activate + autodoc + $ cd ~/ + $ git clone "the gambit repo current address" + $ cd gambit + $ ./configure --enable-single-host --enable-debug --enable-rtlib-debug-source + $ make bootstrap + $ make bootclean + $ make -j + $ make install + 3. Put a link to 'geiser/elisp/geiser.el' in your init file in your + init file paste : + (load-file "~/geiser/elisp/geiser.el") + (the path is your path to geiser.el.) + + And, if you also want to use a remote Gambit REPL: + + 1. Enable the gambit/geiser module: + $ mkdir ~/gambit/lib/gambit/geiser + $ cp ~/geiser/geiser-module/* ~/gambit/lib/geiser/ + 2. Now that you have the module you start gsi with it and using the + '-:d' option: + $ gsi -:d gambit/geiser - + 3. You can now open emacs and call + M-x geiser-connect gambit + Enjoy! + + By the way, if you are unable to use gambit modules, open gsi with +the 'gambit.scm' file located in +'geiser/scheme/gambit/geiser/gambit.scm'; something like: + gsi -:d ~/geiser/scheme/gambit/geiser/gambit.scm - + (Keep in mind that these paths may be a little different for you.) + + +File: web.info, Node: From the source's mouth, Next: Friends, Prev: Gambit installation, Up: Installation + +2.5 Installing from source +========================== + +Downloading Geiser +.................. + +The latest release tarballs can be found here +(https://gitlab.com/jaor/geiser/-/releases). + + If you feel like living on the bleeding edge, just grab Geiser from +its Git repository over at Savannah +(http://git.savannah.nongnu.org/cgit/geiser.git/), either with the +following incantation: + + git clone git://git.sv.gnu.org/geiser.git + +or, if you happen to live behind a firewall, with the alternative: + + git clone http://git.sv.gnu.org/r/geiser.git + +You can also follow Geiser's development in one +(https://gitlab.com/jaor/geiser) or (http://repo.or.cz/w/geiser.git) +three (http://gitorious.org/geiser) mirrors that are kept synchronized +with the one at Savannah. + + Either way, you'll now be in possession of a copy of Geiser's libre +code. I'll follow you into its directory and the next section. + +Setting it up +............. + +Geiser is ready to be used out of the box without much more ado. For +the sake of concreteness, let's assume you put its source in the +directory '~/lisp/geiser'. All you need to do is to add the following +line to your Emacs initialisation file (be it '~/.emacs', +'~/.emacs.d/init.el' or any of its moral equivalents): + + (load-file "~/lisp/geiser/elisp/geiser.el") + +or simply evaluate that form inside Emacs (you wouldn't kill a friend +just to start using Geiser, would you?). That's it: you're ready to go +(*note The REPL::). + + What? You still here? I promise the above is all that's needed to +start using Geiser. But, in case you are missing your configure/make +all install routine, by all means, you can go through those motions to +byte compile and install Geiser too. That is, you enter the source +directory and (since we grabbed the development tree) run the customary +autogen script: + + $ cd ~/lisp/geiser + $ ./autogen.sh + +I recommend that you compile Geiser in a separate directory: + + $ mkdir build && cd build + $ ../configure + <some drivel here> + $ make all + <more of the above> + + Now you have two options: loading the byte-compiled Geiser from the +'elisp' subdirectory, or installing it system-wide. To load the +byte-code from here, add this line to your initialisation file: + + (load "~/lisp/geiser/build/elisp/geiser-load") + +and eval that form and you're done (you could also restart Emacs, but +killing your friends is widely considered bad form). Yes, that's 'load' +and 'geiser-load' instead of 'load-file' and 'geiser.el'. + + If you prefer a system-wide installation, just type: + + $ sudo make install + + With the above spell, Geiser will be compiled and installed in a safe +place inside Emacs' load path. To load it into Emacs you'll need, +instead of the 'load-file' form above, the following line in your +initialisation file: + + (require 'geiser-install) + +Please note that we're requiring 'geiser-install', and not 'geiser', and +that there's no 'load-file' to be seen this time. There are some ways +of fine-tuning this process, mainly by providing additional arguments in +the call to configure: you'll find those gory details in the file called +'INSTALL', right at the root of the source tree. The installation will +also take care of placing this manual, in Info format, where Emacs can +find it, so you can continue to learn about Geiser inside its natural +habitat. See you there and into the next chapter! + + +File: web.info, Node: Friends, Prev: From the source's mouth, Up: Installation + +2.6 Friends +=========== + +Although Geiser does not need them, it plays well with (and is enhanced +by) the following Emacs packages: + + * Paredit (http://www.emacswiki.org/emacs/ParEdit). Regardless of + whether you use Geiser or not, you shouldn't be coding in any Lisp + dialect without the aid of Taylor Campbell's structured editing + mode. + * Company (http://company-mode.github.io/). Nikolaj Schumacher's and + Dmitry Gutov's 'company-mode' provides a generic front-end for + completion engines (such as Geiser's), with pretty and automatic + completion lists. + * ac-geiser (https://github.com/xiaohanyu/ac-geiser/) If you prefer + 'auto-complete-mode' to 'company-mode', Xiao Hanyu's 'ac-geiser', + which provides a Geiser plugin for the popular Emacs Auto + Completion Mode (https://www.emacswiki.org/emacs/AutoComplete), is + the package for you. Like Geiser, 'ac-geiser' is available in + MELPA, and also as an 'el-get' package. + +You just need to install and setup them as usual, for every package's +definition of usual. Geiser will notice their presence and react +accordingly. + + +File: web.info, Node: The REPL, Next: Between the parens, Prev: Installation, Up: Top + +3 The REPL +********** + +If you've followed the instructions in *note Installation::, your Emacs +is now ready to start playing. Otherwise, i'll wait for you: when +you're ready, just come back here and proceed to the following sections. + +* Menu: + +* Starting the REPL:: +* First aids:: +* Switching context:: +* Completion and error handling:: +* Autodoc and friends:: +* Seeing is believing:: +* Customization and tips:: + + +File: web.info, Node: Starting the REPL, Next: First aids, Prev: The REPL, Up: The REPL + +3.1 Starting the REPL +===================== + +To start a Scheme REPL (meaning, a Scheme process offering you a +Read-Eval-Print Loop), Geiser provides the generic interactive command +'run-geiser'. If you invoke it (via, as is customary in Emacs, 'M-x +run-geiser'), you'll be saluted by a prompt asking which one of the +supported implementations you want to launch--yes, you can stop the +asking, see *note below: active-implementations. Tabbing for completion +will offer you, as of this writing, 'guile', 'racket', 'chicken', 'mit', +'chibi' and 'chez'. Just choose your poison, and a new REPL buffer will +pop up (by default, the REPL will appear in a new window: if that annoys +you, just set 'geiser-repl-use-other-window' to 'nil' and the current +window will be used). + + If all went according to plan, you'll be facing an +implementation-dependent banner, followed by an interactive prompt. +Going according to plan includes having the executable of the Scheme you +chose in your path. If that's not the case, you can tell Emacs where it +is, as described in *note a moment: impl-binary. Returning to our REPL, +the first thing to notice is that the funny prompt is telling you your +current module: its name is the part just after the @ sign (in Guile, +that means 'guile-user', while Racket's and Chicken's top namespaces +don't have a name; cf. discussion in *note Switching context::). Other +than that, this is pretty much equivalent to having a command-line +interpreter in a terminal, with a bunch of add-ons that we'll be +reviewing below. You can start typing sexps right there: Geiser will +only dispatch them for evaluation when they're complete, and will indent +new lines properly until then. It will also keep track of your input, +maintaining a history file that will be reloaded whenever you restart +the REPL. + + If you're not happy with the faces Geiser is using for the REPL's +prompt and evaluated input, you can customise +'geiser-font-lock-repl-prompt' and 'geiser-font-lock-repl-input' to +better-looking faces. + +Connecting to an external Scheme +................................ + +There's an alternative way of starting a Geiser REPL: you can connect to +an external Scheme process, provided it's running a REPL server at some +known port. How to make that happen depends on the Scheme +implementation. + + If you use Guile, you just need to start your Guile process (possibly +outside Emacs) passing to it the flag '--listen'. This flag accepts an +optional port as argument (as in '--listen=1969'), if you don't want to +use the default. + + In Racket, you have to use the REPL server that comes with Geiser. +To that end, put Geiser's Racket 'scheme' directory in Racket's +collection search path and invoke 'start-geiser' (a procedure in the +module 'geiser/server') somewhere in your program, passing it the +desired port and, if desired, network interface name. This procedure +will start the REPL server in a separate thread. For an example of how +to do that, see the script 'bin/geiser-racket.sh' in the source +distribution, or, if you've compiled Geiser, 'bin/geiser-racket-noinst' +in the build directory, or, if you've installed Geiser, 'geiser-racket' +in '<installation-prefix>/bin'. These scripts start a new interactive +Racket that is also running a REPL server (they also load the errortrace +library to provide better diagnostics, but that's not strictly needed). + + With your external Scheme process running and serving, come back to +Emacs and execute 'M-x geiser-connect', 'M-x connect-to-guile' or 'M-x +connect-to-racket'. You'll be asked for a host and a port, and, voila, +you'll have a Geiser REPL that is served by the remote Scheme process in +a dedicated thread, meaning that your external program can go on doing +whatever it was doing while you tinker with it from Emacs. Note, +however, that all Scheme threads share the heap, so that you'll be able +to interact with those other threads in the running Scheme from Emacs in +a variety of ways. For starters, all your (re)definitions will be +visible everywhere. That's dangerous, but will come in handy when you +need to debug your running web server. + + The connection between Emacs and the Scheme process goes over TCP, so +it can be as remote as you need, perhaps with the intervention of an SSH +tunnel. + + +File: web.info, Node: First aids, Next: Switching context, Prev: Starting the REPL, Up: The REPL + +3.2 First aids +============== + +A quick way of seeing what else Geiser's REPL can do for you, is to +display the corresponding entry up there in your menu bar. No, i don't +normally use menus either; but they can come in handy until you've +memorized Geiser's commands, as a learning device. And yes, i usually +run Emacs inside a terminal, but one can always use La Carte +(http://www.emacswiki.org/emacs/LaCarte) to access the menus in a +convenient enough fashion. + + Or just press 'C-h m' and be done with that. + + Among the commands at your disposal, we find the familiar input +navigation keys, with a couple twists. By default, 'M-p' and 'M-n' are +bound to matching items in your input history. That is, they'll find +the previous or next sexp that starts with the current input prefix +(defined as the text between the end of the prompt and your current +position, a.k.a. "point", in the buffer). For going up and down the +list unconditionally, just use 'C-c M-p' and 'C-c M-n'. In addition, +navigation is sexp-based rather than line-based. + + There are also a few commands to twiddle with the Scheme process. +'C-c C-q' will gently ask it to quit, while 'C-u C-c C-q' will +mercilessly kill the process (but not before stowing your history in the +file system). Unless you're using a remote REPL, that is, in which case +both commands will just sever the connection and leave the remote +process alone. If worse comes to worst and the process is dead, 'C-c +C-z' will restart it. However, the same shortcut, issued when the REPL +is alive, will bring you back to the buffer you came from, as explained +in *note this section: switching-repl-buff. + + The remaining commands are meatier, and deserve sections of their +own. + + +File: web.info, Node: Switching context, Next: Completion and error handling, Prev: First aids, Up: The REPL + +3.3 Switching context +===================== + +In tune with Geiser's modus operandi, evaluations in the REPL take place +in the namespace of the current module. As noted above, the REPL's +prompt tells you the name of the current module. To switch to a +different one, you can use the command 'switch-to-geiser-module', bound +to 'C-c C-m'. You'll notice that Geiser simply uses a couple of +meta-commands provided by the Scheme REPL (the stock ',m' in Guile and +Chicken and the (geiser-defined) ',enter' in Racket), and that it +doesn't even try to hide that fact. That means that you can freely use +said native ways directly at the REPL, and Geiser will be happy to +oblige. In Racket, ',enter' works like Racket's standard 'enter!' form, +but you can also provide a path string as its argument (e.g., ',enter +"/tmp/foo.rkt"' is equivalent to ',enter (file "/tmp/foo.rkt")'). Like +'enter!', ',enter' accepts also module names (as in, say, ',enter +geiser/main'). As mentioned, in Guile and Chicken, ',m' is used as is. + + Once you enter a new module, only those bindings visible in its +namespace will be available to your evaluations. All Schemes supported +by Geiser provide a way to import new modules in the current namespace. +Again, there's a Geiser command, 'geiser-repl-import-module', to invoke +such functionality, bound this time to 'C-c C-i'. And, again, you'll +see Geiser just introducing the native incantation for you, and you're +free to use such incantations by hand whenever you want. + + One convenience provided by these two Geiser commands is that +completion is available when introducing the new module name, using the +'<TAB>' key. Pressing it at the command's prompt will offer you a +prefix-aware list of available module names. + + Which brings me to the next group of REPL commands. + + +File: web.info, Node: Completion and error handling, Next: Autodoc and friends, Prev: Switching context, Up: The REPL + +3.4 Completion and error handling +================================= + +We've already seen Geiser completion of module names in action at the +minibuffer. You won't be surprised to know that it's also available at +the REPL buffer itself. There, you can use either 'C-.' or 'M-`' to +complete module names, and '<TAB>' or 'M-<TAB>' to complete identifiers. +Geiser will know what identifiers are bound in the current module and +show you a list of those starting with the prefix at point. Needless to +say, this is not a static list, and it will grow as you define or import +new bindings in the namespace at hand. If no completion is found, +'<TAB>' will try to complete the prefix after point as a module name. + + REPL buffers use Emacs' compilation mode to highlight errors reported +by the Scheme interpreter, and you can use the 'next-error' command +('M-g n') to jump to their location. By default, every time you enter a +new expression for evaluation old error messages are forgotten, so that +'M-g n' will always jump to errors related to the last evaluation +request, if any. If you prefer a not-so-forgetful REPL, set the +customization variable 'geiser-repl-forget-old-errors-p' to 'nil'. +Note, however, that even when that variable is left as 't', you can +always jump to an old error by moving to its line at the REPL and +pressing '<RET>'. When your cursor is away from the last prompt, +'<TAB>' will move to the next error in the buffer, and you can use +'<BACKTAB>' everywhere to go to the previous one. + +Caveat about completion & the REPL +---------------------------------- + +It is possible for Geiser to hang your Emacs process when trying to +complete symbols. This can happen in the REPL itself or even in a +Scheme buffer that is attached to the REPL process. If this happens, +you've probably entered a module that changes the REPL prompt from what +Geiser was expecting to see. + + Unfortunately, there's no general solution for this issue right now +(as it is a daunting task to try to make a regexp that can encompass all +possible REPL prompts). The best solution for now is to fix this issue +on a case-by-case basis by adjusting your prompt regexp variable so that +it matches the default prompt as well as your Scheme module's special +prompt. + + For example, XREPL is a Racket module that implements a better Racket +REPL. You might be interested in toying around with some of its +functions, but when you try to enter XREPL via, say, 'C-c C-m xrepl', +you'll notice that the REPL prompt has changed to something like this: + + <pkgs>/xrepl-lib/xrepl/main> + + If you start typing symbols, and then you try to auto-complete those +symbols, your Emacs process may hang. This is because Geiser expects +the REPL prompt to match this regexp (for Racket): + + "\\(mzscheme\\|racket\\)@[^ ]*> " + + Therefore, we can fix this issue by changing our default prompt +regexp like so: + + (setq geiser-racket--prompt-regexp "<pkgs>.*> \\|\\(mzscheme\\|racket\\)@[^ ]*> ") + + Note that you may have to run 'M-x geiser-reload' after setting this +variable so that your changes will take effect. + + Again, you'll have to change the regexp to fit every prompt that +causes this issue, but the only alternative (that we can think of right +now) is to create a regexp that will match every possible prompt. +Obviously, that is going to be more than a little tricky. However, if +you have a better solution than that, please share it with the Geiser +developers; we'll be more than happy to hear it. + + +File: web.info, Node: Autodoc and friends, Next: Seeing is believing, Prev: Completion and error handling, Up: The REPL + +3.5 Autodoc and friends +======================= + +Oftentimes, there's more you'll want to know about an identifier besides +its name: What module does it belong to? Is it a procedure and, if so, +what arguments does it take? Geiser tries to help you answering those +questions too. + + Actually, if you've been playing with the REPL as you read, you might +have notice some frantic activity taking place in the echo area every +now and then. That was Geiser trying to be helpful (while, hopefully, +not being clippy), or, more concretely, what i call, for want of a +better name, its "autodoc" mode. Whenever it's active (did you notice +that A in the mode-line?), Geiser's gerbils will be scanning what you +type and showing (unless you silence them with 'C-c C-d C-a') +information about the identifier nearest to point. + + If that identifier corresponds to a variable visible in the current +namespace, you'll see the module it belongs to and its value. For +procedures and macros, autodoc will display, instead of their value, the +argument names (or an underscore if Geiser cannot determine the name +used in the definition). Optional arguments are surrounded by +parentheses. When the optional argument has a default value, it's +represented by a list made up of its name and that value. When the +argument is a keyword argument, its name has "#:" as a prefix. + + If that's not enough documentation for you, 'C-c C-d d' will open a +separate documentation buffer with help on the symbol at point. This +buffer will contain implementation-specific information about the +identifier (e.g., its docstring for Guile, or its contract, if any, for +Racket), and a handy button to open the corresponding manual entry for +the symbol, which will open an HTML page (for Racket and Chicken) or the +texinfo manual (for Guile). If you'd rather go directly to the manual, +try 'C-c C-d i', which invokes 'geiser-doc-look-up-manual' as the handy +button does. + + Geiser can also produce for you a list, classified by kind, of the +identifiers exported by a given module: all you need to do is press 'C-c +C-d m', and type or complete the desired module's name. + + The list of exported bindings is shown, again, in a buffer belonging +to Geiser's documentation browser, where you have at your disposal a +bunch of navigation commands listed in *note our cheat-sheet: +Documentation browser. + + We'll have a bit more to say about the documentation browser in *note +a later section: doc-browser. + + If that's still not enough, Geiser can jump, via 'M-.', to the +symbol's definition. A buffer with the corresponding file will pop up, +with its point resting upon the identifier's defining form. When you're +done inspecting, 'M-,' will bring you back to where you were. As we +will see, these commands are also available in Scheme buffers. 'M-.' +also works for modules: if your point is on an unambiguous module name, +the file where it's defined will be opened for you. + + +File: web.info, Node: Seeing is believing, Next: Customization and tips, Prev: Autodoc and friends, Up: The REPL + +3.6 Seeing is believing +======================= + +In schemes that support images as values (currently, that means Racket), +the REPL will display them inline if you're using them in a +graphics-aware Emacs. + + For the terminal, images will appear as buttons: press return on them +to invoke an external viewer (configurable via 'geiser-image-viewer') +that will show you the image at hand. You can also ask for the same +behaviour on all emacsen by customising 'geiser-repl-inline-images-p' to +'nil'. + + Geiser keeps a cache of the last displayed images in the directory +'geiser-image-cache-dir', which defaults to the system's temp directory, +with up to 'geiser-image-cache-keep-last' files. You can invoke the +external image viewer on any of them with 'M-x geiser-view-last-image', +which takes a prefix argument to indicate which image number you want, 0 +corresponding to the newest one. + + +File: web.info, Node: Customization and tips, Prev: Seeing is believing, Up: The REPL + +3.7 Customization and tips +========================== + +The looks and ways of the REPL can be fine-tuned via a bunch of +customization variables. You can see and modify them all in the +corresponding customization group (by using the menu entry or the good +old 'M-x customize-group geiser-repl'), or by setting them in your Emacs +initialisation files (as a rule, all knobs in Geiser are tunable this +way: you don't need to use customization buffers if you don't like +them). + + I'm documenting below a proper subset of those settings, together +with some related tips. + +Choosing a Scheme implementation +................................ + +Instead of using the generic 'run-geiser' command, you can directly +start your Scheme of choice using any of the following commands: + * 'run-racket' + * 'run-guile' + * 'run-chicken' + * 'run-mit' + * 'run-chibi' + * 'run-chez' + In addition, the variable 'geiser-active-implementations' contains a +list of those Schemes Geiser should be aware of. Thus, if you happen to +be, say, a racketeer not to be beguiled by other schemes, you can tell +Geiser to forget about the richness of the Scheme ecosystem with +something like: + + (setq geiser-active-implementations '(racket)) + +in your initialisation files. + + When starting a new REPL, Geiser assumes, by default, that the +corresponding Scheme binary is in your path. If that's not the case, +the variables to tweak are (depending on which Scheme you choose): + * 'geiser-guile-binary' + * 'geiser-racket-binary' + * 'geiser-chicken-binary' + * 'geiser-mit-binary' + * 'geiser-chibi-binary' + * 'geiser-chez-binary' + They should be set to a string with the full path to the requisite +binary. + + Before starting the REPL, Geiser will check wether the version of +your Scheme interpreter is good enough. This means that it will spend a +couple tenths of a second launching and quickly discarding a Scheme +process, but also that the error message you'll get if you're on the +wrong Scheme version will be much more informative. If you one to avoid +version checks, just check 'geiser-repl-skip-version-check-p' to 't' in +your configuration. + + You can also specify a couple more initialisation parameters. For +Guile, 'geiser-guile-load-path' is a list of paths to add to its load +path (and its compiled load path) when it's started, while +'geiser-guile-init-file' is the path to an initialisation file to be +loaded on start-up. The equivalent variables for Racket are +'geiser-racket-collects' and 'geiser-racket-init-file'. + + Note, however, that specifying 'geiser-guile-init-file' is not +equivalent to changing Guile's initialization file ('~/.guile'), because +the former is loaded using the '-l' flag, together with '-q' to disable +loading the second. But there are subtle differences in the way Guile +loads the initialization file versus how it loads a file specified via +the '-l' flag. If what you want is just loading '~/.guile', leave +'geiser-guile-init-file' alone and set 'geiser-guile-load-init-file-p' +to 't' instead. + + These variables controlling your scheme's initialisation process are +good candidates for an entry in a project's '.dir-locals.el' file, so +that they are automatically set to a sensible value whenever you start a +REPL in the project's directory. + +Racket startup time +................... + +When starting Racket in little computers, Geiser might have to wait a +bit more than it expects (which is ten seconds, or ten thousand +milliseconds, by default). If you find that Geiser is giving up too +quickly and complaining that no prompt was found, try to increase the +value of 'geiser-repl-startup-time' to, say, twenty seconds: + + (setq geiser-repl-startup-time 20000) + +If you prefer, you can use the customize interface to, well, customise +the above variable's value. + +History +....... + +By default, Geiser won't record duplicates in your input history. If +you prefer it did, just set 'geiser-repl-history-no-dups-p' to 'nil'. +History entries are persistent across REPL sessions: they're saved in +implementation-specific files whose location is controlled by the +variable 'geiser-repl-history-filename'. For example, my Geiser +configuration includes the following line: + + (setq geiser-repl-history-filename "~/.emacs.d/geiser-history") + +which makes the files 'geiser-history.guile' and 'geiser-history.racket' +to live inside my home's '.emacs.d' directory. + +Autodoc +....... + +If you happen to love peace and quiet and prefer to keep your REPL's +echo area free from autodoc's noise, 'geiser-repl-autodoc-p' is the +customization variable for you: set it to 'nil' and autodoc will be +disabled by default in new REPLs. You can always bring the fairies +back, on a per-REPL basis, using 'C-c C-d C-a'. + +Remote connections +.................. + +When using any of the connection commands (e.g. 'geiser-connect', +'connect-to-guile', 'connect-to-racket', etc.) you'll be prompted for a +host and a port, defaulting to "localhost" and 37146. You can change +those defaults customizing 'geiser-repl-default-host' and +'geiser-repl-default-port', respectively. + +Killing REPLs +............. + +If you don't want Emacs to ask for confirmation when you're about to +kill a live REPL buffer (as will happen, for instance, if you're exiting +Emacs before closing all your REPLs), you can set the flag +'geiser-repl-query-on-kill-p' to 'nil'. On a related note, the +customizable variable 'geiser-repl-query-on-exit-p' controls whether +Geiser should ask for confirmation when you exit the REPL explicitly +(via, say, 'C-c C-q', as opposed to killing the buffer), and is set to +'nil' by default. + + +File: web.info, Node: Between the parens, Next: Cheat sheet, Prev: The REPL, Up: Top + +4 Between the parens +******************** + +A good REPL is a must, but just about half the story of a good Scheme +hacking environment. Well, perhaps a bit more than a half; but, at any +rate, one surely needs also a pleasant way of editing source code. +Don't pay attention to naysayers: Emacs comes with an excellent editor +included for about any language on Earth, and just the best one when +that language is sexpy (especially if you use Paredit). Geiser's +support for writing Scheme code adds to Emacs' 'scheme-mode', rather +than supplanting it; and it does so by means of a minor mode +(unimaginatively dubbed 'geiser-mode') that defines a bunch of new +commands to try and, with the help of the same Scheme process giving you +the REPL, make those Scheme buffers come to life. + +* Menu: + +* Activating Geiser:: +* The source and the REPL:: +* Documentation helpers:: +* To eval or not to eval:: +* To err perchance to debug:: +* Jumping around:: +* Geiser writes for you:: + + +File: web.info, Node: Activating Geiser, Next: The source and the REPL, Prev: Between the parens, Up: Between the parens + +4.1 Activating Geiser +===================== + +With Geiser installed following any of the procedures described in *note +The easy and quick way:: or *note From the source's mouth::, Emacs will +automatically activate geiser-mode when opening a Scheme buffer. Geiser +also instructs Emacs to consider files with the extension 'rkt' part of +the family, so that, in principle, there's nothing you need to do to +ensure that Geiser's extensions will be available, out of the box, when +you start editing Scheme code. + + Indications that everything is working according to plan include the +'Geiser' minor mode indicator in your mode-line and the appearance of a +new entry for Geiser in the menu bar. If, moreover, the mode-line +indicator is the name of a Scheme implementation, you're indeed in a +perfect world; otherwise, don't despair and keep on reading: i'll tell +you how to fix that in a moment. + + The menu provides a good synopsis of everything Geiser brings to the +party, including those keyboard shortcuts we Emacsers love. If you're +seeing the name of your favourite Scheme implementation in the +mode-line, have a running REPL and are comfortable with Emacs, you can +stop reading now and, instead, discover Geiser's joys by yourself. I've +tried to make Geiser as self-documenting as any self-respecting Emacs +package should be. If you follow this route, make sure to take a look +at Geiser's customization buffers ('M-x customize-group <RET> geiser'): +there's lot of fine-tuning available there. You might also want to take +a glance at the tables in *note our cheat sheet: Cheat sheet. + + Since geiser-mode is a minor mode, you can toggle it with 'M-x +geiser-mode', and control its activation in hooks with the functions +'turn-on-geiser-mode' and 'turn-off-geiser-mode'. If, for some reason i +cannot fathom, you prefer geiser-mode not to be active by default, +customizing 'geiser-mode-auto-p' to 'nil' will do the trick. + + And if you happen to use a funky extension for your Scheme files that +is not recognised as such by Emacs, just tell her about it with: + + (add-to-list 'auto-mode-alist '("\\.funky-extension\\'" . scheme-mode)) + + Now, geiser-mode is just a useless wretch unless there's a running +Scheme process backing it up. Meaning that virtually all the commands +it provides require a REPL up and running, preferably corresponding to +the correct Scheme implementation. In the following section, we'll see +how to make sure that that's actually the case. + + +File: web.info, Node: The source and the REPL, Next: Documentation helpers, Prev: Activating Geiser, Up: Between the parens + +4.2 The source and the REPL +=========================== + +As i've already mentioned a couple of times, geiser-mode needs a running +REPL to be operative. Thus, a common usage pattern will be for you to +first call 'run-geiser' (or one of its variants, e.g. 'run-guile'), and +then open some Scheme files; but there's nothing wrong in first opening +a couple Scheme buffers and then starting the REPL (you can even find it +more convenient, since pressing 'C-c C-z' in a Scheme buffer will start +the REPL for you). Since Geiser supports more than one Scheme +implementation, though, there's the problem of knowing which of them is +to be associated with each Scheme source file. Serviceable as it is, +geiser-mode will try to guess the correct implementation for you, +according to the algorithm described below. + +How Geiser associates a REPL to your Scheme buffer +.................................................. + +To determine what Scheme implementation corresponds to a given source +file, Geiser uses the following algorithm: + + 1. If the file-local variable 'geiser-scheme-implementation' is + defined, its value is used. A common way of setting buffer-local + variables is to put them in a comment near the beginning of the + file, surrounded by '-*-' marks, as in: + + ;; -*- geiser-scheme-implementation: guile -*- + + 2. If you've customized 'geiser-active-implementations' so that it's a + single-element list, that element is used as the chosen + implementation. + 3. The contents of the file is scanned for hints on its associated + implementation. For instance, files that contain a '#lang' + directive will be considered Racket source code, while those with a + 'define-module' form in them will be assigned to a Guile REPL. + 4. The current buffer's file name is checked against the rules given + in 'geiser-implementations-alist', and the first match is applied. + You can provide your own rules by customizing this variable, as + explained below. + 5. If we haven't been lucky this far and you have customized + 'geiser-default-implementation' to the name of a supported + implementation, we'll follow your lead. + 6. See? That's the problem of being a smart aleck: one's always + outsmarted by people around. At this point, geiser-mode will + humbly give up and ask you to explicitly choose the Scheme + implementation. + + As you can see in the list above, there are several ways to influence +Geiser's guessing by means of customizable variables. The most direct +(and most impoverishing) is probably limiting the active implementations +to a single one, while customizing 'geiser-implementations-alist' is the +most flexible (and, unsurprisingly, also the most complex). Here's the +default value for the latter variable: + + (((regexp "\\.scm$") guile) + ((regexp "\\.ss$") racket) + ((regexp "\\.rkt$") racket)) + +which describes the simple heuristic that files with '.scm' as extension +are by default associated to a Guile REPL while those ending in '.ss' or +'.rkt' correspond to Racket's implementation (with the caveat that these +rules are applied only if the previous heuristics have failed to detect +the correct implementation, and that they'll match only if the +corresponding implementation is active). You can add rules to +'geiser-implementations-alist' (or replace all of them) by customizing +it. Besides regular expressions, you can also use a directory name; for +instance, the following snippet: + + (eval-after-load "geiser-impl" + '(add-to-list 'geiser-implementations-alist + '((dir "/home/jao/prj/frob") guile))) + +will add a new rule that says that any file inside my +'/home/jao/prj/frob' directory (or, recursively, any of its children) is +to be assigned to Guile. Since rules are first matched, first served, +this new rule will take precedence over the default ones. + + A final tip: if you want Geiser to start automatically a REPL for you +if it notices that there's no one active when it enters geiser-mode, you +can customize 'geiser-mode-start-repl-p' to 't'. + +Switching between source files and the REPL +........................................... + +Once you have a working geiser-mode, you can switch from Scheme source +buffers to the REPL or 'C-c C-z'. Those shortcuts map to the +interactive command 'switch-to-geiser'. + + If you use a numeric prefix, as in 'C-u C-c C-z', besides being +teleported to the REPL, the latter will switch to the namespace of the +Scheme source file, as if you had used 'C-c C-m' in the REPL, with the +source file's module as argument; cf. discussion in *note Switching +context::. This command is also bound to 'C-c C-a'. + + Once you're in the REPL, the same 'C-c C-z' shortcut will bring you +back to the buffer you jumped from, provided you don't kill the Scheme +process in between. This is why the command is called switch-to-geiser +instead of switch-to-repl, and what makes it really handy, if you ask +me. + + If for some reason you're not happy with the Scheme implementation +that Geiser has assigned to your file, you can change it with 'C-c C-s', +and you probably should take a look at the previous subsection to make +sure that Geiser doesn't get confused again. + +A note about context +.................... + +As explained before (*note Modus operandi::), all Geiser activities take +place in the context of the current namespace, which, for Scheme +buffers, corresponds to the module that the Scheme implementation +associates to the source file at hand (for instance, in Racket, there's +a one-to-one correspondence between paths and modules, while Guile +relies on explicit 'define-module' forms in the source file). + + Now that we have 'geiser-mode' happily alive in our Scheme buffers +and communicating with the right REPL instance, let us see what it can +do for us, besides jumping to and fro. + + +File: web.info, Node: Documentation helpers, Next: To eval or not to eval, Prev: The source and the REPL, Up: Between the parens + +4.3 Documentation helpers +========================= + +Autodoc redux +............. + +The first thing you will notice by moving around Scheme source is that, +every now and then, the echo area lights up with the same autodoc +messages we know and love from our REPL forays. This happens every time +the Scheme process is able to recognise an identifier in the buffer, and +provide information either on its value (for variables) or on its arity +and the name of its formal arguments (for procedures and macros). That +information will only be available if the module the identifier belongs +to has been loaded in the running Scheme image. So it can be the case +that, at first, no autodoc is shown for identifiers defined in the file +you're editing. But as soon as you evaluate them (either individually +or collectively using any of the devices described in *note To eval or +not to eval::) their signatures will start appearing in the echo area. + + Autodoc activation is controlled by a minor mode, 'geiser-autodoc', +which you can toggle with 'M-x geiser-autodoc-mode', or its associated +keyboard shortcut, 'C-c C-d a'. That /A indicator in the mode-line is +telling you that autodoc is active. If you prefer that it be inactive +by default (e.g., because you're connecting to a really remote scheme +and want to minimize network exchanges), just set +'geiser-mode-autodoc-p' to 'nil' in your customization files. Even when +autodoc mode is off, you can use 'geiser-autodoc-show', bound by default +to 'C-c C-d s', to show the autodoc string for the symbol at point. + + The way autodoc displays information deserves some explanation. It +will first show the name of the module where the identifier at hand is +defined, followed by a colon and the identifier itself. If the latter +corresponds to a procedure or macro, it will be followed by a list of +argument names, starting with the ones that are required. Then there +comes a list of optional arguments, if any, enclosed in parentheses. +When an optional argument has a default value (or a form defining its +default value), autodoc will display it after the argument name. When +the optional arguments are keywords, their names are prefixed with "#:" +(i.e., their names are keywords). An ellipsis (...) serves as a marker +of an indeterminate number of parameters, as is the case with rest +arguments or when autodoc cannot fathom the exact number of arguments +(this is often the case with macros defined using 'syntax-case'). +Another way in which autodoc displays its ignorance is by using an +underscore to display parameters whose name is beyond its powers. + + It can also be the case that a function or macro has more than one +signature (e.g., functions defined using 'case-lambda', or some +'syntax-rules' macros, for which Geiser has often the black magic +necessary to retrieve their actual arities). In those cases, autodoc +shows all known signatures (using the above rules for each one) +separated by a vertical bar (|). + + As you have already noticed, the whole autodoc message is enclosed in +parentheses. After all, we're talking about Scheme here. + + Finally, life is much easier when your cursor is on a symbol +corresponding to a plain variable: you'll see in the echo area its name, +preceded by the module where it's defined, and followed by its value, +with an intervening arrow for greater effect. This time, there are no +enclosing parentheses (i hope you see the logic in my madness). + + You can change the way Geiser displays the module/identifier combo by +customizing 'geiser-autodoc-identifier-format'. For example, if you +wanted a tilde surrounded by spaces instead of a colon as a separator, +you would write something like: + + (setq geiser-autodoc-identifier-format "%s ~ %s") + +in your Emacs initialisation files. There's also a face +('geiser-font-lock-autodoc-identifier') that you can customize (for +instance, with 'M-x customize-face') to change the appearance of the +text. And another one ('geiser-font-lock-autodoc-current-arg') that +controls how the current argument position is highlighted. + +Other documentation commands +............................ + +Sometimes, autodoc won't provide enough information for you to +understand what a function does. In those cases, you can ask Geiser to +ask the running Scheme for further information on a given identifier or +module. + + For symbols, the incantation is 'M-x geiser-doc-symbol-at-point', or +'C-c C-d C-d' for short. If the associated Scheme supports docstrings +(as, for instance, Guile does), you'll be teleported to a new Emacs +buffer displaying Geiser's documentation browser, filled with +information about the identifier, including its docstring (if any; +unfortunately, that an implementation supports docstrings doesn't mean +that they're used everywhere). + + Pressing 'q' in the documentation buffer will bring you back, +enlightened, to where you were. There's also a handful of other +navigation commands available in that buffer, which you can discover by +means of its menu or via the good old 'C-h m' command. And feel free to +use the navigation buttons and hyperlinks that justify my calling this +buffer a documentation browser. + + For Racket, which does not support docstrings out of the box, this +command will provide less information, but the documentation browser +will display the corresponding contract when it's available, as well as +some other tidbits for re-exported identifiers. + + You can also ask Geiser to display information about a module, in the +form of a list of its exported identifiers, using 'C-c C-d C-m', exactly +as you would do in *note the REPL: repl-mod. + + In both cases, the documentation browser will show a couple of +buttons giving you access to further documentation. First, you'll see a +button named source: pressing it you'll jump to the symbol's definition. +The second button, dubbed manual, will open the Scheme implementation's +manual page for the symbol at hand. For Racket, that will open your web +browser displaying the corresponding reference's page (using the HTML +browser in Racket's configuration, which you can edit in DrRacket's +preferences dialog, or by setting 'plt:framework-pref:external-browser' +directly in '~/.racket/racket-prefs.rktd'), while in Guile a lookup will +be performed in the texinfo manual. + + For Guile, the manual lookup uses the info indexes in the standard +Guile info nodes, which are usually named "guile" or "guile-2.0". If +yours are named differently, just add your name to the customizable +variable 'geiser-guile-manual-lookup-nodes'. + + A list of all navigation commands in the documentation browser is +available in *note our cheat-sheet: Documentation browser. + + You can also skip the documentation browser and jump directly to the +manual page for the symbol at point with the command +'geiser-doc-look-up-manual', bound to 'C-c C-d i'. + + +File: web.info, Node: To eval or not to eval, Next: To err perchance to debug, Prev: Documentation helpers, Up: Between the parens + +4.4 To eval or not to eval +========================== + +One of Geiser's main goals is to facilitate incremental development. +You might have noticed that i've made a big fuss of Geiser's ability to +recognize context, by being aware of the namespace where its operations +happen. + + That awareness is especially important when evaluating code in your +scheme buffers, using the commands described below. They allow you to +send code to the running Scheme with a granularity ranging from whole +files to single s-expressions. That code will be evaluated in the +module associated with the file you're editing, allowing you to redefine +values and procedures to your heart's (and other modules') content. + + Macros are, of course, another kettle of fish: one needs to +re-evaluate uses of a macro after redefining it. That's not a