Evaluating Clojure with CIDER

1. Launching the CIDER REPL

So far, you have Emacs configured for Clojure and a project ready to go. The next step is to start a Clojure process and connect Emacs to it. CIDER makes this seamless with a process called "jacking in."

When you "jack in," CIDER does a few things automatically:

1. It reads your project's deps.edn file.
2. It calculates the classpath (the set of source directories and dependencies).
3. It starts a new Clojure process running an nREPL server.
4. It connects your Emacs session to that server, giving you a REPL buffer.

The following video demonstrates this process.

Exercise: Jack-in to Your Project

Now, it's your turn.

1. Open your fx-calculator project in Emacs. If you use a project manager like projectile, open the project. Otherwise, just open the src/fx_calculator/core.clj file.
2. With the core.clj file open, press C-c M-j (or M-x cider-jack-in-clj).
3. You will see some output in the minibuffer and then a new window will appear with the CIDER REPL. It will show a prompt like fx-calculator.core=>.

The prompt is important. It tells you that the REPL's current namespace is fx-calculator.core, which matches the namespace of the file you jacked-in from. This means any functions you define in this file will be available in the REPL once evaluated.

2. Evaluating Code from the Source File

While you can type code directly into the REPL, the most effective workflow is to write your code in your .clj source files and send it to the REPL for evaluation. This keeps your source files as the single source of truth. Your familiarity with Lisp will make the concept of evaluating "symbolic expressions" (S-expressions) feel natural.

CIDER provides several commands to evaluate code directly from a source buffer. The video below introduces the most common ones.

As the video explains, these commands let you send code to the REPL without ever leaving your source file.

• C-x C-e (cider-eval-last-sexp) is useful for evaluating small, inner expressions. You place your cursor after the closing parenthesis.
• C-M-x (cider-eval-defun-at-point) is for evaluating the entire top-level expression (like a function definition) that your cursor is inside. This is one of the most frequently used commands.

3. The Interactive Development Loop

Now let's put this together into a complete workflow: write, evaluate, test.

Your core.clj file should contain the -main function from the previous lesson:

(ns fx-calculator.core)

(defn -main []
  (println "Hello, FX Calculator!"))

Let's evaluate this function and run it.

1. Evaluate: Place your cursor anywhere inside the (defn -main ...) form in core.clj and press C-M-x. You should see a confirmation in the minibuffer that the #'fx-calculator.core/-main var has been defined.

2. Switch to REPL: Press C-c C-z (cider-switch-to-repl-buffer) to jump to the REPL buffer.

3. Test: At the REPL prompt, type the following and press Enter:

   (-main)
   

   You should see Hello, FX Calculator! printed to the REPL, followed by nil (the return value of println).

This cycle is the essence of REPL-driven development. You write code in your editor, send it to the live process to update its state, and then interact with it in the REPL to verify its behavior.

Exercise: Define and Test a New Function

Let's reinforce this loop by adding a new function.

1. In core.clj, add the following function definition below your -main function:

   (defn square
     "Computes the square of a number."
     [x]
     (* x x))
   

2. With your cursor inside the (defn square ...) form, evaluate it using C-M-x.

3. Switch to the REPL with C-c C-z.

4. Test your new function with a few different inputs:

   (square 5)
   ;;=> 25
   
   (square 1.5)
   ;;=> 2.25
   

You've just experienced the core feedback loop of Clojure development. Notice how you didn't have to recompile your entire project or restart the application. You simply updated the running system with your new definition.

The following video segment provides a longer demonstration of this iterative process of defining functions, evaluating them, and testing them in the REPL.

4. Essential Commands Summary

Here is a summary of the key commands you've learned in this lesson. These will become muscle memory very quickly.

Conclusion

In this lesson, you connected your development environment to your project and experienced the interactive, REPL-driven workflow that is a hallmark of Clojure. You learned how to start a CIDER session and, most importantly, how to evaluate code from your source files directly into the running application.

Key Takeaways:

• Jacking-in (C-c M-j) is the standard way to start a CIDER REPL session for a project.
• The primary workflow is to write code in .clj files and send it to the REPL for evaluation.
• C-M-x is your go-to command for evaluating function definitions and other top-level forms.
• The write-evaluate-test loop provides an immediate feedback cycle, allowing for rapid and incremental development.

You now have the fundamental skills for writing and running Clojure code. In our next lesson, we will deepen your REPL skills by exploring how to utilize the REPL for common development tasks like loading and reloading namespaces, inspecting data, and looking up documentation, all without leaving Emacs.