[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: EQness of functions
> The case of
> (let ((f #'(lambda ...)))
> (eq f f))
> has no bearing on the issue of whether (eq f #'eq) is valid. #'eq means
> (function eq), which may or may not result in something being done at
> run time to evaluate it; f is a variable reference whose value has already
> "been evaluated" at some prior time. (eq f f) ought to always be true,
> modulo some kinds of number-optimization.
It is clear at least they we are not understanding each other.
I will try again nonetheless. The problem may be that I am
talking about what FUNCTION should be and you seem to be talking
about what it is.
I want #'F to be a reference in the function namespace just as
plain F is a reference in the value namespace.
Consider the following in Scheme:
(let ((f (lambda ...)))
(eq f f))
This will return true. In Common Lisp, I might write it as:
(let ((f #'(lambda ...)))
(eq f f))
but I might prefer:
(flet ((f ...)) (eq #'f #'f))
I do not think that this additional transformation (into FLET) should
introduce any new uncertainty w.r.t. EQ -- because #'F, like F, is
just a reference (whose value has already been evaluated). The
relevance of the LET example is that it and the FLET version should
(in my view) be equivalent.
Put another way, I suggest that FUNCTION should be interpeted as
more or less a syntactic marker as in
<form> ::= ... | (FUNCTION <function>) | ...
<function> ::= <identifier> | (LAMBDA <lambda list> <form>*)
That is, (LAMBDA ...) in, say, ((LAMBDA ...) ...) has as its value
a function; (LAMBDA ...) in (FUNCTION (LAMBDA ...)) is interpreted
in more or less the same way; but in (... (LAMBDA ...) ...) it is not
[it's interpreted as a call to the (non-)function LAMBDA]. So in
the <identifier> case, FUNCTION simply indicates that the identifier
is a function name, not a variable.
In other words, I do not think of FUNCTION as an operation that
constructs a value -- it's not like LIST or MAKE-SYMBOL. Furthermore,
I am not saying that Common Lisp currently treats FUNCTION in the way
I prefer -- I am saying that (in my opinion) it should.
Finally, recent messages have shown that the "may make a new object
each time" view of (FUNCTION <identifier>) provides some freedom that
can be exploited in various ways. Whether this freedom is important
enough to determine the semantics is less clear.
I hope everyone isn't *too* tired of this.