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

[jayessay <nospam@foo.com>]

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

> I was including Lisp macros and C macros and the macros of many other
> languages, including assembly languages in the term "macro systems".
> Larry Kilgallen mentioned Bliss, which has an extremely powerful macro
> system.  Most of them, I believe, share the same problem of accidentally
> referring to names visible at the place of the instantiation (macro
> call).

The other big one is unintended multiple evaluation of parameters.

In the case of Lisp (Common Lisp), these are not a problem as David
Trudgett pointed out, i.e., there are simple mechanisms available
which _guarantee_ this cannot happen.  OTOH, there are times when
variable capture is _exactly_ what you _want_.

Example (impossible unintended variable capture and no multiple evaluation):

(defmacro with-foo (id &body body)
  (with-unique-names (gid temp)
    `(let* ((,gid ,id)
	    (,temp (get-foo ,gid)))
       (unwind-protect
	   (progn ,@body)
	 (release-foo ,temp)))))

gid and temp here act very similarly to "temporary variables"
generated by a compiler to hold intermediate values in a generated
code sequence.  Both are generated at expansion time and both are
universally unique.  Also, a parameter passed to the formal ID will be
evaluated exactly once.


(defun flubber (xyz info)
  (let ((temp (some-computation xyz)))
    (with-foo (determine-foo info)
      (do-some-stuff temp)
      (setf temp (some-other-computation))
      (if (some-test temp)
	  :success
	:fail))))

Here's what the body of flubber expands to:

(let ((temp (some-computation xyz)))
  (let* ((#:gid81696 (determine-foo info))
         (#:temp81697 (get-foo #:gid81696)))
    (unwind-protect
        (progn
          (do-some-stuff temp)
          (setf temp (some-other-computation))
          (if (some-test temp) :success :fail))
      (release-foo #:temp81697))))

For this _specific_ expansion, gid and temp become "temporary
variables" #:gid81696 and #:temp81697.  Another expansion will
generate new versions.  Note that TEMP is not inadvertantly captured
and the TEMP in the users code correctly refers to the outermost TEMP.


> But I agree that most of them are inferior to the Lisp version
> in many other respects.

In this respect as well.



> >... 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).
> 
> This has been debated intensely in the Lisp community.  My opinion
> is that GENSYM doesn't make them hygienic, because GENSYM is
> something you have to remember to do by hand all over the place.

Not really - as you can see above.  But then "hygiene" is pretty
subjective.  As I said above, there are times when you absolutely
_want_ to have a particular variable captured.  It makes the
_semantics_ exactly right.  In something like syntax-case, you can't
do that.  Which is one reason (amoung many) why all Scheme
implementations actually end up providing defmacro anyway.


> In Scheme macros, and Ada generics, it happens automatically.
> Also, I don't see how this hygiene loses any power -- if you *want*
> to capture variable names visible at the call site, you can pass
> parameters to the macro/generic.

That does not capture lexical variables which is what you sometimes
want.


/Jon

-- 
'j' - a n t h o n y at romeo/charley/november com