🚀 go-pugleaf

Stephen E. Witham:
      > Lisp has two features: an internal form for programs, and a
      > (over:-) simple syntax.  I think with an "infix Scheme,"
      > having a well-defined internal form would give you most of the
      > power.  You'd need a "code-constant" or
      > "internal-form-of-this-quoted-code-fragment" construct, e.g.,
      > x = quote {
      >     function ( a, b ) {
      >         return a+b;
      >         }
      >     };
      > (That's not a lambda expression, it's a quoted lambda expression.)

Raul Rockwell (me):
      Requiring a lambda expression to express an anonymous function
      seems to me to be one of LISP's flaws, not one of its advantages.

Mark Friedman:
   What's your alternative? You need some syntax to say that you want
   a function that takes some number of arguments.

Well, you can say that an infix function takes one or two arguments.
Make one argument optional (with greedy binding) and ambiguity may be
resolved when the function is used.  e.g.  x-y  vs.  -y

A less elegant solution might be to always require two arguments and
use BOTTOM a lot.

Me:   Or, put another way, infix notation already has a clear scheme
      for representing arguments, why not take advantage of it?

Mark Friedman:
   I won't argue about the usefulness of infix notation, but what has
   that to do with anonymous functions?

You can define anonymous functions using infix notation by either (a)
explicitly declaring dummy variables (similar to (lambda (x y) ...))
(b) using a pair of "standard names" for dummy variables, or (c)
tacitly defining functions without the use of any dummy variables
(just say what functions preprocess the arguments/postprocess the
results).

I expect you'd want a good variety of data-structure building
functions for something like this (otherwise you could only work with
"toy" data).  [And a good variety of meta-functions for leverage.]

Or maybe I'm missing the point of the question??

-- 
Raul <rockwell@socrates.umd.edu>