Two binding features

Two binding features

[Richard M Stallman]

Two primitive features that would be useful for mumamo
(and perhaps othere programs) are:

* A primitive that would let-bind variables from an alist.
I think Common Lisp has such a construct; is that correct?
I do not recall its name, though.

* A way to temporarily turn off all buffer-local bindings.  This could
take the form of a variable which you would bind with `let', and when
it is non-nil, the buffer-local bindings are not visible.
`with-current-buffer' should bind it to nil so that the buffer-local
bindings of the newly current buffer always do take effect.

It would be ok if certain variables whose values are stored directly
in the buffer object, such as `buffer-file-name', fail to be affected
by this feature.

I think any feature to temporarily switch modes, or pretend to do so,
would find these features useful.  Could someone implement them?

Re: Two binding features

[David Kastrup]

Richard M Stallman <rms@gnu.org> writes:

> Two primitive features that would be useful for mumamo
> (and perhaps othere programs) are:
>
> * A primitive that would let-bind variables from an alist.
> I think Common Lisp has such a construct; is that correct?
> I do not recall its name, though.
>
> * A way to temporarily turn off all buffer-local bindings.  This could
> take the form of a variable which you would bind with `let', and when
> it is non-nil, the buffer-local bindings are not visible.

How about making (with-current-buffer nil ...)  have that effect (in
case this is not already the case or an error)?  Or is that
inconvenient?

> I think any feature to temporarily switch modes, or pretend to do so,
> would find these features useful.

How so?

-- 
David Kastrup

Re: Two binding features

[Johan Bockgård]

Richard M Stallman <rms@gnu.org> writes:

> * A primitive that would let-bind variables from an alist.
> I think Common Lisp has such a construct; is that correct?
> I do not recall its name, though.

  progv is a Lisp macro in `cl-macs.el'.

  (progv SYMBOLS VALUES &rest BODY)

  Bind SYMBOLS to VALUES dynamically in BODY.
  The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
  Each symbol in the first list is bound to the corresponding value in the
  second list (or made unbound if VALUES is shorter than SYMBOLS); then
  the
  BODY forms are executed and their result is returned.  This is much like
  a `let' form, except that the list of symbols can be computed at
  run-time.

-- 
Johan Bockgård

Re: Two binding features

[Paul R]

bojohan+news@dd.chalmers.se (Johan Bockgård) writes:

> Richard M Stallman <rms@gnu.org> writes:
>
>> * A primitive that would let-bind variables from an alist.
>> I think Common Lisp has such a construct; is that correct?
>> I do not recall its name, though.
>
>   progv is a Lisp macro in `cl-macs.el'.
>
>   (progv SYMBOLS VALUES &rest BODY)
>
>   Bind SYMBOLS to VALUES dynamically in BODY.
>   The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists.
>   Each symbol in the first list is bound to the corresponding value in the
>   second list (or made unbound if VALUES is shorter than SYMBOLS); then
>   the
>   BODY forms are executed and their result is returned.  This is much like
>   a `let' form, except that the list of symbols can be computed at
>   run-time.

destructuring-bind is also a lisp macro in cl-macs.el. No docstring in
my install. It works pretty much the same, but generalized to any
structure for symbols and values.
Also, I feel org-mode implemented exactly what Richard said, I'll dig
it a bit more and report later.

-- 
      Paul

Re: Two binding features

[Richard M Stallman]

    > * A way to temporarily turn off all buffer-local bindings.  This could
    > take the form of a variable which you would bind with `let', and when
    > it is non-nil, the buffer-local bindings are not visible.

    How about making (with-current-buffer nil ...)  have that effect (in
    case this is not already the case or an error)?  Or is that
    inconvenient?

This would seem to mean that no buffer is current
and you can't edit any buffer.  That is not what we want.

Re: Two binding features

[Richard M Stallman]

progv in CL is implemented using unwind-protect.
That does the job, but maybe it would be better
to implement it as a primitive, making real bindings.

The current implementation has one advantage: it uses
just one specpdl slot for any number of variables.
But I suspect that the unwind-protect implementation
will give wrong results in some cases, for instance
when buffer-local bindings are in use for the same
variables.

Re: Two binding features

[Stefan Monnier]

> Two primitive features that would be useful for mumamo
> (and perhaps othere programs) are:

> * A primitive that would let-bind variables from an alist.
> I think Common Lisp has such a construct; is that correct?
> I do not recall its name, though.

> * A way to temporarily turn off all buffer-local bindings.  This could
> take the form of a variable which you would bind with `let', and when
> it is non-nil, the buffer-local bindings are not visible.
> `with-current-buffer' should bind it to nil so that the buffer-local
> bindings of the newly current buffer always do take effect.

> It would be ok if certain variables whose values are stored directly
> in the buffer object, such as `buffer-file-name', fail to be affected
> by this feature.

> I think any feature to temporarily switch modes, or pretend to do so,
> would find these features useful.  Could someone implement them?

The above features can be simulated fairly well and easily with Elisp
code, so I think it'd be better to first try an Elisp implementation and
when it turns out that it is indeed useful and that the performance
and/or semantics of the Elisp code is problematic, we can consider
adding the feature in C.


        Stefan

Re: Two binding features

[Richard M Stallman]

Mumamo already has Lisp code to do these jobs.
Of course, it is rather ugly.  What we need now is
primitives to do it cleanly.