Passing a variable messages list to Quiet

Question

I'm trying to build a Verbose option into some code but I'm having trouble passing to a Quiet statement a variable list of which messages I want to suppress.

My naïve try is code along the lines of

f[x_] := Module[{messageList},
  messageList = {Power::infy};
  Quiet[1/x, messageList]
  ]
f[0]

The idea would then be to build an option Verbose which controls whether the assignment messageList = {Power::infy} is made, or whether that variable is set to {}, which will let the message through.

However, even this bare-bones code is not working, and it returns messages of the sort

Quiet::anmlist: Argument 2 of Quiet[1/0,messageList$1303]
      should be All, None, a message name, or a list of message names. >>

(though obviously the number after messageList$ changes every time).

Edit

It seems, from a discussion in the comments, that two things are important (though I don't understand why). First of all, not all error messages are treated equally (as shown e.g. by running Evaluate[{Power::infy, FindRoot::lstol}]) so to give a better example, here is one with the error I'm interested in, FindRoot::lstol:

g[a_] := Module[{verbose = True, messageList},
  If[verbose,
   messageList = {},
   messageList = {FindRoot::lstol}
   ];
  Quiet[
   FindRoot[x^2 + x + a, {x, 3}]
   , messageList]
  ]
g[1]

It is also important to me to be able to control, from within the function (and eventually with an OptionsPattern[] that contains Verbose->True or False) whether the message list that gets passed is {} or a nontrivial one. I'm not picky about how it gets there (i.e. messageList = If[verbose, {}, {FindRoot::lstol}]; would serve just fine) but it does need to have at least that level of logic built in.

What is the correct way to do this?

You need to use Evaluate@messageList inside Quiet because Quiet has the attribute HoldAll. — C. E., Aug 20 '14 at 16:55
I tried that, but it has very patchy behaviour and different messages work differently. Try, for example, running Evaluate[{Power::infy, FindRoot::lstol}]: the first one evaluates to itself, but the second one returns the error message. And, of course, giving Quiet the message text is not what you want to do. — Emilio Pisanty, Aug 20 '14 at 17:14
OK, try this: function[x_] := With[{messageList := {Power::infy, FindRoot::lstol}}, Quiet[1/x, messageList]] (Worked for me on your example but I don't know what other corner cases there are.) — C. E., Aug 20 '14 at 17:31
@Pickett Unless I am overlooking something, there's no need to use SetDelayed inside With's first argument. — Teake Nutma, Aug 20 '14 at 17:41
@TeakeNutma You are overlooking the fact that otherwise FindRoot::lstol will be evaluated at assignment. For example With[{x = 2 + 2}, Hold[x]] versus With[{x := 2 + 2}, Hold[x]]. — C. E., Aug 20 '14 at 17:43
@Pickett That code works on its own, but it breaks down if the assignment of messageList contains any logic. Thus, even messageList := If[True, {FindRoot::lstol}] inside the With[{...} statement returns an error. — Emilio Pisanty, Aug 20 '14 at 17:58
@episanty OK, I like your new example. I think we at least did some ground work for the people who are good at this so that they can write answers. This is a little bit over my head now, though. +1 — C. E., Aug 20 '14 at 18:18

score 6 · Accepted Answer · answered Aug 21 '14 at 03:43

6

We can use Hold to prevent message names from being evaluated until the time is right:

g[a_, verbose_:False] :=
  Module[{messageList}
  , messageList = If[verbose, {}, Hold[FindRoot::lstol]]
  ; messageList /. _[m___] :> Quiet[FindRoot[x^2 + x + a, {x, 3}], {m}]
  ]

result screenshot

answered Aug 21 '14 at 03:43

WReach

68,832
4
164
269

So, in essence, this works not by Evaluating the Hold, but by replacing it with a 'wrapper' that's everything else in the Quiet? – Emilio Pisanty Aug 21 '14 at 14:01
(In that case, I think syntax like If[verbose, Hold[], Hold[FindRoot::lstol]] /. Hold[m___] :> Quiet[FindRoot[x^2 + x + a, {x, 3}], {m}] is a bit clearer.) – Emilio Pisanty Aug 21 '14 at 14:58
@episanty Yes, it works by preventing evaluation of the message list using Hold and then transforming the expression into a call to Quiet. Whether or not to use the auxiliary variable messageList, or to represent the empty message list using Hold[], are choices that can be made to suit one's taste (and the form of the "real" version of g). – WReach Aug 21 '14 at 18:15

score 5 · Answer 2 · answered Aug 29 '14 at 12:21

Why not something a little simpler?

g[a_, verbose_: False] /; ! verbose := Quiet[g[a, True], FindRoot::lstol]
g[a_, True] := FindRoot[x^2 + x + a, {x, 3}]

Now:

g[1]        (* no message *)

g[1, True]  (* FindRoot::lstol: printed *)

This has the advantage of separating the primary definition from the one that controls Message printing, making both easier to read in my opinion.

score 4 · Answer 3 · answered Aug 20 '14 at 21:02

I have found a workaround which works for my purposes, though it is not particularly pretty, and the weird behaviour of Evaluate on error messages remains a mystery to me. It is possible to switch between different Quiet behaviours by setting a custom message group and then switching that within the logic.

The following code works, as far as I can tell.

$MessageGroups = Join[$MessageGroups, {"Custom" :> {FindRoot::lstol}}]

g[a_, verbose_] := Module[{},
  If[verbose,
   $MessageGroups = ($MessageGroups /. {("Custom" :> {___}) -> ("Custom" :> {})}),
   $MessageGroups = ($MessageGroups /. 
                        {("Custom" :> {___}) -> ("Custom" :> {FindRoot::lstol})})
   ];
  Quiet[
   FindRoot[x^2 + x + a, {x, 3}]
   , {"Custom"}]
  ]

It has two obvious disadvantages:

The function g has side effects, and the value of "Custom"/.$MessageGroups is depends on the value of verbose on the last call to g.
This pollutes a global variable, and may therefore interfere with other uses of g run on other notebooks on the same kernel or on parallel kernels.

Both of these can probably be fixed with appropriate use of contexts, though it is probably enough to be careful with both of those disadvantages. In any case, I remain interested in a more 'normal' solution which doesn't need to meddle with normal variables and which explains the different behaviour of Power::infy and FindRoot::lstol.

score 1 · Answer 4 · answered Aug 20 '14 at 23:23

another workaround

example: problem

msg = {General::argx, Power::infy}
Quiet[1/0 + Sqrt[], Evaluate@msg]

example: workaround

msg = {General::argx::English, Power::infy}
Quiet[1/0 + Sqrt[], Evaluate@msg]

it seems: messages, which take arguments are problematic

Passing a variable messages list to Quiet

Edit

4 Answers4

another workaround

Linked