Emacs and slime reference

From PaskvilWiki
Jump to: navigation, search
Emacs in General ---------------------------------------------------------------
* C-u N cmd                repeat the 'cmd' N-times (N is a number) - further on denoted [N] cmd
* M-N cmd                  repeat the 'cmd' N-times (N is a number) - further on denoted [N] cmd
* C-g                      stop current command - useful if emacs stops responding; also to discard command typed so far
* <Esc> <Esc> <Esc>        general "get out" command
* C-h c cmd                display brief help for the 'cmd'
* C-h k cmd                display a full help for the 'cmd'
* C-h f fn                 display a full help for the function 'fn'
* C-h a                    apropos - type word or regex to show all commands related to it
* C-h r                    reference manual
* chord C-h                print a list of all command that start with a given key 'chord' e.g. C-x C-h gives all commands starting with C-x
* C-h b, C-h m             list of available bindings, info about current mode
* C-x C-c                  quit

To (re)define key chord, edit your ~/.emacs file like this:
(define-key slime-repl-mode-map (kbd "C-c ;")
(global-set-key (quote [C-tab]) 'slime-complete-symbol)

To interactively create bindings, use (in Emacs):
1) M-x global-set-key
2) press the key combination you want
3) type the command to run upon this
4) press C-x ESC ESC to see the command in full

Moving around:
* C-v, M-v                one screen ahead/back
* [N] C-v, [N] M-v        move the screen down/up by N lines
* C-l                     center the screen around cursor, move to top, and move to bottom (on repetition of the stroke)
* [N] C-l                 move the current line to be N-th on the screen, 0-based
* C-b, C-f, C-p, C-n      move left/right/up/down
* M-b, M-f                move by words backward/forward
* C-a, C-e                move to the beginning/end of current line
* M-a, M-e                move to the beginning/end of current sentence
* M-<, M->                move to the beginning/end of whole text

* M-Bcksp, M-d            kill word before/after cursor
* C-k, M-k                kill from cursor to end of line (second C-k will kill \n at the end), to end of sentence
                          repeating C-k will accumulate the killed text (if you press C-k 10 times - killing 5 lines,
                          and then yank the text, it will yank all 5 lines, not just the last)
* [N] C-k                 kill N lines, including the newlines
* C-y                     yank the killed text
* M-y                     replace the yank with previous kill (i.e. after C-y, you can press M-y, and it will replace the yank
                          with text that was killed before this one, and so on; this is circular queue - press M-y will get you
                          back to the last kill; you can also use [N] M-y, where N can be positive or negative)
* C-x u, C-_              undo
                          undo's are considered ordinary changes; thus if the chain of undo's is stopped, e.g. with C-f, undo's can be undone

* C-x 1                   kill all other windows - go to "one window" editing; deletes all other windows, and expands current to full screen
* C-x 2                   split screen in 2
* C-x o                   move to "other" window
* C-M-v                   scroll the other window
* C-x 3                   split window vertically
* C-x 4 C-f file          open file in new bottom window and jump to it

* C-x C-f                 find (open) file; opens in a new buffer
* C-x C-s                 save the file contents

* C-x C-b                 list of buffers
* C-x b                   switch to buffer (prompts for buffer name)
* C-x s                   save some buffers
* C-x <lft>, C-x <rgh>    previous/next buffer
* C-x k    bfr            kill buffer 'bfr', defaults to current buffer

Search and Replace:
* C-s, C-r                search forward/backward, incrementally; C-s/C-r repeats the search, Backspace goes back, Enter ends the search
* M-x replace-string      params 'from' 'to'

