In the original LISP, the originator of the Lisp programming language family, there were two fundamental data types, atoms and lists. A list was a finite ordered sequence of elements, where each element is in itself either an atom or a list, and an atom was a number or a symbol. A symbol was essentially a unique named item, written as an alphanumeric string in source code, and used either as a variable name or as a data item in symbolic processing. For example, the list (FOO (BAR 1) 2) contains three elements: the symbol FOO, the list (BAR 1), and the number 2.
The essential difference between atoms and lists was that atoms were immutable and unique. Two atoms that appeared in different places in source code but were written in the exact same way represented the same object, whereas each list was a separate object that could be altered independently of other lists and could be distinguished from other lists by comparison operators.
As more data types were introduced in later Lisp dialects, and programming styles evolved, the concept of an atom lost importance. Many dialects still retained the predicate atom for legacy compatibility, defining it as true for anything that is not a cons cell (ie. a list or a partial list).
In Lisp, all of the quoted text including the punctuation mark and the blank spaces is a single atom.
You can also evaluate an atom that is not part of a list--one that is not surrounded by parentheses; again, the Lisp interpreter translates from the humanly readable expression to the language of the computer.
Since Emacs Lisp is large, it is customary to name symbols in a way that identifies the part of Emacs to which the function belongs.
Note that Common Lisp, particularly in its simpler features, has much in common with other Lisps (to a certain extent, that's what the word "Common" in its name means).
Lisp iimplementations are usually interactive interpreters, i.e., programs to which you can type expressions and have them evaluated immediately.
Much of the input and output that you would need to write in other languages are unnecessary in Lisp's interpreted environment, because inputs to a computation can often be entered simply as part of an expression typed interactively to the interpreter, and the interpreter automatically prints the result of every expression you give it.
Feeds |
Contact