Re: require does not define variables and constants

[Sam S. <sd...@gn...>]

> * In message <200...@cl...>
> * On the subject of "Re: require does not define variables and constants"
> * Sent on Tue, 12 Aug 2003 20:52:11 +0200
> * Honorable Bruno Haible <br...@cl...> writes:
>
> Sam wrote:
> > (require "foo") should init variables and constants defined in
> > foo.lisp,
> 
> Why should it?

because REQUIRE means "load unless already loaded", and LOAD will
define and init the variables and constants.

> > but it does not, because foo.lib only proclaims them special
> > but does not initialize them.
> 
> It doesn't need to. Read the CLHS section about DEFCONSTANT:
> 
>   "the compiler must recognize that name names a constant variable.
>    An implementation may choose to evaluate the value-form at compile
>    time, load time, or both."
> 
>   ==> In the compilation environment, the knowledge about the value
>   of a given constant is not required.
> 
> See also CLHS section 3.2.2.3 Semantic Constraints.

since foo & bar are separate compilation units, this, IMO, should not
be relevant.

> > === foo.lisp ===
> > (defconstant *x* 1)
> > === foo.lisp ===
> >
> > === bar.lisp ===
> > (require "foo")
> > (defun x (y)
> >   (case y
> >     (#.*x* 100)))
> > === bar.lisp ===
> >
> > clisp -c bar.lisp
> > *** - EVAL: variable *X* has no value
> 
> Since 'require' is a function (i.e. the compiler doesn't need to do
> any special processing when it sees the invocation), this is not CLHS
> compliant code. But anyway, let's assume clisp's interpretation:

indeed, let's replace (require "foo") with
(eval-when (compile load eval) (require "foo"))

> 'require' seen at compile time must "load" the "compilation
> environment" that is left after foo.lisp was compiled. Even then, the
> code above is invalid, because even in implementations that choose to
> evaluate the value form of *x* in the compilation environment, this
> value may be available only to the compiler and not to the
> general-purpose evaluator (which is used by #. ). So your program
> bar.lisp should better read
> 
> (eval-when (load compile eval) (load "foo"))
> (defun x (y)
>   (case y
>     (#.*x* 100)))

this would repeatedly load "foo".
I do not want it.


-- 
Sam Steingold (http://www.podval.org/~sds) running w2k
<http://www.camera.org> <http://www.iris.org.il> <http://www.memri.org/>
<http://www.mideasttruth.com/> <http://www.honestreporting.com>
Programming is like sex: one mistake and you have to support it for a lifetime.