SLIME - Superior Lisp Interaction Mode for Emacs -------------------------------
-- note: all 3-key commands can be used with or without `C-' for the last key;
e.g C-c C-d d can also be used as C-c C-d C-d
    C-c C-w c can also be used as C-c C-w C-c, etc.
with the exception of the last key being 'h'
-- Evaluation
* C-x C-e, C-c C-p        evaluate expression before point and show result in echo area/pretty print result in new buffer
* C-M-x                   evaluate current toplevel (note - if evaluating defvar, resets the variable even if already bound)
* C-c :                   evaluate expression read from minibuffer
* C-c C-r                 evaluate region
* C-x M-e                 evaluate expression before point, and show output buffer (useful for expressions that print to stdout)
* C-c E                   edit value of set-able form in new buffer, and set its value in Lisp upon commit with C-c C-c
* C-c C-u                 undefine (fmakunbound) function for the symbol at point

-- Compilation
* C-c C-c                 compile toplevel form at point; the code is executed afterwards
* [N] C-c C-c             -"-, with N>0 compile for maximal debugging, for N<0 for speed
* C-c C-k                 compile and load current buffer's source file
* C-c M-k                 compile but do not load current buffer's source file
* C-c C-l                 load Lisp file
---- after the compilation (notes are indicated as underlining on source forms)
* M-n, M-p                move to next/previous compiler note, and display it
* C-c M-c                 remove all annotations from buffer
* C-x `                   go to next error message

-- Completion and Editing
* M-TAB                   complete symbol at point
* C-c M-q                 reindent current defun
* M-x slime-close-all-parens-in-sexp
* M-x slime-insert-balanced-comments
* M-C-a, M-C-e            slime-beginning/end-of-defun
* M-x slime-ensure-typeout-frame    create typeout frame if necessary; it's like echo area, just scrollable and more persistent
* M-x slime-highlight-edits-mode    toggle on-off highlighting edits is file (e.g. to see what to recompile with C-c C-c)

-- Finding Definitions
* M-.                     go to the definition of the symbol at point
* M-,                     go to the point where M-. was invoked
* C-x 4 .                 like M-. but switches to the other window to edit the definition
* C-x 5 .                 like M-. but opens another frame to edit the definition in

-- Documentation
* SPC                     inserts space and looks up arguments list for the function at point
* C-c C-d d               describe the symbol at point
* C-c C-f                 describe the function at point
* C-c C-d a               perform apropos search on Lisp symbol names, and display their doc strings
* C-c C-d z               like C-c C-d a, but includes internal symbols by default
* C-c C-d p               show apropos results of all symbols in package
* C-c C-d h               hyperspec lookup, location defined in 'common-lisp-hyperspec-root'; the 'C-c C-d C-h' does not work here!
* C-c C-d ~               lookup a 'format character' in hyperspec

-- Cross-Reference
* C-c C-w c               show callers of a function
* C-c C-w w               show all known callees
* C-c C-w r               show references to global variable
* C-c C-w b               show bindings of a global variable
* C-c C-w s               show assignments to a global variable
* C-c C-w m               show expansions of a macro
* M-x slime-who-specializes        show all known methods that specialized on a class
---- Lisp system dependent (works by going through heap, and is only somewhere available)
* C-c <                   list callers of a function
* C-c >                   list callees of a function

-- Macro-Expansion
* C-c C-m                 macro-expand1 the expression at point
* C-c M-m                 macro-expand the expression at point

-- Disassembly
* C-c M-d                 disassemble the function definition of the symbol at point
* C-c C-t                 toggle tracing of the function at point
* M-x slime-untrace-all   untrace all functions

-- Abort/Recovery
* C-c C-b                 interrupt Lisp (send SIGINT)
* M-x slime-restart-inferior-lisp
* C-c ~                   synchronize the current package and working directory from Emacs to Lisp
* C-c M-p                 set the current package of the REPL
* M-x slime-cd            set the cwd of the Lisp process and of the REPL buffer
* M-x slime-pwd           print the current directory of the Lisp process

-- Inspector
* C-c I                   inspect the value of an expression entered in the minibuffer
---- within the inspector
* RET                     call inspector on the value at point; call the action if point is on action
* d                       describe the slot at point
* v                       toggle between verbose and terse mode
* l                       go back from the previous object (return from RET)
* n                       inverse of 'l', also bound to SPC
* q                       dismiss the inspector buffer
* M-RET                   store the value under point in variable '*', to access it in REPL

-- Profiling
* M-x slime-toggle-profile-fdefinition        toggle profiling of a function
* M-x slime-profile-package                   profile all functions in a package
* M-x slime-unprofile-all                     unprofile all functions
* M-x slime-profile-report                    report profiler data
* M-x slime-profile-reset                     reset profiler data
* M-x slime-profiled-functions                show list of currently profiled functions

