lambda(-macro) ideas

[jsmall]

Suppose that lambda and lambda-macro were identical

except that the former had strict evaluation of actual

arguments and the latter lazy evaluation of actual

arguments.  Make this the default behavior (which it is

now).  But suppose newlisp had atomatized behavior like

this:

     (lambda (x ~y)  ....)    ;; y is lazy



     (lambda-macro (!x y) ...)   ;;  x is strict

Also if newlisp allowed something like the following

    (define (foo x y) ...)



    (~foo 1)

which had the effect of cloning foo on the fly

returning

    (lambda (y , x) (set 'x 1)  ... ;; old foo)

then this would allow transparent currying.  It seems

with the lambda lists that doing this sort of thing

of rotating argument would not be that difficult to

add to newlisp.



The default behavior of



    (define (bar) ...)



    (~bar)



would simply return bar.





A different approach to:



     (lambda (x ~y)  .... (eval y) ...)    ;; y is lazy



could be



     (lambda (x (f y))  .... (f x) ...)    ;; y is lambda argument



This would be interpreted as



     (lambda-macro (!x f-body)

        (set 'f (expand (lambda (y) f-body) 'f-body))

         ...)



We could then call it like this



     ((lambda (x (f y)) ... (f y) ...) 1 (println y))



In other words the actual argument passed would be

wrapped in a lambda expression having a y argument.

Instead of our expression being lazily evaluated it would

be delay evaluated, i.e. call by function instead of call by

name.