Emacs: Evaluating S-expressions

1. Your Interactive Playground: The *scratch* Buffer

Emacs provides a special buffer called *scratch* that is created automatically every time you start it. This buffer is an ideal place to experiment with Elisp because it's temporary and set up for interactive evaluation.

The primary command you'll use to evaluate Elisp code is eval-last-sexp, which is bound to the key combination C-x C-e. When you invoke it, Emacs looks backward from your cursor (what Emacs calls the "point"), finds the first complete S-expression it can, evaluates it, and prints the result in the minibuffer (the small area at the bottom of your Emacs window).

Let's see this in action.

The key points to remember are:

• The *scratch* buffer is your sandbox.
• The command is C-x C-e (eval-last-sexp).
• Your cursor must be positioned after the S-expression you want to evaluate.
• The output appears in the minibuffer.

Here is a static image that reinforces this workflow.

For a detailed textual explanation of this process, you can refer to the following article. It's a great resource to bookmark for future reference.

2. Evaluating Your First S-Expressions: Atoms

Let's start with the simplest form of S-expression: the atom. As you learned in the last lesson, atoms are indivisible values like numbers and strings.

In Elisp, many atoms are self-evaluating. This means that when you evaluate them, the result is the atom itself.

Let's Try It:

1. Open your *scratch* buffer in Emacs. If you've closed it, you can get it back with C-x b *scratch* RET.
2. Type a number, for example: 42.
3. Position your cursor immediately after the 2.
4. Press C-x C-e.

You should see 42 appear in your minibuffer. The number evaluates to itself.

Now, let's try a string:

1. On a new line in your *scratch* buffer, type a string: "Speculative fiction".
2. Position your cursor immediately after the closing double-quote.
3. Press C-x C-e.

The minibuffer will display "Speculative fiction". The string also evaluates to itself. This simple behavior is the foundation upon which more complex evaluations are built.

This short video clip demonstrates exactly this process.

3. Function Calls: Arithmetic and Strings

Things get more interesting when we evaluate lists. As you know, a list like (+ 2 3) is interpreted as a function call using prefix notation.

Let's use the *scratch* buffer to perform some basic arithmetic. The functions are the symbols you'd expect: +, -, *, and / for division.

Let's Try It:

Evaluate each of the following expressions in your *scratch* buffer using C-x C-e. Remember to place your cursor after the final parenthesis for each one.

(+ 100 50)

(- 100 50)

(* 10 5)

(/ 100 5)

The video you've been watching has a great segment covering these arithmetic functions. It also shows the common error of trying to use infix notation, which will help solidify your understanding of the Lisp way.

The same function call syntax applies to all operations, not just math. Let's use the message function, which takes a string as an argument and displays it in the minibuffer. This is incredibly useful for debugging and providing feedback in your own functions later.

Let's Try It:

Evaluate the following in your *scratch* buffer:

(message "Hello from Elisp!")

After you press C-x C-e, you'll see "Hello from Elisp!" appear in the minibuffer. You'll also see the return value of the message function, which is the string itself: "Hello from Elisp!". This distinction between a function's action (a "side effect") and its return value is a key programming concept we will revisit.

4. Practice and Exploration

You now have the fundamental skill for interacting with Elisp. The best way to internalize it is through practice.

Exercise:

In your *scratch* buffer, write and evaluate Elisp S-expressions to answer the following questions:

1. What is the result of 2017 - 1982?
2. If a book has 42 chapters and each chapter has approximately 12 pages, how many pages are in the book?
3. Display the message "Code is data." in the minibuffer.

This simple cycle—write code, evaluate, see result—is the core feedback loop you'll use constantly as you learn Elisp and build your own customizations.

For a final review of the different ways to evaluate Elisp, the following guide is an excellent summary.

Conclusion

In this lesson, you made the crucial leap from knowing what an S-expression is to actually executing one. You have configured nothing, installed nothing, and yet you've turned your text editor into a live programming environment. This interactive nature is a hallmark of Lisp and a cornerstone of what makes extending Emacs so powerful.

Key Takeaways:

• The *scratch* buffer is your primary environment for quick Elisp experiments.
• C-x C-e (eval-last-sexp) is the fundamental command for evaluating the S-expression before your cursor.
• The result of an evaluation is displayed in the minibuffer.
• Simple atoms like numbers and strings are self-evaluating.
• Lists are evaluated as function calls using prefix notation, whether for arithmetic (+, *) or other tasks (message).

Preview of the Next Lesson:
You've evaluated single, self-contained expressions. But the real power of Lisp comes from composition. In the next lesson, we will learn how to nest S-expressions, building complex operations by using the result of one function call as an argument to another. This will unlock a new level of expressiveness and allow you to start writing more sophisticated code.