Manipulating unevaluated expressions in nested function calls

Question

This is a follow-up to my earlier question: Passing an unevaluated part of an association to a function

I'm trying to create a modular dashboard that controls sound volume of an audio system consisting of several speakers.

System settings are given by the following association:

speakers = <|
    "speaker1" -> <|"volume" -> 0.5|>, 
    "speaker2" -> <|"volume" -> 0.7|>
|>

I have a simple widget AdjustOneSpeaker that takes in a part of the speakers variable corresponding to one of the speakers, and dynamically adjusts its volume using a slider:

SetAttributes[AdjustOneSpeaker, HoldAll];

AdjustOneSpeaker[speaker_] := {
   Slider[Dynamic[speaker["volume"]]], 
   Dynamic[speaker["volume"]]
};

Passing speakers["speaker1"] to this widget works fine:

AdjustOneSpeaker[speakers["speaker1"]]

To use AdjustOneSpeaker function as a building block for a composite dashboard, I must be able to map it over the speakers association (i.e. over all speakers):

SetAttributes[AdjustAllSpeakers, HoldAll];

AdjustAllSpeakers[speakers_] := AdjustOneSpeaker /@ speakers // Values;

Unfortunately, this operation forces an evaluation of the individual parts of speakers before they are passed to AdjustOneSpeaker, making it impossible for the slider to set the volume fields of the global speakers association (since its argument is no longer a reference to the global field, but an association literal):

AdjustAllSpeakers[speakers]

Association::setps: <|volume->0.5|> in the part assignment is not a symbol. >>

Is there a way to pass an unevaluated part of an unevaluated speakers association to AdjustOneSpeaker here?

Answer 1

Although I urge you to consider a method like the one below as I think it will ultimately make your coding experience easier, for the specific example in hand you can prevent the unwanted evaluation by writing speakers inside AdjustOneSpeaker where it is held (by HoldAll). Note also that you need to map over the Keys of the association, not its values.

AdjustOneSpeaker[speakers@#] & /@ Keys[speakers] // Grid

Conceptual handling of active expressions

In my opinion you should try to avoid passing around expressions like speakers["speaker1"] for the very reason of the evaluation that brought about your question. This is similar to defining functions/procedures like doSometing := Print[foo] whereas I always write doSomething[] := Print[foo] instead as the latter lets me pass doSometing around without fear of evaluation.

In your application you might define a new head like so:

SetAttributes[ascSpec, HoldFirst];
ascSpec[asc__][part__] := ascSpec[asc, part]

Now you can map it onto the Keys of speakers without unwanted action:

ascSpec[speakers] /@ Keys[speakers]

{ascSpec[speakers, "speaker1"], ascSpec[speakers, "speaker2"]}

You would then define your slider maker to handle this container:

SetAttributes[adjust1, HoldAll];

adjust1[ascSpec[asc_, parts___] | asc_] :=
  {Slider[Dynamic[asc[parts, "volume"]]],  Dynamic[asc[parts, "volume"]]};

adjust1 /@ {ascSpec[speakers, "speaker1"], ascSpec[speakers, "speaker2"]} // Grid

Playing with Unevaluated

As an example of the kind of gymnastics the method above is intended to avoid here is an example of trying to solve the problem by way of Unevaluated. Admittedly I am not giving this my best effort and there may be a cleaner form but I am also not making this intentionally baroque. I'll show the process step by step so you can watch the transformation:

Keys[speakers]
Hold @@ %
Unevaluated[speakers] /@ %
AdjustOneSpeaker /@ %
List @@ % // Grid

{"speaker1", "speaker2"}

Hold["speaker1", "speaker2"]

Hold[speakers["speaker1"], speakers["speaker2"]]

Hold[AdjustOneSpeaker[speakers["speaker1"]], AdjustOneSpeaker[speakers["speaker2"]]]