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 the primary difference between an atom in Common Lisp and an atom in Clojure? (What is missing from the definition of atom in Clojure that exists in CL?)

Answer 1

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 2

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).