Access to variables in surrounding context from within Manipulate

Question

Suppose you want to access a variable defined in a "surrounding" context (scoped via Begin and End) from within Manipulate. The following naive attempt does not work.

Begin["MyContext`"];
x = 123;
Manipulate[x + y, {y, 0, 1}]
End[];
x = 456; (* changes the value of Manipulate output *)

One way to fix this is by using Inactive and Activate as follows.

Begin["MyContext`"];
x = 123;
Activate@Manipulate[Inactive[x] + y, {y, 0, 1}]
End[];
x = 456; (* does not change the value of Manipulate output *)
MyContext`x = 456; (* changes the value of Manipulate output *)

Is this a robust way to achieve the desired goal or do you see any problems using this pattern in more involved examples? If so which alternative solutions do you suggest?

Answer 1

What you are showing can in principle work, under two conditions:

• You need to have the Begin[…] and End[…] parts in different cells. If you do not, the symbol x is already resolved to Global`x before the context is changed. This is because as a first step, the entire cell contents are converted into an expression using MakeExpression. Only then are the individual lines evaluated.

• x must not exist in the Global` context when evaluating your code. This is because otherwise x is still resolved to Global`x, because $ContextPath still contains Global` , so no new symbol is created.¨

  Begin["MyContext`"];
  
  (* separate cell *)
  x = 123;
  
  Manipulate[x + y, {y, 0, 1}]
  
  (* separate cell *)
  End[];
  
  (* separate cell *)
  x = 456;(*does not change the value of Manipulate output*)
  

  

Here are three approaches to make sure the second condition is not an issue:

• Use `x instead of x. This makes sure you are referring to the x in the current context, and not Global`x

  x = 233;
  
  (* separate cell *)
  Begin["MyContext`"];
  
  `x = 123;
  
  Manipulate[`x + y, {y, 0, 1}]
  
  (* separate cell *)
  End[];
  
  (* separate cell *)
  x = 456;(*does not change the value of Manipulate output*)
  

  

• Change $ContextPath temporarily.

  x = 233;
  
  Begin["MyContext`"];
  oldCP = $ContextPath; $ContextPath = {"System`", $Context};
  
  (* separate cell *)
  x = 123;
  
  Manipulate[x + y, {y, 0, 1}]
  
  (* separate cell *)
  $ContextPath = oldCP;
  End[];
  
  (* separate cell *)
  x = 456;(*does not change the value of Manipulate output*)
  

  

• Use BeginPackage to handle $ContextPath for you.

  x = 233;
  
  (* separate cell *)
  BeginPackage["System`"];
  Begin["MyContext`"];
  
  (* separate cell *)
  x = 123;
  Manipulate[x + y, {y, 0, 1}]
  
  (* separate cell *)
  End[];
  EndPackage[];
  
  (* separate cell *)
  x = 456;(*does not change the value of Manipulate output*)
  

  

  This makes use of the same strategy that is used for paclet development: You use BeginPackage to temporarily reset $ContextPath to a clean version, and use Begin to make a private context whose symbols are not seen from the outside. The only difference is that here, I'm using BeginPackage["System`"] in order not to create any superfluous contexts. You could also use BeginPackage["MyContext`"], and then Begin["`Private`"]. You could then expose some of the symbols by declaring them before the Begin[...] part, and hide the other ones in the MyContext`Private` subcontext.

To work around the issue mentioned by @MichaelE2 with the labels of the sliders, you can manually specify the label for the slider using the syntax {{y,0,"y"},0,1} to specify the slider.

Answer 2

You can take advantage of $CellContext` and the cell option CellContext:

Remove@x;
Begin["MyContext`"];
x = 123;
CellPrint[
 ExpressionCell[
  Manipulate[x + y, {y, 0, 1}],
  "Output",
  CellContext -> Context[]
  ]
 ]
End[];
x = 456;   (* does not change the value of Manipulate output *)
MyContext`x = 789; (* changes the value of Manipulate output *)

Caveat:

If the output cell generated above is copied and pasted, all works fine.

If only the Manipulate in the output cell is copied and it is pasted into an existing cell, then the context of that cell will be used. Normally the cell context is Global` .

Alternate method

In this alternative, Manipulate sets the cell context. If the Manipulate output is copied and pasted into another cell, it will overwrite that cell's context to "MyContext`".

Begin["MyContext`"];
`x = 123; (* Lukas Lang's suggestion *)
With[{context = Context[]},
 Manipulate[x + y, {y, 0, 1},
  Initialization :> (CurrentValue[EvaluationCell[], CellContext] = 
     context
    )
  ]
 ]
End[];

Answer 3

Manipulate is a Dynamics module and I do not think the Context you are setting affects it.

One can see this by doing Print[Context[]]; from inside Manipulate. The context you are setting do not extend to it:

Begin["MyContext`"];
Print[Context[]]; (*this prints MyContext`*)
Manipulate[
 Print[Context[]]; (*this prints Global`*)
 x = 100;
 Print["the above x sits in context ", Context[x]]; (*this prints Global`*)
 y,
 {{y, 0, "y"}, 0, 1, .1}
 ]
End[];

But if you want to modify the x used Manipulate from outside, Why not just leave it global?

ClearAll[x, y];
Manipulate[
 Grid[{{"x", x}, {"x+y", x + y}}, Frame -> All],
 {{y, 0, "y"}, 0, 1, .1},
 TrackedSymbols :> {x, y}
 ]

And now from outside Manipulate you can do x = 99; and Manipulate will update.

btw, I would not do any of these things myself. You are just asking for trouble.

Better to have all the variables to be controlled inside Manipulate and not make it use Global variables to update, and use a Module inside Manipulate to protect non-controlled variable from outside. That is the standard way to use Manipulate. You can also use its Initialization section to initialize things if needed.