[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
bug#18059: 24.3.92; defvar and special variables
From: |
Noam Postavsky |
Subject: |
bug#18059: 24.3.92; defvar and special variables |
Date: |
Sun, 04 Mar 2018 18:27:54 -0500 |
User-agent: |
Gnus/5.13 (Gnus v5.13) Emacs/26.0.90 (gnu/linux) |
Michael Heerdegen <michael_heerdegen@web.de> writes:
> Stefan Monnier <monnier@IRO.UMontreal.CA> writes:
>
>> This `defvar` case was devised specifically as a way to make it
>> possible to provide something like fluid-let without having to
>> introduce a new special form.
>
> Then we should document that use case.
Yes, you're right. Since this case really relates more to the lexical
vs dynamic binding, I think it would make more sense to add the example
in a later section (with a link, of course). I still don't think I can
claim with a straight face that (let (_) (defvar foo) ...) being
different than (let () (defvar foo) ...) is not a bug though.
>From 3e62f1d6d892b26993ad5553ee17a2aaeae67d8b Mon Sep 17 00:00:00 2001
From: Noam Postavsky <npostavs@gmail.com>
Date: Sat, 10 Feb 2018 14:06:05 -0500
Subject: [PATCH v3] Explain more about (defvar foo) form (Bug#18059)
* doc/lispref/variables.texi (Defining Variables)
(Using Lexical Binding):
* doc/lispref/compile.texi (Compiler Errors): Emphasize that omitting
VALUE for `defvar' marks the variable special only locally.
---
doc/lispref/compile.texi | 5 +++--
doc/lispref/variables.texi | 38 ++++++++++++++++++++++++++++++++++++--
2 files changed, 39 insertions(+), 4 deletions(-)
diff --git a/doc/lispref/compile.texi b/doc/lispref/compile.texi
index 0e39866d34..70da9727ee 100644
--- a/doc/lispref/compile.texi
+++ b/doc/lispref/compile.texi
@@ -500,8 +500,9 @@ Compiler Errors
@item
Likewise, you can tell the compiler that a variable is defined using
@code{defvar} with no initial value. (Note that this marks the
-variable as special, i.e.@: dynamically bound.) @xref{Defining
-Variables}.
+variable as special, i.e.@: dynamically bound, but only for the rest
+of the current binding form, or file if at top-level.)
+@xref{Defining Variables}.
@end itemize
You can also suppress any and all compiler warnings within a certain
diff --git a/doc/lispref/variables.texi b/doc/lispref/variables.texi
index e025d3fd10..9acdb210e1 100644
--- a/doc/lispref/variables.texi
+++ b/doc/lispref/variables.texi
@@ -442,8 +442,13 @@ Defining Variables
evaluated and @var{symbol} is set to the result. But if @var{symbol}
is not void, @var{value} is not evaluated, and @var{symbol}'s value is
left unchanged. If @var{value} is omitted, the value of @var{symbol}
-is not changed in any case. Using @code{defvar} with no value is one
-method of suppressing byte compilation warnings, see @ref{Compiler
+is not changed in any case.
+
+Note that specifying a value, even @code{nil}, marks the variable as
+special permanently. Whereas if @var{value} is omitted then the
+variable is only marked special locally (i.e.@: for the rest of the
+current binding form, or file if at the top-level). This can be
+useful for suppressing byte compilation warnings, see @ref{Compiler
Errors}.
If @var{symbol} has a buffer-local binding in the current buffer,
@@ -488,6 +493,9 @@ Defining Variables
The @code{defvar} form returns @var{symbol}, but it is normally used
at top level in a file where its value does not matter.
+
+For a more elaborate example of using @code{defvar} without a value,
+@xref{Local defvar example}.
@end defspec
@cindex constant variables
@@ -1164,6 +1172,32 @@ Using Lexical Binding
(@pxref{Defining Variables}). All other variables are subject to
lexical binding.
+@anchor{Local defvar example}
+Using @code{defvar} without a value, it is possible to bind a variable
+dynamically just in one file, or in just one part of a file while
+still binding it lexically elsewhere. For example:
+
+@example
+@group
+(let (_)
+ (defvar x) ; @r{Let-bindings of @code{x} will be dynamic within this
let.}
+ (let ((x -99)) ; @r{This is a dynamic binding of @code{x}.}
+ (defun get-dynamic-x ()
+ x)))
+
+(let ((x 'lexical)) ; @r{This is a lexical binding of @code{x}.}
+ (defun get-lexical-x ()
+ x))
+
+(let (_)
+ (defvar x)
+ (let ((x 'dynamic))
+ (list (get-lexical-x)
+ (get-dynamic-x))))
+ @result{} (lexical dynamic)
+@end group
+@end example
+
@defun special-variable-p symbol
This function returns non-@code{nil} if @var{symbol} is a special
variable (i.e., it has a @code{defvar}, @code{defcustom}, or
--
2.11.0
- bug#18059: 24.3.92; defvar and special variables,
Noam Postavsky <=
- bug#18059: 24.3.92; defvar and special variables, Michael Heerdegen, 2018/03/05
- bug#18059: 24.3.92; defvar and special variables, Noam Postavsky, 2018/03/07
- bug#18059: 24.3.92; defvar and special variables, Michael Heerdegen, 2018/03/09
- bug#18059: 24.3.92; defvar and special variables, Stefan Monnier, 2018/03/09
- bug#18059: 24.3.92; defvar and special variables, Noam Postavsky, 2018/03/11
- bug#18059: 24.3.92; defvar and special variables, Drew Adams, 2018/03/11
- bug#18059: 24.3.92; defvar and special variables, Noam Postavsky, 2018/03/14
- bug#18059: 24.3.92; defvar and special variables, Noam Postavsky, 2018/03/23
bug#18059: 24.3.92; defvar and special variables, Eli Zaretskii, 2018/03/05