(DEFVAR B 1)
=> B
(DEFUN FOO (A) (CONS A B))
=> FOO
(DEFUN BAR (B) (FOO 'A))
=> BAR
(DEFUN BAZ (B) (DECLAIM (SPECIAL B)) (FOO 'A))
=> BAZ
(BAR 'B)
=> (A . B) ; shouldn't that be "(A . 1)"?
(BAZ 'B)
=> (A . B) ; as expected (?)

I thought that (DECLAIM (SPECIAL B)) extends the dynamic environment
with the value of B from the lexical environment, and that the free
variable B in FOO would have dynamic binding.  I'm trying to follow
Queinnec's descriptions of dynamic vs. lexical bindings in chapter 1
of _Lisp in Small Pieces_ (page 19 in my copy), along with the
HyperSpec's description of Lisp's evaluator in section 3.  Er, help?

AndrewI

    KMP> This declares B special in all subsequent uses, whether or
    KMP> not there is an accompanying declare.  It can't be retracted
    KMP> nor lexically shadowed. (It can be shadowed by making a new
    KMP> package, of course.)

Ah, I understand.  If I replace "(DEFVAR B 1)" with "(SETQ B 1)",
"(SPECIAL B)" works as expected.

    me> (DEFUN BAZ (B) (DECLAIM (SPECIAL B)) (FOO 'A)) => BAZ

    KMP> Use DECLAIM only at top-level.  Doing it in a program won't
    KMP> do what you expect.  Use only DECLARE in programs.  Use
    KMP> either DECLAIM or PROCLAIM at top-level.

Yeah, once I read a little further down in the definition of SPECIAL I
realized I'd made an error.

;; no DEFVAR of B

In the above example, B is not globally declared (proclaimed) special
(which it would have been with DEFVAR), but just in specific places.

Disclaimer: I have not actually run this example (sorry, too lazy),
please run it!

DECLAIM does something else, but I won't go into it as I think you
were thinking about DECLARE here.  (After you have things about
declarations clear, read the description of DECLAIM.)

Now (DECLARE (SPECIAL B)) means: within the scope of this declaration
treat all references to B as references to a dynamic variable, ignoring
any lexical bindings that might otherwise be in force.  `The scope of
this declaration' is the form in which this declaration appears including
any nested forms *but* excluding nested forms like LET and DO that bind
B.  (Well, this is just a rough description; consult the literature for
the Real Thing.)

If you want (I can't think of a reason) to `extend the dynamic
environment with the value of B from the lexical environment' you
can do e.g.

  (let ((x b))
    (declare (special x))
    ...)

or

  (defvar x 'init "my starless and bible black global variable")
  ...
  (let ((x b)) ...)

---assuming that B is a lexical variable in the scope that surrounds
this LET---and for the duration of the execution of the LET, anywhere
in the program text (i.e. not just in the textual body of the LET),
the binding for X in the dynamic environment (until changed) would
have B's value.  Now if you rename X as B in the above example, you
get a lexical B and a dynamic B.  I hope you are not too confused.

Good luck, and keep asking questions until you are sure you get it,
Vassil.

P.S.  Beware of analogies with other programming languages like C:
some things about variables are similar and some are very different.

Vassil Nikolov <vniko...@poboxes.com> www.poboxes.com/vnikolov
(You may want to cc your posting to me if I _have_ to see it.)
   LEGEMANVALEMFVTVTVM  (Ancient Roman programmers' adage.)