Miscellaneous Features

You can evaluate Clojure code in the minibuffer at almost any time using M-x cider-read-and-eval (bound in cider-mode buffers to C-c M-:). TAB completion will work in the minibuffer, just as in REPL and source buffers.

Typing C-c C-v . in a Clojure buffer will insert the defun at point into the minibuffer for evaluation. This way you can pass arguments to the function and evaluate it and see the result in the minibuffer.

You can also enable other convenient modes in the minibuffer. For instance, you might want to have both eldoc-mode and paredit-mode available to you:

CIDER provides a simple way to create a Clojure scratchpad via the M-x cider-scratch command. This is a great way to play around with some code without having to create source files or pollute the REPL buffer and is very similar to Emacs’s own *scratch* buffer.

While Clojure’s and CIDER’s interactive programming style means you’ll restart your application far less often than with other languages and development environments, sometimes you’ll want to clean everything up and reload one or more namespaces to ensure that they are up to date and there are no temporary definitions hanging around.

Typing C-c M-n r or C-c M-n M-r will invoke cider-ns-refresh and reload all modified Clojure files on the classpath.

Adding a prefix argument, C-u C-c M-n r, will reload all the namespaces on the classpath unconditionally, regardless of their modification status.

Adding a double prefix argument, C-u C-u M-n r, will first clear the state of the namespace tracker before reloading. This is useful for recovering from some classes of error that normal reloads would otherwise not recover from. A good example is circular dependencies. The trade-off is that stale code from any deleted files may not be completely unloaded.

cider-ns-refresh wraps clojure.tools.namespace, and as such the same benefits and caveats regarding writing reloadable code also apply.

The above three operations are analogous to clojure.tools.namespace.repl/refresh, clojure.tools.namespace.repl/refresh-all and clojure.tools.namespace.repl/clear (followed by a normal refresh), respectively.

You can define Clojure functions to be called before reloading, and after a successful reload, when using cider-ns-refresh:

These must be set to the namespace-qualified names of vars bound to functions of no arguments. The functions must be synchronous (blocking), and are expected to be side-effecting - they will always be executed serially, without retries.

By default, messages regarding the status of the in-progress reload will be displayed in the echo area after you call cider-ns-refresh. The same information will also be recorded in the *cider-ns-refresh-log* buffer, along with anything printed to *out* or *err* by cider-ns-refresh-before-fn and cider-ns-refresh-start-fn.

You can make the *cider-ns-refresh-log* buffer display automatically after you call cider-ns-refresh by setting the cider-ns-refresh-show-log-buffer variable to a non-nil value. This will also prevent any related messages from also being displayed in the echo area.

By default, CIDER will prompt for whether to save all modified clojure-mode buffers visiting files on the classpath. You can customize this behavior with cider-ns-save-files-on-refresh and cider-ns-save-files-on-refresh-modes.

Sometimes, cider-ns-refresh may not work for you. If you’re looking for a bit more forceful reloading the cider-ns-reload and cider-ns-reload-all commands can be used instead. These commands invoke Clojure’s (require ... :reload) and (require ... :reload-all) commands at the REPL.

The cider-selector (C-c M-s) command allows you to quickly navigate to important buffers in the context of a Clojure project - e.g. the REPL, the stacktrace buffer, the doc buffer, the most recently visited Clojure file, etc. The usage of the command is extremely simple - after invoking it you need to type a single key identifying the target buffer (e.g. r for the REPL).

Here’s a list of all of cider-selector's keybindings:

You can easily extend the selector with new commands using def-cider-selector-method:

You can easily browse the items on your classpath with the command M-x cider-classpath.

Here you can see it in action:

Press RET on a classpath entry to navigate into it.

You can browse the contents of any loaded namespace with the command M-x cider-browse-ns. CIDER will prompt you for the namespace to browse.

You can also browse all available namespaces with M-x cider-browse-ns-all.

There are a bunch of useful keybindings that are defined in browser buffers.

If you are using Clojure 1.9 or newer you can browse the Clojure spec registry.

If you already know which spec you’re looking for, you can type M-x cider-browse-spec and CIDER will prompt you for a spec name and then drop you into the spec browser.

If you aren’t quite sure which spec you want, you can type M-x cider-browse-spec-all. CIDER will then prompt you for a regex and will filter out all the spec names that don’t match.

Once in the browser you can use your mouse or the keybindings below to navigate deeper.

If your project includes the org.clojure/test.check library, you can type e when browsing a spec to generate an example that meets the spec.

Sometimes in your documentation strings, you’d like to be able to point other programmers at different definitions. If you specify the name of a definition as a fully qualified symbol, or surround it in backticks (`...`) or Codox-style delimiters ([[...]]), CIDER will convert these references into live links when it displays the documentation string in the documentation buffer.

If the name is in another namespace, then you’ll have to include the fully qualified name in the docstring.

Example function with a docstring containing references:

You can change the delimiters that CIDER uses to find references if you want to support other reference formats. Simply update the regexp in cider-doc-xref-regexp to match your preferred format. The first group of the regexp should always match the cross-reference name. For example, if you want to want to use Latex-style references (\ref{...}) instead, the regexp would be: