What is the difference between an atom in Common Lisp and an atom in Clojure?

Question

The following page talks about how atoms work in Clojure. It doesn\'t say a whole lot about the differences between atoms in Clojure and other lisp dialects.

What is th

Answer 1

In all Lisps atoms are symbolic expressions that are not lists (except empty lists). They are also called atomic S-expressions. What's atomic (indivisible) in it? Historically the lists were something that could be divided into smaller parts where atoms (but not non-empty lists) contained within them couldn't.

In Clojure there are also atomic S-expressions but there is also a data structure called Atom which allows one to create mutable data objects that can be accessed by multiple threads. What's atomic in them? The operation.

If you modify an Atom its state will be successfuly changed or not. There won't be a situation that a half of it (e.g. some vector) will change and a half will not. If the operation is unsuccessful then it is retried and a current thread waits until it completes.

What is the difference between Lisp's atoms and Clojure's Atoms? The abstraction level. Lisp's atoms are a class of symbolic expressions, whereas Clojure's Atoms are a class of data structures used to handle shared data.

Answer 2

Atoms in Clojure and atoms in Common Lisp (and most other Lisps) are two completely unrelated concepts. They have nothing to do with each other, other than having the same name.

There is no 'difference'. It would be asking what is the difference between a window in a house and a window on your computer screen? It does not make sense to identify differences, since the two concepts are not related.

'Atoms' in Clojure manage state.

'Atoms' in Lisp is a word for all data types that are not cons cells (like numbers, characters, strings, symbols, ...).

In Lisp the function ATOM is simply defined as:

(defun atom (object)
   (not (consp object)))

Since Clojure does not have cons cells and no function consp, it is not possible to say (not (consp object)). Thus there does not exist a Lisp concept like 'atom' in Clojure. Note that Clojure has a function cons, but it does not create cons cells like in Lisp.

Answer 3

They are largely different and have a common conceptual basis for using the name 'Atom'

• Atom in Common lisp refers to the idea of an indivisable thing like the origional meaning of an atom of matter.

• Atom in clojure refers to a specific mutable data structure that changes 'atomically' that is a write to it either completes or it does not (and is subsequently retried)

the common idea is the indivisible concept. in CL its what the thing is and in Clojure its how the thing changes.

In Clojure Atoms are used when you need blocking mutable data that is not coordinated. for instance a single userId counter or something. Clojure also has coordinated mutable access in Refs (think bank account transfers) and atomic uncoordinated non-blocking mutable things in Agents (think log collectors for example).