Whoops (SETF and LAMBDAs)

[William Galway <Galway@UTAH-20.ARPA>]

I guess I didn't make myself very clear in my previous message,
so I'll try again.  First, I'm talking about two related but
distinct things, namely
 1.) the lambda calculus
 2.) Lisp.

I picked a rather miserable example to illustrate what I want to
do in the lambda calculus, so here's another try.  The way I'd
assign a value to an expression like

    ((lambda (x)
       (plus x 1))
      2)

is to "evaluate (plus x 1) in an environment where `x' has the
value 2".  What I want to do is to extend this to the case where
x isn't an atom.  So to evaluate

    ((lambda ((sin x))
       (cos x))
      1)

I'd "evaluate (cos x) in an environment where the non-atomic
expression `(sin x)' has the value 1".  (I'm not necessarily
claiming that "plus", "sin", "cos", "2", "1", have their typical
meanings--I suppose it depends on what they're bound to.)  With
the usual meanings, I'd expect the value of the expression to be
zero, and if we plugged 0 instead of 1 into the lambda, the
result would be ambiguous, but either +1 or -1 should be valid
"interpretations".


In the case of Lisp, I was just thinking of LET as being a
convenient shorthand for LAMBDA.  So

    (let (
          ((elt v 0) (length v)))
      v)

is equivalent to

    ((lambda ((elt v 0))
       v)
      (length v))

(or should that be a "(function (lambda ...))"?  Anyway...)
So, is that roughly what MacLisp's "destructuring LET" did?
Something like SETF for lambdas, only without the idea that the
LET actually expanded to a lambda?

Let me also repeat that I'm not seriously suggesting
implementation of this stuff (or non-implementation for that
matter).  I'm just interested in toying with the ideas (for now).

Hope that clarifies what I was trying to get across.

-- Will
-------