`clojure-unwind`: Unwind a threaded expression. Supports both `->>` and `->`.
`clojure-thread-first-all`: Introduce the thread first macro (`->`) and rewrite
the entire form. With a prefix argument do not thread the last form.
`clojure-thread-last-all`: Introduce the thread last macro and rewrite the
entire form. With a prefix argument do not thread the last form.
`clojure-unwind-all`: Fully unwind a threaded expression removing the threading
macro.
### Cycling things
`clojure-cycle-privacy`: Cycle privacy of `def`s or `defn`s. Use metadata
explicitly with setting `clojure-use-metadata-for-privacy` to `t` for `defn`s
too.
`clojure-cycle-not`: Add or remove a `not` form around the current form.
`clojure-cycle-when`: Find the closest `when` or `when-not` up the syntax tree
and toggle it.
`clojure-cycle-if`: Find the closest `if` or `if-not` up the syntax tree and
toggle it. Also transpose the `else` and `then` branches, keeping the semantics
the same as before.
### Convert collection
Convert any given collection at point to list, quoted list, map, vector or set.
### Let expression
`clojure-introduce-let`: Introduce a new `let` form. Put the current form into
its binding form with a name provided by the user as a bound name. If called
with a numeric prefix put the let form Nth level up in the form hierarchy.
`clojure-move-to-let`: Move the current form to the closest `let`'s binding
form. Replace all occurrences of the form in the body of the let.
`clojure-let-forward-slurp-sexp`: Slurp the next form after the `let` into the
`let`. Replace all occurrences of the bound forms in the form added to the `let`
form. If called with a prefix argument slurp the next n forms.
`clojure-let-backward-slurp-sexp`: Slurp the form before the `let` into the
`let`. Replace all occurrences of the bound forms in the form added to the `let`
form. If called with a prefix argument slurp the previous n forms.
`paredit-convolute-sexp` is advised to replace occurrences of bound forms with their bound names when convolute is used on a let form.
### Rename ns alias
`clojure-rename-ns-alias`: Rename an alias inside a namespace declaration,
and all of its usages in the buffer
If there is an active selected region, only rename usages of aliases within the region,
without affecting the namespace declaration.
### Add arity to a function
`clojure-add-arity`: Add a new arity to an existing single-arity or multi-arity function.
## Related packages
* [clojure-mode-extra-font-locking][] provides additional font-locking
for built-in methods and macros. The font-locking is pretty
imprecise, because it doesn't take namespaces into account and it
won't font-lock a function at all possible positions in a sexp, but
if you don't mind its imperfections you can easily enable it:
```el
(require 'clojure-mode-extra-font-locking)
```
The code in `clojure-mode-font-locking` used to be bundled with
`clojure-mode` before version 3.0.
You can also use the code in this package as a basis for extending the
font-locking further (e.g. functions/macros from more
namespaces). Generally you should avoid adding special font-locking
for things that don't have fairly unique names, as this will result in
plenty of incorrect font-locking. CIDER users should avoid this package,
as CIDER does its own dynamic font-locking, which is namespace-aware
and doesn't produce almost any false positives.
* [clj-refactor][] provides refactoring support.
* Enabling `CamelCase` support for editing commands(like
`forward-word`, `backward-word`, etc) in `clojure-mode` is quite
useful since we often have to deal with Java class and method
names. The built-in Emacs minor mode `subword-mode` provides such
functionality:
```el
(add-hook 'clojure-mode-hook #'subword-mode)
```
* The use of [paredit][] when editing Clojure (or any other Lisp) code
is highly recommended. It helps ensure the structure of your forms is
not compromised and offers a number of operations that work on code
structure at a higher level than just characters and words. To enable
it for Clojure buffers:
```el
(add-hook 'clojure-mode-hook #'paredit-mode)
```
* [smartparens][] is an excellent
(newer) alternative to paredit. Many Clojure hackers have adopted it
recently and you might want to give it a try as well. To enable
`smartparens` use the following code:
```el
(add-hook 'clojure-mode-hook #'smartparens-strict-mode)
```
* [RainbowDelimiters][] is a
minor mode which highlights parentheses, brackets, and braces
according to their depth. Each successive level is highlighted in a
different color. This makes it easy to spot matching delimiters,
orient yourself in the code, and tell which statements are at a
given depth. Assuming you've already installed `RainbowDelimiters` you can
enable it like this:
```el
(add-hook 'clojure-mode-hook #'rainbow-delimiters-mode)
```
* [aggressive-indent-mode][] automatically adjust the indentation of your code,
while you're writing it. Using it together with `clojure-mode` is highly
recommended. Provided you've already installed `aggressive-indent-mode` you can
enable it like this:
```el
(add-hook 'clojure-mode-hook #'aggressive-indent-mode)
```
## REPL Interaction
One of the fundamental aspects of Lisps in general, and Clojure in
particular, is the notion of interactive programming - building your
programs by continuously changing the state of the running Lisp
program (as opposed to doing something more traditional like making a
change and re-running the program afterwards to see the changes in
action). To get the most of clojure-mode you'll have to combine it
with some tool which will allow you to interact with your Clojure program
(a.k.a. process/REPL).
A number of options exist for connecting to a
running Clojure process and evaluating code interactively.
### Basic REPL
[inf-clojure][] provides basic interaction with a Clojure REPL process.
It's very similar in nature and supported functionality to `inferior-lisp-mode`
for Common Lisp.
### CIDER
[CIDER][] is a powerful Clojure interactive development environment,
similar to SLIME for Common Lisp.
If you're into Clojure and Emacs you should definitely check it out.
## Tutorials
Tutorials,
targeting Emacs beginners, are available at
[clojure-doc.org](https://clojure-doc.org/articles/tutorials/editors/) and
[Clojure for the Brave and the True](https://www.braveclojure.com/basic-emacs/).
Keep in mind, however, that they might be out-of-date.
## Caveats
`clojure-mode` is a capable tool, but it's certainly not perfect. This section
lists a couple of general design problems/limitations that might affect your
experience negatively.
### General Issues
`clojure-mode` derives a lot of functionality directly from `lisp-mode` (an Emacs major mode for Common Lisp), which
simplified the initial implementation, but also made it harder to implement
certain functionality. Down the road it'd be nice to fully decouple `clojure-mode`
from `lisp-mode`.
See [this ticket](https://github.com/clojure-emacs/clojure-mode/issues/270) for a bit more details.
### Indentation Performance
`clojure-mode`'s indentation engine is a bit slow. You can speed things up significantly by disabling `clojure-use-backtracking-indent`, but this will break the indentation of complex forms like `deftype`, `defprotocol`, `reify`, `letfn`, etc.
We should look into ways to optimize the performance of the backtracking indentation logic. See [this ticket](https://github.com/clojure-emacs/clojure-mode/issues/606) for more details.
### Font-locking Implementation
As mentioned [above](https://github.com/clojure-emacs/clojure-mode#font-locking), the font-locking is implemented in terms of regular expressions which makes it both slow and inaccurate.
## Changelog
An extensive changelog is available [here](CHANGELOG.md).
## License
Copyright © 2007-2025 Jeffrey Chu, Lennart Staflin, Phil Hagelberg, Bozhidar
Batsov, Artur Malabarba, Magnar Sveen and [contributors][].
Distributed under the GNU General Public License; type C-h C-c to view it.
[badge-license]: https://img.shields.io/badge/license-GPL_3-green.svg
[melpa-badge]: https://melpa.org/packages/clojure-mode-badge.svg
[melpa-stable-badge]: https://stable.melpa.org/packages/clojure-mode-badge.svg
[melpa-package]: https://melpa.org/#/clojure-mode
[melpa-stable-package]: https://stable.melpa.org/#/clojure-mode
[COPYING]: https://www.gnu.org/copyleft/gpl.html
[badge-circleci]: https://circleci.com/gh/clojure-emacs/clojure-mode.svg?style=svg
[circleci]: https://circleci.com/gh/clojure-emacs/clojure-mode
[CIDER]: https://github.com/clojure-emacs/cider
[cider-nrepl]: https://github.com/clojure-emacs/cider-nrepl
[inf-clojure]: https://github.com/clojure-emacs/inf-clojure
[contributors]: https://github.com/clojure-emacs/clojure-mode/contributors
[melpa]: https://melpa.org
[melpa stable]: https://stable.melpa.org
[clojure-mode-extra-font-locking]: https://github.com/clojure-emacs/clojure-mode/blob/master/clojure-mode-extra-font-locking.el
[clj-refactor]: https://github.com/clojure-emacs/clj-refactor.el
[paredit]: https://mumble.net/~campbell/emacs/paredit.html
[smartparens]: https://github.com/Fuco1/smartparens
[RainbowDelimiters]: https://github.com/Fanael/rainbow-delimiters
[aggressive-indent-mode]: https://github.com/Malabarba/aggressive-indent-mode
clojure-mode-5.20.0/clojure-mode-extra-font-locking.el 0000664 0000000 0000000 00000027554 15015275167 0022631 0 ustar 00root root 0000000 0000000 ;;; clojure-mode-extra-font-locking.el --- Extra font-locking for Clojure mode -*- lexical-binding: t; -*-
;; Copyright © 2014-2021 Bozhidar Batsov
;;
;; Author: Bozhidar Batsov