flet, cl-flet, cl-letf in 24.3

flet, cl-flet, cl-letf in 24.3

[ndemmel]

Hi,

it seems that from 24.3 on flet is marked as obsolete, to be replaced by cl-flet or cl-letf. If you are fine with lexical scope, cl-flet is your friend. However, I did not find explicit documentation on what to do when you want to keep relying on the dynamic scope as with the old flet. Is (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) the suggested method? Does that give always have dynamic scope? I'm a bit confused.

Best,
Niko

RE: flet, cl-flet, cl-letf in 24.3

[Drew Adams]

> it seems that from 24.3 on flet is marked as obsolete, to be 
> replaced by cl-flet or cl-letf. If you are fine with lexical 
> scope, cl-flet is your friend. However, I did not find 
> explicit documentation on what to do when you want to keep 
> relying on the dynamic scope as with the old flet. Is 
> (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 
> the suggested method? Does that give always have dynamic 
> scope? I'm a bit confused.

If you have read the doc and you feel it does not make things clear, consider
filing a doc bug: `M-x report-emacs-bug'.

Re: flet, cl-flet, cl-letf in 24.3

[ndemmel]

On Sunday, April 21, 2013 9:41:11 AM UTC+2, Drew Adams wrote:
> > it seems that from 24.3 on flet is marked as obsolete, to be 
> 
> > replaced by cl-flet or cl-letf. If you are fine with lexical 
> 
> > scope, cl-flet is your friend. However, I did not find 
> 
> > explicit documentation on what to do when you want to keep 
> 
> > relying on the dynamic scope as with the old flet. Is 
> 
> > (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 
> 
> > the suggested method? Does that give always have dynamic 
> 
> > scope? I'm a bit confused.
> 
> 
> 
> If you have read the doc and you feel it does not make things clear, consider
> 
> filing a doc bug: `M-x report-emacs-bug'.

I don't even have emacs 24.3 installed. I'm referring to the documentation [1,2,3,4]. Together with the notification

    `flet' is an obsolete macro (as of 24.3); use either `cl-flet' or `cl-letf'.

as reported here [5], this documentation does not really tell me what to do if I want to keep relying on the dynamic scoping of flet. A brief google search [6] leads me to believe that 

    (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 

is the suggested solution, however I wanted to make sure that is the case.

In any case if that were the sugggested way, it should maybe be added to one of the documentation sites [1,2,3,4]. I'd be happy to file a report on that.

Cheers,
Niko


[1] http://www.gnu.org/software/emacs/manual/html_node/cl/Function-Bindings.html#index-cl_002dflet-24
[2] http://www.gnu.org/software/emacs/manual/html_node/cl/Obsolete-Macros.html#index-flet-173
[3] http://www.gnu.org/software/emacs/manual/html_node/cl/Obsolete-Macros.html#index-letf-175
[4] http://www.gnu.org/software/emacs/manual/html_node/cl/Modify-Macros.html#index-cl_002dletf-19
[5] https://github.com/moesenle/rosemacs-debs/issues/2
[6] https://groups.google.com/forum/#!msg/gnu.emacs.help/eaopyFH5hmY/emHfn-DYZZIJ

RE: flet, cl-flet, cl-letf in 24.3

[Drew Adams]

> > If you have read the doc and you feel it does not make 
> > things clear, consider filing a doc bug: `M-x report-emacs-bug'.
> 
> I don't even have emacs 24.3 installed. I'm referring to the
> documentation [1,2,3,4]. Together with the notification
>     `flet' is an obsolete macro (as of 24.3); use either 
>     `cl-flet' or `cl-letf'.
> as reported here [5], this documentation does not really tell 
> me what to do if I want to keep relying on the dynamic 
> scoping of flet.  A brief google search [6] leads me to believe
> that (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 
> is the suggested solution, however I wanted to make sure that 
> is the case.

It is good to ask the question here, of course, and someone will likely post a
good answer soon.

> In any case if that were the sugggested way, it should maybe 
> be added to one of the documentation sites [1,2,3,4]. I'd be 
> happy to file a report on that.

Please do.  That can help Emacs Dev understand what might need to be done to
make things clearer.  If there is a misunderstanding wrt the references you
cite, Emacs Dev will likely let you know that too.  Just becoming aware of a
misunderstanding can be helpful input to those trying to communicate better.

Re: flet, cl-flet, cl-letf in 24.3

[Stefan Monnier]

> as reported here [5], this documentation does not really tell me what to do
> if I want to keep relying on the dynamic scoping of flet.  A brief google
> search [6] leads me to believe that

>     (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 

> is the suggested solution,

That's the case.

> Does that always have dynamic scope?

How could it not?

> however I wanted to make sure that is the case.

Even better in most cases is:

     (defvar my-enable-foo-advice nil)
     (defadvice foo (...)
       (if my-enable-foo-advice ... ...))

and then replace (flet ((foo ...)) ...)
with (let ((my-enable-foo-advice t)) ...)


        Stefan

Re: flet, cl-flet, cl-letf in 24.3

[Andreas Röhler]

Am 22.04.2013 15:32, schrieb Stefan Monnier:
>> as reported here [5], this documentation does not really tell me what to do
>> if I want to keep relying on the dynamic scoping of flet.  A brief google
>> search [6] leads me to believe that
>
>>      (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...)
>
>> is the suggested solution,
>
> That's the case.
>
>> Does that always have dynamic scope?
>
> How could it not?
>
>> however I wanted to make sure that is the case.
>
> Even better in most cases is:
>
>       (defvar my-enable-foo-advice nil)
>       (defadvice foo (...)
>         (if my-enable-foo-advice ... ...))
>
> and then replace (flet ((foo ...)) ...)
> with (let ((my-enable-foo-advice t)) ...)
>
>
>          Stefan
>
>
>

Hi Stefan,

until now, a let bound variable was easy to use, there was no difficulty wrt global namespace.
 From this would expect some confusion, as a defvar is Emacs-wide. Isn't a defvar setting init-value only at first time?

I.e. if another program already used (defvar my-enable-foo-advice 'my-init-value)
  (defvar my-enable-foo-advice nil) should have not effect.

May someone point me to the thread where that was discussed?

Thanks,

Andreas

Re: flet, cl-flet, cl-letf in 24.3

[ndemmel]

On Monday, April 22, 2013 3:32:05 PM UTC+2, Stefan Monnier wrote:
> > as reported here [5], this documentation does not really tell me what to do
> 
> > if I want to keep relying on the dynamic scoping of flet.  A brief google
> 
> > search [6] leads me to believe that
> 
> 
> 
> >     (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 
> 
> 
> 
> > is the suggested solution,
> 
> 
> 
> That's the case.

Thanks!

> 
> > Does that always have dynamic scope?
> 
> How could it not?
> 

I'm not sure. What makes you say that? I can see how a lexical binding to a generalized place (not a variable) would not neccessarily make sense; is that what you mean? Otoh cl-flet does exactly that, for the special case of (symbol-function ...), or is that not how I should view it?

> 
> > however I wanted to make sure that is the case.
> 
> 
> 
> Even better in most cases is:
> 
> 
> 
>      (defvar my-enable-foo-advice nil)
> 
>      (defadvice foo (...)
> 
>        (if my-enable-foo-advice ... ...))
> 
> 
> 
> and then replace (flet ((foo ...)) ...)
> 
> with (let ((my-enable-foo-advice t)) ...)
> 

I see. In my case I was concerned with keeping legacy code working without changing much.

Thanks!
Niko

Re: flet, cl-flet, cl-letf in 24.3

[Pascal J. Bourguignon]

ndemmel@gmail.com writes:

> On Monday, April 22, 2013 3:32:05 PM UTC+2, Stefan Monnier wrote:
>> > as reported here [5], this documentation does not really tell me what to do
>> 
>> > if I want to keep relying on the dynamic scoping of flet.  A brief google
>> 
>> > search [6] leads me to believe that
>> 
>> 
>> 
>> >     (cl-letf (((symbol-function 'foo) #'(lambda (...) ...))) ...) 
>> 
>> 
>> 
>> > is the suggested solution,
>> 
>> 
>> 
>> That's the case.
>
> Thanks!
>
>> 
>> > Does that always have dynamic scope?
>> 
>> How could it not?
>> 
>
> I'm not sure. What makes you say that? 

That's because it's not until run-time that the function slot of the
symbol foo is modified.  The _expression_ is evaluated at run-time.
Here we have a literal anonymous function, but it could be any
expression returning a function determined at run-time.

Therefore there's absolutely no way the compiler can know what (foo x)
means inside the cl-letf (apart from the fact that it's a function
call).

Also, since (symbol-function 'foo) is a global place, _while_ the cl-letf
is in effect, (foo x) will call your lambda even outside of the lexical
scope of the cl-letf.



> I can see how a lexical binding
> to a generalized place (not a variable) would not neccessarily make
> sense; is that what you mean? 

Indeed.



-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
A bad day in () is better than a good day in {}.

Re: flet, cl-flet, cl-letf in 24.3

[Stefan Monnier]

> I see. In my case I was concerned with keeping legacy code working
> without changing much.

Then you don't need to change anything, since flet still works
as before.


        Stefan