🚀 go-pugleaf

In article ... hrubin@pop.stat.purdue.edu (Herman Rubin) writes:

[Remarking on my Pop example with ``define 5 ++ (x, y) ...''

   If you could write 

   define	(x ++ y) x+y+1

   I would accept that as the insertion of the ++ operator.  

Well, it seems that this is just a quibble over an (admittedly unpleasant)
definition syntax; I've just checked and conformed that

    define 5 x ++ y; lvars x, y; x + y + 1 enddefine;

is an acceptable form (the ``lvars'' are required for historical reasons; the
Pop9X standard may well make them the default for formal parameters). There are
good Popish reasons for needing the precedence annotation.

   I would definitely
   allow far more complicated versions, as defining the power operator 
   differently depending on the types of the arguments.  

Steve Kinght's ``objectclass'' will allow this, although I don't recall whether
it allows operator definitions too. [Discussion on Pop can now take place on
comp.lang.pop, yipee!]

   But I would object to any language
   which insists that we use a strictly stack machine.  Pushing, popping, and
   calling are to be avoided unless necessary.  Otherwise things just run too
   slowly to be of more than theoretical use.

Pop doesn't insist on a stack *machine*, but it's *model* is stack-based. A Pop
compiler is entitled to elide pushes, pops, and calls where the difference
cannot be seen. But Pop the language is, ineluctably, stack-based, and I wasn't
suggesting that Herman code in Pop; I was pointing out that what the rest of
the programming community see as ``user-defined operators'', and what Herman
means by ``u. d. o's'', are *different things*, and suggesting we agree on some
language. 


--

Regards,    | "Layered protocols give the software implementor a chance to
Kers.       | ruin his performance in each layer." - Don Gillies