I liked the original ideas and the discussions on this topic. Just a few
brief comments:

What you called ³eager² and ³lazy² macros seems to correspond pretty well to
³#define² macros in the C preprocessor and ordinary function definitions in
C. Am I right here? Clearly most languages could use a macro processor, and
in many it would be very useful. You might also call them ³compile-time² and
³run-time² operators (or something like that). I believe some languages even
have ³link-time² and ³load-time² macros, but these distinctions only make
sense in more complex systems. So, I would advise you to continue with the
two, but you do need some really convincingly useful examples of the eager
macros.

About the pattern matching operators, written in the ³before-and-after²
style, where (a b ‹ b a) implements swap, for example. I seem to remember a
few years back some discussion on how to extend this to handle list
manipulation. The pattern (a [b c D] -- b a [c a D] b [D]) would match a
stack whose top element is a list of at least two items, b and c, and which
also has a second element a. This operator would remove these two items from
the stack and then push the five items on the right of the ³--², which are:
b, the first element of the list, then a, the original second element,
then a list whose first two elements are c and a then the rest D of the
list, then b again, and finally, on top, the list which is just the rest D
of the list. Not a very useful example (contrary to my own advice), but
you get the idea. It would help if someone could remember when this
discussion occurred.


It looks a bit like Prolog, doesn¹t it? In fact all the stack-shufflers and
all list operators can be implemented in a Joy-in-Prolog using this style.
Sticking to the ³before/after² style, here are some familiar ones:

cons == (a [B] -- [a B])
uncons == ([a B] -- a [B])
first == ([a B] -- a)
rest == ([a B] -- [B])

Note that in the two examples all variables occurring to the right of
the ²--² were already bound on the left of the ³--². That need not be
so, but then we need some extra machinery. I will only give one
example. Suppose I have a list of at least 3 items on top of the stack,
and that third item is a number, and I wish to square it. In Joy I
would write

squarethird == uncons uncons unswons dup * swons cons cons

In a pattern matching Prolog-like Joy I would write

squarethird([x y z R] -- [x y w R])
w = z dup *

So the extra ³machinery² is precisely what in Prolog is the body of
a relation.

I cannot remember how far we went in our discussion some years back.
I have resisted the pattern matching mechanism for Joy mainly for
reasons of purity. But I am also aware how some of the pattern matching
languages allow very succinct code.

I hope what I wrote is of some use to the language smiths on this group.

- Manfred










[Non-text portions of this message have been removed]