Elisp Core Data Types

1. What is a Data Type?

Since you've requested we cover foundational concepts, let's start with a definition. A data type is a classification that tells the computer how to interpret a value. It specifies what kind of data an object can hold (e.g., a whole number, a piece of text) and what operations can be performed on it (e.g., you can do arithmetic on numbers, but not on text).

Elisp, like any programming language, has a set of built-in data types. We'll start with the most familiar ones.

2. Numbers: Integers and Floats

Numbers in Elisp are straightforward. They come in two primary forms:

• Integers: Whole numbers, like 1, 42, -100.
• Floating-point numbers (Floats): Numbers with a decimal part, like 3.14, -0.5, 2.0.

When you evaluate a number in Elisp, it simply returns itself. This makes them "self-evaluating" types.

Checking the Type: Predicates

A common task in programming is to check if a value is of a certain type. In Elisp, this is done with functions called predicates. A predicate is a function that answers a yes/no question, returning t (true) or nil (false). By convention, predicate functions in Elisp often end with the letter p.

• integerp checks if a value is an integer.
• floatp checks if a value is a float.
• numberp checks if a value is any kind of number.

Hands-on Practice

Open your *scratch* buffer and try evaluating these expressions yourself by placing your cursor after each one and pressing C-x C-e. Observe the result in the minibuffer.

42          ; An integer
-3.14       ; A float

(integerp 42)    ; Returns t
(integerp 42.0)  ; Returns nil, because it's a float
(floatp 42.0)    ; Returns t
(numberp 42)     ; Returns t
(numberp 42.0)   ; Returns t

3. Strings

A string is a sequence of characters, like a word, a sentence, or a paragraph. In Elisp, strings are enclosed in double quotes ("). Like numbers, strings are self-evaluating.

"Hello, world!"
"This is a string."
"" ; An empty string

The predicate for checking if a value is a string is stringp.

As a writer, you can imagine how central strings are. Any function you write to automate tasks related to your creative writing—manipulating sentences, searching for patterns, inserting boilerplate text—will rely heavily on string manipulation.

Hands-on Practice

Try these in your *scratch* buffer:

"speculative fiction"   ; A string

(stringp "Elisp")       ; Returns t
(stringp 42)            ; Returns nil

4. Booleans: The Nature of Truth in Lisp

In most programming languages, you have specific "boolean" values for true and false. Elisp is a bit different, and this is a key aspect of the Lisp philosophy.

• False is represented by the special symbol nil.
• True is represented by the special symbol t. More broadly, in a logical context, any value other than nil is considered true.

This means 0, the empty string "", and any other value will be treated as true in a conditional check. Only nil is false.

Crucially, t and nil are not a special "boolean" type. They are just symbols. The symbol nil has a unique triple role: it means "false," it is a symbol named "nil," and it also represents the empty list '(). This is a powerful and elegant design choice you'll come to appreciate.

The primary predicate related to nil is null, which returns t if its argument is nil, and nil otherwise.

(null nil)      ; Returns t
(null '())     ; Also returns t, because nil is the empty list
(null 0)        ; Returns nil
(null "hello")  ; Returns nil

5. Symbols: The Heart of Lisp's Variables and Functions

We've arrived at the most distinctively Lisp-like data type: the symbol. You've already seen symbols everywhere: +, message, integerp, t, and nil are all symbols.

As the article explains, the key difference is:

• A string is just a piece of text. The string "message" is its own value.
• A symbol is a name that refers to a value. The symbol message refers to the built-in function that prints messages.

Except for the special cases of t and nil, symbols are not self-evaluating. When Elisp evaluates a symbol, it looks up the value associated with it. This is how variables work.

If you try to evaluate a symbol that has no value, you'll get an error:

my-undefined-symbol   ; C-x C-e here will produce a "void variable" error

To refer to the symbol itself rather than its value, you must quote it with a single quote (').

'my-undefined-symbol  ; This evaluates to the symbol my-undefined-symbol itself

The predicate for this type is symbolp.

Hands-on Practice

This is a critical distinction to grasp. Evaluate the following in your *scratch* buffer.

(stringp "message")   ; t, because "message" is a string
(symbolp "message")   ; nil

(symbolp 'message)    ; t, because 'message is a symbol
(stringp 'message)    ; nil

This shows that even though they look similar, a string and a symbol are fundamentally different types of data.

Conclusion

In this lesson, we've surveyed the five most fundamental data types in Emacs Lisp. Understanding these is essential for writing any Elisp code.

Key Takeaways:

• Integers and Floats are self-evaluating number types. Use integerp, floatp, and numberp to check them.
• Strings are self-evaluating sequences of characters in double quotes. Use stringp to check for them.
• Booleans in Elisp are not a distinct type. The symbol nil represents false, and any other value (including the symbol t) represents true.
• Symbols are names that refer to other values (like variables or functions). They are not self-evaluating and must be quoted (') to refer to the symbol itself. Use symbolp to check for them.

Preview of the Next Lesson:

You now know what a symbol is and that it acts as a name referring to a value. But how do you create that association? In our next lesson, we will learn how to assign values to global variables using setq, officially starting our journey into creating and managing state in our programs.