Features of a Clojure aware editor

The features I would expect to find in my Clojure development environment, with a bias towards highly effective interaction via the keyboard and an uncluttered user interface.

Typically assembled with an editor orchestrating a range of Clojure tooling.

REPL features

connect to an existing REPL process (nREPL or socket repl - maybe prepl)
start a new REPL process (using Leiningen, Clojure CLI)
- Clojure CLI REPL process allows inclusion of aliases from project deps.edn and user level deps.edn
restart / refresh a REPL process

Project management

Create a clojure project, with options on templates
- a shell is good, a specific feature could be nicer
Git client (ideally as rich as Emacs Magit or VS Code edamagit)

Clojure code evaluation in the REPL process

Evaluate in Source code window & terminal REPL UI (longer running processes, logging, etc)
eval namespace (evaluates all expressions in namespace - except those in comment, #_)
eval top-level expression
eval a nested expression (e.g. eval last s-expression)
Un-evaluate a var (e.g. remove def, defn, deftest names from the REPL process)
eval expression within (comment ...) and after #_
eval expression and display result pretty printed
eval expression and write result as comment (with pretty print option)
replace expression with result of evaluation
macro-expand expression

Inspecting / Navigating Data

navigate data, especially nested data
paginate through large data sets (without slowing down the environment)
Inspect results of an evaluation
Data browser updates after each evaluation

Debugging tools

instrument function(s) with break points
step through functions
display / inspect local values
step over calls

Code manipulation features

Vim style editing (a bias of mine, but definitely worth having)
Structural Editing (smartparents, paredit - manually driven approach)
Refactor code (rename, add requires, extract to function / let,
Multi-replacement (e.g. Emacs iedit)
- select all matches in scope, jump between matches, toggle matches and simultaneously edit them
Narrowing (e.g Emacs narrowing) - view over part of a file, limiting scope of changes
Multiple cursors

Unit Testing

Support REPL based test runner (e.g. cider-test)
Support externally running test runner (e.g. kaocha)
Enable watch for changes to trigger re-run of tests
Run all tests / namespace tests / single test / only failing test
support test selectors to run group of tests
easy to understand test reports

Code archaeology features

Incoming / outgoing call stack
Navigate to definition (project, dependency and Java sources where relevant)
Indicate uses (e.g. number of functions calling a function)
Indicate unit tests (optional)
Navigate to errors

Live collaboration

sharing live code view (Vs code live, floor it's, etc.)
- VS Code Live is excellent and significant code changes could be done in a separate editor if vscode/calva unfamiliar

General features

Option to use 100% Keyboard driven interaction (mouse-less operation of tooling)
vim-style multi-modal editing
Clojure LSP support (ideally with easily customisable client lsp UI elements)

practicalli / blog-cryogen

Features of a Clojure aware editor #128