How to inherit options by scoping?

Question

Consider the following example: you have a function framed producing a cell with a button that, when pushed, calls framed again. How to supply options to framed such that whenever the button is pushed, the "embedded" framed inherits these options? If, however, the framed is called not by the button, it should use the default options (as it cannot inherit it from a parent).

The following example works as expected (any new cell will inherit a -> 1111:

Options[framed] = {a -> 1};
Options[button] = {"framedOptions" -> Options@framed};
button[x_, opts : OptionsPattern[]] := 
  Button[x, Print@framed[x, OptionValue@"framedOptions"]];
framed[x_, opts : OptionsPattern[]] := 
  Framed[{button[x, "framedOptions" -> Flatten@{opts}], OptionValue@a}];

Print@framed["Push", a -> 1111];

Pushing the displayed button yields a second cell with inherited options:

But for certain reasons I want to avoid unnecessary options like "framedOptions" and use some kind of scoping as there could be multiple embeddings and recursion and I don't want to forward "framedOptions" all the time. No scoping would work however, as the button funcion is only evaluated at runtime.

Options[framed] = {a -> 1};
button[x_] := Button[x, Print@framed@x];
framed[x_, opts : OptionsPattern[]] := Framed[
   Internal`InheritedBlock[{framed = framed},
    SetOptions[framed, Flatten@{opts}];
    {button@x, OptionValue@a}
    ]];

Print@framed["Push", a -> 1111];

Note that the problem extends to attributes or any part of a function definition. What I would really need is an InheritedDynamicBlock (nonexistent) that not justs inherits the function definition but also keeps it local to a certain part of the screen (where the original content is displayed). Any idea?

Answer 1

How about this:

ClearAll[framed, button, $opts];
    $opts = {};
Options[framed] = {a -> 1};
button[x_] :=
  With[{opts = $opts},
    Button[x, Print@framed[x, opts]]];

framed[x_, opts : OptionsPattern[]] :=
  Block[{$opts = Flatten[{opts}]},
    Framed[{button[x], OptionValue@a}]
  ];

and you use this as before:

Print@framed["Push", a -> 1111]

The scheme here is that we use Block (dynamic scoping), to affect the way the button function is constructed, at run-time, when framed is called. So, the code of button gets those options embedded when framed is called, and passes those options further when the button is pressed. I don't see a way to avoid such a mix of lexical and dynamic scoping altogether, in this specific case.

EDIT

You can also hide the global $opts somewhat, and make the code better structured (particularly if, as you mentioned, functions button anf framed can live in different packages), by having a separate package looking something like

BeginPackage["Bindings`"]

LexicallyBound::usage = "LexicallyBound[var_Symbol][code] lexically binds the variable var in code, to an existing at the time of the call dynamic binding";

DynamicallyBound::usage = "DynamicallyBound[arg][code] executes code with a dynamic binding to the value of arg";

Begin["`Private`"]

$opts = {};

LexicallyBound[var_Symbol] := 
    Function[code, With @@ Hold[{var = $opts}, code], HoldAll];

DynamicallyBound[arg_] :=
    Function[code, Block[{$opts = arg}, code], HoldAll];

End[]
EndPackage[]

and now, you import this package in both of your packages, and define:

ClearAll[framed];
Options[framed] = {a -> 1};
framed[x_, opts : OptionsPattern[]] := 
   DynamicallyBound[Flatten[{opts}]][Framed[{button[x], OptionValue@a}]];

in one package, and

button[x_] := LexicallyBound[opts][Button[x, Print@framed[x, opts]]];

in another one.

Note that with this method, you can only use a single binding, at any time. It can be extended to become "binding objects", so that you could create many independent bindings. I can provide more details on this upon request.