anchor.diff:  
   === What to expect from an in-editor REPL integration?
   
  -Here are some common editor commands provided by REPL integrations. All major Clojure 
  +Here are some common editor commands provided by REPL integrations. All major Clojure
   editors support a majority of them:
   
  -* **Send form before caret to REPL:** evaluate the expression before the cursor in the REPL, 
  +* **Send form before caret to REPL:** evaluate the expression before the cursor in the REPL,
   in the namespace of the current file. Useful for experimenting in the context of the current namespace.
   * **Send top-level form to REPL:** evaluate the biggest expression in which the cursor is currently contained
  --typically a `(defn ...)` or `(def ...)` expression-in the namespace of the current file. 
  +-typically a `(defn ...)` or `(def ...)` expression-in the namespace of the current file.
   Useful for defining or re-defining Vars in a namespace.
   * **Load the current file in the REPL.** Useful to avoid <<_working_with_libs,loading libs manually>>.
   * **Switch the REPL's namespace to current file:** useful to avoid typing `(in-ns '...)`.
  
positive.code: [#editor-integrations]
  == Editor integrations
  
  All <<xref/../../../community/resources#_clojure_tools,major Clojure editors>> support a way of evaluating code in the REPL without leaving 
  the current code buffer, which reduces the amount of context switching a programmer has to do.
  Here's what it looks like (the editor used in this example is https://cursive-ide.com/userguide/repl.html[Cursive]):
  
  
negative.code: 
  ==== Going further: 'spying' macros
  
  Some Clojure libraries provide 'enhanced' versions of `prn` that are more informative, by also printing information
  about the wrapped expression. For example:
  
  * the **https://github.com/clojure/tools.logging[tools.logging]** logging library
  provides a http://clojure.github.io/tools.logging/#clojure.tools.logging/spy[spy] macro to log an expression's code along
  with its value
  * the **https://github.com/dgrnbrg/spyscope[spyscope]** library lets you to insert these printing calls with very
  lightweight syntax.
  
  ==== Going further: tracing libraries
  
  _Tracing_ libraries such as **https://github.com/clojure/tools.trace[tools.trace]** and **http://clojure-emacs.github.io/sayid/[Sayid]**
  can help you instrument larger portions of your code, for example by automatically printing all the function calls in a
  given namespace, or all intermediary values in a given expression.
  
  === Intercepting and saving values on-the-fly
  
  Sometimes you want to do more with intermediary values than just print them:
  you want to save them to conduct further experiments on them at the REPL.
  This can be done by inserting a `(def ...)` call inside the expression where the value appears:
  
  [source,clojure]
  ----
  