dolist?

dolist?

[Lennart Borgman]

I am trying to use dolist in the function below. When I comment out the 
line marked below I only get the first det from detlst. What is wrong? 
Is dolist a no-no? Or is this a bug?


(defun instpack-check-pack-list()
  (message "Checking package list detail names...")
  (dolist (pack instpack-package-list)
    (let ((name (nth 0 pack))
      (detlst (nth 1 pack)))
      (message "  %s" name)
      (when detlst
    (dolist (det detlst)
          ;;(message "    det=%s" det) ;; <----------- I only get the 
first "det" if I comment out this...
      (let ((detname (car det)))
        (message (concat "  ... checking detail name " (symbol-name 
detname)))
        (unless (instpack-detail-valid detname)
          (error (concat "Detail name " detname " in package " name " is 
invalid" )))))))))

Re: dolist?

[Lennart Borgman]

Lennart Borgman wrote:

> I am trying to use dolist in the function below. When I comment out 
> the line marked below I only get the first det from detlst. What is 
> wrong? Is dolist a no-no? Or is this a bug?

Since I sent my last update reply on this to myself instead of the list 
I am trying again...

Here is a better example for testing. Please test this with the marked 
message commented out and not commented out. Just put it in a buffer and 
eval it.

Am I doing something seriously silly? Has someone checked this or should 
I file a bug?

    --lennart


******** Test example, run with marked line COMMENTED OUT/NOT COMMENTED 
OUT. Check *Messages*.
(defconst assoc-assoc-list nil)
(setq assoc-assoc-list
      '(
        ("cedet-1.03b"
         (
          (description . "CEDET")
          (install-function . 'cedet-setup)
          ))
        ("nxml-mode-20041004"
         (
          (description . "NXML")
          (install-function . 'nxml-setup)
          ))
        ))

(defun check-detail(consdet)
  (unless nil
    ;;(message "    consdet=%s" consdet) ;; <---- does not work unless 
this is NOT commented out
    )
  (let ((detname (car consdet)))
    (message (concat "    ... checking detail \"" (symbol-name detname) 
"\""))))
 
(defun check-list()
  (message "Checking package list detail names...")
  (mapc
   (lambda (pack)
     (let ((detlst (nth 1 pack)))
       (when detlst
         (message "\ndetlst=%s" detlst)
         (mapc 'check-detail detlst))))
   assoc-assoc-list))

(check-list)

********** If run with marked line COMMENTED OUT it gives this:
Checking package list detail names...

detlst=((description . CEDET) (install-function quote cedet-setup))
    ... checking detail "install-function"

detlst=((description . NXML) (install-function quote nxml-setup))
    ... checking detail "install-function"

********** If run with marked line NOT COMMENTED OUT it gives this:
Checking package list detail names...

detlst=((description . CEDET) (install-function quote cedet-setup))
    consdet=(description . CEDET)
    ... checking detail "description"
    consdet=(install-function quote cedet-setup)
    ... checking detail "install-function"

detlst=((description . NXML) (install-function quote nxml-setup))
    consdet=(description . NXML)
    ... checking detail "description"
    consdet=(install-function quote nxml-setup)
    ... checking detail "install-function"

Re: dolist?

[Lennart Borgman]

Lennart Borgman wrote:

> Here is a better example for testing. Please test this with the marked 
> message commented out and not commented out. Just put it in a buffer 
> and eval it.
>
> Am I doing something seriously silly? Has someone checked this or 
> should I file a bug?

Got some time to make an even simpler test, see below:



(defconst assoc-list nil)
(setq assoc-list
      '((description . "CEDET")
        (install-function . "cedet-setup")))

(defvar callmsg nil)
(defun check-detail(consdet)
  (when callmsg (message "    *****")) ;; <---- works only if message is 
called
  (let ((detname (car consdet)))
    (message (concat "    ... checking detail \"" (symbol-name detname) 
"\""))))
 
(message "\n-----------------------Single, NO marked message call:")
(setq callmsg nil)
(mapc 'check-detail assoc-list)
(message "\n-----------------------Single, WITH marked message call:")
(setq callmsg t)
(mapc 'check-detail assoc-list)

Re: dolist? - same result on 21.3

[Lennart Borgman]

Lennart Borgman wrote:

> Lennart Borgman wrote:
>
>> Here is a better example for testing. Please test this with the 
>> marked message commented out and not commented out. Just put it in a 
>> buffer and eval it.
>>
>> Am I doing something seriously silly? Has someone checked this or 
>> should I file a bug?
>
>
> Got some time to make an even simpler test, see below:
>
>
>
> (defconst assoc-list nil)
> (setq assoc-list
>      '((description . "CEDET")
>        (install-function . "cedet-setup")))
>
> (defvar callmsg nil)
> (defun check-detail(consdet)
>  (when callmsg (message "    *****")) ;; <---- works only if message 
> is called
>  (let ((detname (car consdet)))
>    (message (concat "    ... checking detail \"" (symbol-name detname) 
> "\""))))
>
> (message "\n-----------------------Single, NO marked message call:")
> (setq callmsg nil)
> (mapc 'check-detail assoc-list)
> (message "\n-----------------------Single, WITH marked message call:")
> (setq callmsg t)
> (mapc 'check-detail assoc-list) 


I just tested on 21.3 and got the same result.

Re: dolist?

[Miles Bader]

I expect it has something to do with message's special handling of
lines containing "..." -- if you replace the "..." with "x" in your
message strings, your example works as expected.

[I'm looking at the "*Messages*" buffer to judge the results.]

-Miles
-- 
Do not taunt Happy Fun Ball.

Re: dolist?

[David Ponce]

Lennart Borgman wrote:
> Lennart Borgman wrote:
> 
>> Here is a better example for testing. Please test this with the marked 
>> message commented out and not commented out. Just put it in a buffer 
>> and eval it.
>>
>> Am I doing something seriously silly? Has someone checked this or 
>> should I file a bug?
> 
> 
> Got some time to make an even simpler test, see below:

It looks there is a problem with the function `message' when the message
string starts with "...".

trying this (emacs -Q):

(dolist (i '(1 2 3 4))
   (message "... %d" i))

The *message* buffer received:

... 4

With this:

(dolist (i '(1 2 3 4))
   (message ".. %d" i))

.. 1
.. 2
.. 3
.. 4

Weird.
David

Re: dolist?

[Juanma Barranquero]

(mapc #'(lambda (x) (message "..%s" x)) '(1 2 3 4)) 

In *Messages* =>
..1
..2
..3
..4

(mapc #'(lambda (x) (message "...%s" x)) '(1 2 3 4))

In *Messages* =>
...4

Seems like a "feature" of the messages, when using "...".

-- 
                    /L/e/k/t/u

Re: dolist?

[Lennart Borgman]

Juanma Barranquero wrote:

>(mapc #'(lambda (x) (message "...%s" x)) '(1 2 3 4))
>
>In *Messages* =>
>...4
>
>Seems like a "feature" of the messages, when using "...".
>  
>
It feels like a quizz (is that how you spell it?) and I am impressed 
that you all find it so easily. I think this feature should be 
documented. It saves time. (Even if trying to find out what is happening 
is kind of fun, and worrying. Because I am not very fluent in list 
processing I thought there where some conventions I did not know about, 
that might have explained the behaviour. When you have a lot of options 
it is rather difficult, actually.)

Is there a way to calm down the message function?

Re: dolist?

[Juanma Barranquero]

On 7/2/05, Juanma Barranquero <lekktu@gmail.com> wrote:

> Seems like a "feature" of the messages, when using "...".

Yeah. Take a look at message_log_check_duplicate() and friends
(src/xdisp.c). If I understand correctly, it substitute several
identical messages

   ...x
   ...x
   ...x

by

   ...x [3 times]

and

   ...x
   ...y

just by

   ...y

Is that documented anywhere other than the source?

-- 
                    /L/e/k/t/u

Re: dolist?

[Juanma Barranquero]

On 7/2/05, Lennart Borgman <lennart.borgman.073@student.lu.se> wrote:

> and I am impressed
> that you all find it so easily.

Well, Miles implemented that, or at least part of it. Me, I didn't
know. I vaguely remembered the "[x times]" thing, but I wouldn't have
supposed in a million years that "..x", "...y" would end as "...y".
That feels "...wrong [100 times]" ;-)

-- 
                    /L/e/k/t/u

Re: dolist?

[Lennart Borgman]

Juanma Barranquero wrote:

>On 7/2/05, Lennart Borgman <lennart.borgman.073@student.lu.se> wrote:
>
>  
>
>>and I am impressed
>>that you all find it so easily.
>>    
>>
>
>Well, Miles implemented that, or at least part of it. Me, I didn't
>know. I vaguely remembered the "[x times]" thing, but I wouldn't have
>supposed in a million years that "..x", "...y" would end as "...y".
>That feels "...wrong [100 times]" ;-)
>
It feels "standard-output" - but (message ..) does not honor 
standard-output. So, yes, I think this is a not so good feature (the 
last one, the first one is good).

RE: dolist? - same result on 21.3

[Drew Adams]

Likewise, in Emacs 20.7 ("..." doesn't work, even though ".." does), so this
is old behavior.

And mapcar has the same behavior (the resulting list is correct, however).
This is true in both Emacs 22 (from CVS April) and Emacs 20.7.

mapc is implemented in C source in more recent Emacs versions, but in Emacs
20.7 it is defined in terms of mapcar (in cl-extra.el).

It seems odd that the behavior would be the same across versions, but in
Emacs 22, the C code for mapc and mapcar look similar, as do the mapcar C
implementations for Emacs 20 and 22 (different alloc methods).

Looks like a nice bug, to me.

Re: dolist?

[David Ponce]

Lennart Borgman wrote:
> Juanma Barranquero wrote:
> 
>> (mapc #'(lambda (x) (message "...%s" x)) '(1 2 3 4))
>>
>> In *Messages* =>
>> ...4
>>
>> Seems like a "feature" of the messages, when using "...".
[...]

Yes it permits this:

(progn
   (message "test...")
   (message "test...done")
   )

*Messages*

test...done

With this:

(progn
   (message "test..")
   (message "test..done")
   )

*Messages*

test..
test..done

David

RE: dolist?

[Drew Adams]

    Is there a way to calm down the message function?

How about reserving the "..." feature for internal Emacs calls, using a
separate function, say, `message-internal' (or `message...')?

Users should be able to use `message' without working with or around this
"feature".

Re: dolist?

[Lennart Borgman]

David Ponce wrote:

> Lennart Borgman wrote:
>
>> Juanma Barranquero wrote:
>>
>>> (mapc #'(lambda (x) (message "...%s" x)) '(1 2 3 4))
>>>
>>> In *Messages* =>
>>> ...4
>>>
>>> Seems like a "feature" of the messages, when using "...".
>>
Looking at the magic three dots again with a somewhat calmer mind I 
realize they are useful if documented (and a bit evil if not). I vote 
for documenting them (this is the missionary style of frustration).

RE: dolist?

[Drew Adams]

    Yes it permits this:
    (progn (message "test...")(message "test...done"))
    *Messages*
    test...done

Yes, but it should not be hard-wired into the standard message function.

There should either be two different functions, only one of which has this
feature, or this should somehow be optional with `message'.

Re: dolist?

[Adrian Aichner]

Juanma Barranquero <lekktu@gmail.com> writes:

> On 7/2/05, Lennart Borgman <lennart.borgman.073@student.lu.se> wrote:
>
>> and I am impressed
>> that you all find it so easily.
>
> Well, Miles implemented that, or at least part of it. Me, I didn't
> know. I vaguely remembered the "[x times]" thing, but I wouldn't have
> supposed in a million years that "..x", "...y" would end as "...y".
> That feels "...wrong [100 times]" ;-)

FWIW, XEmacs does not have this "feature".

-- 
Adrian Aichner
 mailto:adrian@xemacs.org
 http://www.xemacs.org/

RE: dolist?

[Drew Adams]

    Looking at the magic three dots again with a somewhat calmer mind I
    realize they are useful if documented (and a bit evil if not). I vote
    for documenting them (this is the missionary style of frustration).

Evil, even if documented. A user would have to somehow implement his own
messaging function, to workaround this.

That is, if you ever want more than just the last "..." message to show up
in *Messages*, you're out of luck. The standard `message' function should be
more general (standard). If it is to always perform magic for such a special
case, then another messaging function should be made available. Otherwise,
there should be some way of turning off the message magic.

Re: dolist?

[Miles Bader]

2005/7/3, Drew Adams <drew.adams@oracle.com>:
> There should either be two different functions, only one of which has this
> feature, or this should somehow be optional with `message'.

There could be a variable you bind to have it not do such suppression
(or to refine the algorithm it uses -- perhaps telling the message
code what prefix to consider a duplicate [instead of looking for
"..."]).

However, the standard `message' calls should probably be left as is. 
Most elisp programmers treat `message' as temporary output, and don't
consider that the results are logged, so they often write many
progress messages using `message'.  This looks great to the user, but
can make the message log completely useles by swamping it with
duplicate entries; the current suppression of duplicates tries to work
around this problem.

Documentation is of course a good thing...

-Miles
-- 
Do not taunt Happy Fun Ball.

RE: dolist?

[Drew Adams]

    > There should either be two different functions, only one of 
    > which has this feature, or this should somehow be optional
    > with `message'.
    
    There could be a variable you bind to have it not do such suppression
    (or to refine the algorithm it uses -- perhaps telling the message
    code what prefix to consider a duplicate [instead of looking for
    "..."]).

That would be OK. Just so users have some way around the "magic" behavior.

Agreed, we shouldn't do anything that affects existing `message' calls.

And the behavior needs to be documented.

Re: dolist?

[Richard M. Stallman]

    (mapc #'(lambda (x) (message "...%s" x)) '(1 2 3 4))

    In *Messages* =>
    ...4

    Seems like a "feature" of the messages, when using "...".

This feature is very useful--it prevents a series of progress
messages from cluttering up *Messages*.

It ought to be better documented, though.  I explained this in the
Lisp Manual.

Drew Adams wrote:

    Yes, but it should not be hard-wired into the standard message function.

There's no need for that.  *Message* is meant to provide convenient
info for the user.  Giving programs "full control over *Message*" is
not the goal.  (But they can get it by editing the buffer directly.)

    That is, if you ever want more than just the last "..." message to show up
    in *Messages*, you're out of luck. The standard `message' function should be
    more general (standard).

That would be tantamount to disabling the feature most of the time.
It would make things worse, not better.  We will not make that change.

RE: dolist?

[Drew Adams]

    *Message* is meant to provide convenient info for the user.
    Giving programs "full control over *Message*" is not the goal.

It might not be the goal, but it could be a secondary goal.

        That is, if you ever want more than just the last "..."
        message to show up in *Messages*, you're out of luck.
        The standard `message' function should be more general

    That would be tantamount to disabling the feature most of the time.
    It would make things worse, not better.

No it wouldn't, not if we took Miles's suggestion of providing a variable
that users could set to block the "magic" when needed. The current, magic
behavior would be the default, and no existing code calling `message' would
need to be changed.

(let ((message...magic-p nil)) (message "  ... showme anyway"))

    We will not make that change.

Too bad. Thanks for documenting the magic, anyway.