RE: wrapper fn for message and minibuffer-message?

[Drew Adams]

        differences between `message' and `minibuffer-message':
         - `message' exits the minibuffer (and recursive edit);

    No it doesn't.

My bad.

         - `minibuffer-message' wraps the message in "  [...]";
           `message' does not

    That's just a matter of how to make it stand out at the end of
    the minibuffer.

Yes, of course.

I should also have mentioned this difference:

 - `message' temporarily erases the minibuffer before
   displaying the message; `minibuffer-message appends
   the message to the minibuffer contents, so both are
   visible together

I guess that's part of what you're referring to with your variable
`minibuffer-message-at-end': if non-nil, the message would be appended,
without first erasing the minibuffer.

I still have the same question: Would the variable also be set to non-nil
implicitly, whenever `minibufferp'? (That was the behavior I originally
suggested: use `minibuffer-message' when the minibuffer is active.)

If no, then what is now a simple call to `minibuffer-message' would require
something like (let ((minibuffer-message-at-end t)) (message ...)). If yes,
then a simple call to `message' could require (let
((minibuffer-message-at-end nil)) (message ...)). IIUC, I don't see the
advantage of the variable. But I'm probably missing something.

        It could use the same mechanism as now; or, maybe it would
        be cleaner to change the lower levels of redisplay to display
        the message at the end of the minibuffer when it is selected.

    Sorry, I don't understand you, here. Could you elaborate a bit?

 {}?

Do you mean that low-level redisplay would, in effect, use
`minibuffer-message' when the minibuffer is active and `message' otherwise?
If so, that's the behavior of the function I suggested.

However, if that is the behavior for `message', then my comment above
applies: you would need to do (let ((minibuffer-message-at-end nil))
(message ...)) to get the current effect of `message' (erase content first)
when the minibuffer is active. Sometimes you want to erase the minibuffer
first, even if the minibuffer is active. Most of the time you don't.

Why is your solution "cleaner" than just having `message' (erase first),
`minibuffer-message' (append without erasing), and a wrapper function that
DTRT most of the time (based on `minibufferp')?