SetOptions locally?

Question

Is there a way to SetOptions locally? For example, I have a Module and inside it I am doing a lot of Plots with similar options. If I do a SetOptions[Plot, ...] inside the Module, the change propagates outside. I don't like this because I have other Modules where I am doing other plots with different options.

Is there a way to do a SetOptions[Plot, ...] that only affects "local" plots (say inside a Module, but I am open to any scoping construct)? Here Plot is only an example. In general I want to set options locally for any symbol.

Answer 1

Version 12.2

In version 12.2, use the new function WithCleanup[]:

With[{plotOptions = Options[Plot]}, 
     WithCleanup[SetOptions[Plot, PlotStyle -> Green], 
                 Plot[Sin[x], {x, -π, π}],
                 SetOptions[Plot, plotOptions]]]

which is a direct replacement of the older undocumented function described below.

---

Older versions

Usual caveats about using undocumented functions aside, here is how one might use Internal`WithLocalSettings[]:

With[{plotOptions = Options[Plot]}, 
     Internal`WithLocalSettings[SetOptions[Plot, PlotStyle -> Green], 
                                Plot[Sin[x], {x, -π, π}],
                                SetOptions[Plot, plotOptions]]]

but I do not think this to be any better than Nasser's proposal. As can be surmised from how it was used above, you can think of the three arguments of Internal`WithLocalSettings[] as three stages: setup, body, and clean-up. Carl notes in a comment below that the advantage of using this function is that any code in the first and third arguments are uninterruptible.

A more usual case for its use would be for localizing changes to system settings that are not easily accessible to SetOptions[]. Using the Wizard's code from here as an example:

With[{spopt = SystemOptions["SparseArrayOptions"]},
     Internal`WithLocalSettings[
              SetSystemOptions["SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}],
              ind = {{3, 1}, {3, 3}, {1, 3}, {2, 1}, {3, 2}, {3, 1},
                     {3, 2}, {3, 3}, {1, 3}, {3, 1}};
              val = {1, 1, 3, 0, 3, 4, 3, 1, 1, 1};
              SparseArray[ind -> val] // Normal,
              SetSystemOptions[spopt]]]
   {{0, 0, 4}, {0, 0, 0}, {6, 6, 2}}

(See also this SO thread and this example usage by Oleksandr.)

Answer 2

I have used several methods, including the ones in the other answers. I have found that the simplest method is Internal`InheritedBlock as it allows for temporary changes to a symbol to be made, including changes to Options. For example,

Internal`InheritedBlock[{Plot},
  SetOptions[Plot, PlotStyle -> Red, Frame -> True];
  Plot[Sin[x], {x, 0, 2 Pi}]
]
Plot[Sin[x], {x, 0, 2 Pi}]

Obviously, this has the most utility when you are making multiple plots, but this illustrates the point.

Answer 3

Just define your options as sequence held in a local variable.

Module[{opts = Sequence[PlotStyle -> Red, Frame -> True]},
  Plot[Sin[2 π x], {x, 0, 1}, Evaluate @ opts]]

Answer 4

This is a simple solution. The idea is to save the Plot options on entry, and restore it on leaving the module to whatever it was

f := Module[{savedOpt = Options[Plot]},
  SetOptions[Plot, PlotStyle -> Green];
  Print@Plot[Sin[x], {x, -Pi, Pi}];
  SetOptions[Plot, savedOpt]
  ]

Now global Plot options are not changed. Test: