Re: OT: What was the first programming language to use 'generics'?...

[David Trudgett <wpower@zeta.org.au.nospamplease>]

Robert A Duff <bobduff@shell01.TheWorld.com> writes:

> David Trudgett <wpower@zeta.org.au.nospamplease>  writes:
>
>> "Martin Dowie" <martin.dowie@baesystems.com> writes:
>> 
>> > ...and were they called 'generics'?
>> >
>> > Not Ada but I just know /someone/ here will know this! ;-)
>> >
>> >
>> 
>> Probably (given I'm not a language historian) Lisp code macros were
>> the first, except for a couple of provisos: (a) Lisp never had the
>> strong static typing that Ada has, so Lisp macros weren't invented to
>> solve the same problem as Ada generics; and (b) Lisp macros are more
>> general than Ada generics in the sense that they allow essentially
>> arbitrary code (not text) generation (every Ada programmer's
>> nightmare? ;-)).
>
> An important difference between Ada's generics and most macro systems

A small quibble, perhaps: I don't think one can use the phrase "most
macro systems" for the simple reason that (as far as I'm aware) no
language family besides the Lisp one has a macro system (in the sense
that Lisp has it -- they may well use the same word, but C language
"macros", for instance, are a completely different beast). Lisp's use
of "S-expressions" (for "symbolic expressions", but refers to the
parenthesis syntax: "(function-name argument argument argument...)" is
perhaps the major reason that Lisp macros can be as powerful as they
are (because it's easy for code to generate code in this format). No
language that I know of, besides the Lisp family (including Scheme),
uses this syntax.

Of course, there are many languages of which I have little or no
knowledge, such as Smalltalk, Haskell, Eiffel, ML. I wouldn't be (too)
surprised if one or more of these have some sort of "macro" facility;
but without the regularity of S-expressions, it's hard to see any
comparison to Lisp macros.

Anyway, I'm sure most of you have heard the Lisp macro spiel before.


> is: what should names in the template refer to.  If a name in the
> template refers to something local to the template, it refers to the
> copy of that thing in the instance.  If it refers to a formal parameter
> in the template, it refers to the actual parameter in the instance.  If
> it refers to neither, what should it refer to?  To something visible at
> the place of the template, or something visible at the place of the
> instance?  The Ada answer is: at the place of the template.  The usual
> macro answer is: at the place of the instance.

This all seems to be correct.


>
> Some Lisp dialects have "hygienic macros", which are a lot more like Ada
> generics in this regard.

You would be referring to Scheme dialects here. Interestingly,
Scheme's "hygienic macros" do not make Common Lisp's macros
"unhygienic"! They just add an extra restriction which stops the
programmer from doing certain things that can be done in Common Lisp
macros (from what I hear). The same level of "hygiene" can be had in
Common Lisp macros by the use of appropriate programming style,
including the use of GENSYM to avoid referring to extraneous "symbols"
(read "variable names", close enough).

Thanks for your comments, Bob.


David


-- 

David Trudgett
http://www.zeta.org.au/~wpower/

"... we think the price is worth it."

    -- US Ambassador Madeleine Albright, when asked if the deaths of
       half a million Iraqi children were a price worth paying for
       sanctions