SLIME Debugger (SLDB)
-- Examining Frames (going through stack frames in debugger)
* t                       toggle display of local variables and CATCH tags
* v                       view frame's current source expression in Lisp source file's buffer
* e                       evaluate an expression in the frame; it can refer to local variables in the frame
* d                       -"- and pretty print the result in a temp buffer
* D                       disassemble the frame's function
* i                       inspect the result of evaluating expression in the frame

-- Invoking Restarts
* a                       invoke the ABORT restart
* q                       "quit" - THROW to a tag that the toplevel SLIME request-loop catches
* c                       invoke the CONTINUE restart
* 0..9                    invoke restart by number; also can be called with RET on them in the buffer

-- Navigating between Frames
* n, p                    move between frames
* M-n, M-p                move with "sugar" - display details and source of the next frame only

-- Stepping
* s                       step to the next expression in the frame
* x                       step to next form in the current function
* o                       stop single-stepping temporarly, resume it upon return to this function

-- Miscellaneous
* r                       restart execution of the frame with the original arguments to it
* R                       return from the frame with the value entered in the minibuffer
* B                       exit SLDB and debug the condition using Lisp system's default debugger
* :                       evaluate an expression entered in the minibuffer

-- slime-selector command - for quickly switching to important buffers
-- to bind it to e.g. 'C-c s', use: (global-set-key "\C-cs" 'slime-selector)
-- the following keys switch to buffers:
* ?                       help buffer for current SLIME connection
* r                       the REPL for current SLIME connection
* d                       the most recently activated SLDB buffer
* l                       the most recently visited lisp-mode source buffer
* s                       the *slime-scratch* buffer

-- slime-macroexpansion-minor-mode
* C-c C-m                 macro-expand1 the current form in place (replaces the original form)
* g                       repeat the last macroexpansion, replacing the contents of the buffer with new expression
* q                       close the expansion buffer

SLIME Tips and Tricks
-- Setting Up the Lisp Image
   - to load swank without Emacs, just run: (load "/path/to/swank-loader.lisp") within the running Lisp image.
   now just run the swank server: (swank:create-server); to use just one port, e.g. when tunneling through ssh,
   tell swank not to use extra connection for output: (setf swank:*use-dedicated-output-stream* nil) [this is now default].
   -- parameters to swank:create-server:
      :port - port number to listen on (default 4005)
      :dont-close - should the server continue accepting connections after the first one? (default NIL)
      :coding-system - encoding to use for communication, e.g. "utf-8-unix"
   - then, on the Emacs side, you set these as parameters:
      (setq slime-net-coding-system 'utf-8-unix)
      (slime-connect "" 4005)
   - to create ssh tunnel for swank/slime: `ssh -L4005:localhost:4005 user@remote-machine.com`,
   then start the SLIME with 'M-x slime-connect RET RET' - RET RET means accepting defaults - localhost
   and 4005 port, the ssh tunnel will forward this to the 'remote-machine.com'
   - to translate filenames from local to remote, use 'tramp-mode', like this:
      (push (slime-create-filename-translator :machine-instance "remote-machine.com"
                                              :remote-host "remote"    ; this is what cl:machine-instance returns for the host name
                                              :username "user"

-- Connecting to SLIME automatically
   if you want SLIME to connect to Lisp whenever you open a Lisp file, add this to ~/.emacs:
      (add-hook 'slime-mode-hook
                (lambda ()
                  (unless (slime-connected-p)
                    (save-excursion (slime)))))

SLIME Presentations
-- presentation is region of text associated with Lisp object; right-click brings up menu with allowed operations;
   some, like inspecting, are for all, other are specialized; you can cut-paste presentations - the objects themselves,
   not just the text, - even if it's unreadable object
-- the package 'slime-presentations' installs them in REPL; they appear in red; they can be e.g. copied to a new input
   in REPL; copying incomplete presentation, or editing text within it will turn it to plain text; this can be undone
-- they are also available in inspector (all inspectable parts are presentations) and debugger (all local variables),
   thus can be evaluated in REPL; they are valid as long as the corresponding buffers are open
* C-c C-v SPC             marks presentation at point, making it possible to copy it
* C-c C-v w, C-c C-v r    copying the presentation at point to the kill ring/REPL
* C-c C-v d, C-c C-v i    describe/inspect the object associated with the presentation at point
* C-c C-v n, C-c C-v p    move point to the next/previous presentation in the buffer