DynamicModule with intermediate expressions

Question

I am trying to generalize a Manipulate construct into a DynamicModule one to try and include smoother controls, but I seem to be running afoul of Dynamic's compartmentalization of my intermediate variables inside what used to be a Module.

More specifically, I used to have a construct of the form

Manipulate[
 Module[{y},
  y = f[x];
  {x, g[y]}
  ]
 , {x, 0, 1}]

including (a large number of) intermediate expressions like y=f[x], and which produced output like

I now want to move control of the variable x into the Module - essentially, into a LocatorPane command - but I don't know what the correct translation of the code above should be. My naive attempt is to so something like

DynamicModule[{x, y},
 y = f[x];
 {Slider[Dynamic[x]], Dynamic[x], Dynamic[g[y]]}
 ]

and this produces no errors but the output inside g fails to update:

What is the correct generalization of the Manipulate[Module[ ... ] ] combination? I have tried inserting Dynamic commands in all possible combinations but I cannot seem to get them right. I know the answer is probably fairly basic, but I'm also a bit lost in the maze of tutorials for these commands.

Obviously, simply doing {Slider[Dynamic[x]], Dynamic[x], Dynamic[f[g[y]]]} is not an option in my case. The intermediate calculations f[x] are quite a few and very verbose, and the 'displayable' function g[y] is actually several rather long and slow plotting commands. I need to do the central bit of the computation only once, and I do not want to repeat myself in giving it to the plotting commands.

What am I missing here? It feels very basic but I can't seem to get it right.

Answer 1

To mimic Manipulate, wrap the body in Dynamic:

DynamicModule[{x, y},
 Dynamic[
  y = f[x];
  {Slider[Dynamic[x]], Dynamic[x], Dynamic[g[y]]}]
 ]

(It's what Manipulate does.)

But putting the y code inside its own Dynamic is a little cleaner:

DynamicModule[{x, y},
 {Slider[Dynamic[x]],
  Dynamic[x],
  Dynamic[y = f[x]; Dynamic[g[y]]]}
 ]

Answer 2

You should do something like:

DynamicModule[{x, y},
  {Slider[Dynamic[x]], Dynamic[x], Dynamic[g[y]]}
  , 
 Initialization :> (y = f[x];)]

for full control I would avoid using Manipulate. When you don't know what's going on, use Print for example. Let's focus on your Manipulate code:

Manipulate[Module[{y}, Print[1]; y = f[x];
  {x, g[y]}], {x, 0, 1}]

If you move the slider you are flooded by print. Now you know that your example works because definition of y is reevaluated at each update.