In article <··············@localhost.localdomain>,
Vassil Nikolov <···············@pobox.com> wrote:
> Is there any terminology to distinguish different kinds of ATOMs in
> lisp, e.g. characters, numbers and symbols, etc. vs. arrays and
> structures, etc.? Or a term that would group arrays, conses,
> structures, etc. into one category?
>
> (There are some terms I can think of, but I am not sure about actual
> usage, and then I don't want to bias any answers.)
It sounds like you want to distinguish aggregates from singletons. CL
doesn't have any built-in functions or type specifiers that do this.
The term "atom" dates back to the early versions of Lisp, where conses
were the only aggregate objects (there were no arrays, structures, hash
tables, etc.). So everything that wasn't a cons was truly atomic. As
new data types were added, they were lumped in as atoms because many
programs used (atom x) to detect all non-conses, and they would have
broken if the new types weren't atoms. For instance, if you had a tree
whose leaves were arrays, tree-search functions would try to dive into
the arrays rather than recognize them as leaves, and CAR/CDR would get
errors.
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***
On Sat, 09 Jun 2007 00:31:52 -0400, Barry Margolin <······@alum.mit.edu> said:
| It sounds like you want to distinguish aggregates from singletons.
Yes, thanks for these two terms.
| CL doesn't have any built-in functions or type specifiers that do
| this.
I can define ones in programs if I need them; it is in
natural-language texts that I'd like to avoid defining new terms.
---Vassil.
--
The truly good code is the obviously correct code.
Barry Margolin wrote:
> In article <··············@localhost.localdomain>,
> Vassil Nikolov <···············@pobox.com> wrote:
>
>> Is there any terminology to distinguish different kinds of ATOMs in
>> lisp, e.g. characters, numbers and symbols, etc. vs. arrays and
>> structures, etc.? Or a term that would group arrays, conses,
>> structures, etc. into one category?
>>
>> (There are some terms I can think of, but I am not sure about actual
>> usage, and then I don't want to bias any answers.)
>
> It sounds like you want to distinguish aggregates from singletons. CL
Around the corner, in the C++ world, singleton has a very different
meaning. There, it refers to a class which is instantiated once and
globally shared. This is often used to wrap global things like event
loops, memory heaps, etc.
Maybe "primitive type"/"compound type" works?
- Daniel
On Sat, 09 Jun 2007 20:25:26 -0400, D Herring <········@at.tentpost.dot.com> said:
| Barry Margolin wrote:
|| It sounds like you want to distinguish aggregates from singletons.
| Around the corner, in the C++ world, singleton has a very different
| meaning.
That's the (so-called) "gang of four" world, in fact, which spreads
over more than C++ territory. But I hope that this won't turn into
a thread on patterns (in the sense of this context).
| There, it refers to a class which is instantiated once and
| globally shared. This is often used to wrap global things like event
| loops, memory heaps, etc.
| Maybe "primitive type"/"compound type" works?
I don't think so about "primitive type", since e.g. SYMBOL and CONS
are equally primitive; "compound" might have worked, even though I'm
not sure, except that it already has a(nother) meaning in Common
Lisp [1], which I don't think we should be overloading.
[1] http://www.lisp.org/HyperSpec/Body/glo_c.html#compound_type_specifier
---Vassil.
--
The truly good code is the obviously correct code.