How to evaluate `Dynamic` expression?

Question

I am trying to work my way through Dynamic but there is something I dont get and I would appreciate very much some clarification. Consider the following code

Manipulate[
 var1 = Dynamic@par1;
 im1 = Graphics[Circle[], Axes -> True];
 locd = Dynamic[locator];
 pointOK = Dynamic[locator + {-1, 1}];
 pointWRONG = locd + {-1, 1};
 Grid[{
   {"[1.1]", par1 + 2}
   , {"[1.2]", var1 + 2}
   , {"[1.3]", Evaluate[var1 + 2]}
   , {"[1.4]", ReleaseHold[var1 + 2]}
   , {"[2.1]", LocatorPane[locd, im1]}
   , {"[2.2]", locd}
   , {"[2.3]", pointOK}
   , {"[2.4]", pointWRONG}
   , {"[2.5]", Graphics[{
      PointSize -> Large
      , Blue, Point@pointOK
      , Red, Point@pointWRONG
      }, PlotRange -> 2, Axes -> True]}
   }
  , Alignment -> Left
  ]
 , {par1, 0, 1}
 , {{locator, {0, 0}}, None}
 ]

For different reasons I would like to have a manipulable parameter par1 and perform some alebraic operations on variables defined on it, like in [1.1] in the picture above. But, if, just out of fun, I declare a symbol var1 = Dynamic@par1 and try to perform some algebra on it, like in [1.2], it does not get evaluated. I read that Dynamic has HoldFirst and I thought that Evaluate would help me, as I tried in [1.3], but without luck. The same for ReleaseHOld, [1.4].

The weird thing for me is now that Point (and surely other functions) is able to evaluate this kind of expressions. Consider the Locator in [2.1] based on the locator control and the symbol locd = Dynamic[locator] now. If I want to some algebra on the momentary values of locator, I have to do it like in the symbol pointOK, [2.3], and NOT as in symbol pointWRONG, [2.4], since the Dynamic object is "added" to each element of the list {-1,1}. Nevertheless, in the last graphic, Point is able to process pointWRONG, otherwise you would not see the 2 red points.

So, what property has Point or what do I need to evaluate expressions containing Dynamic objects (such that, e.g., I get the same in [1.1] and [1.2])? Thank you!

EDIT: Compared to the question Programming with Dynamic, I think this question deals more with the question on how to evaluate an expression containing a Dynamic object (if Dynamic could not be evaluated numerically, then Point would not be able to display anything, but you can see the points in my plot). In Programming with Dynamic I had the feeling that it was important to understand that the head of Dynamic[x] is Dynamic. But some evaluation has to be possible even if objects like Integer and Dynamic, again, otherwise Graphics@Point@pointWRONG would not work.

Answer 1

If for some reason you need to have a dynamic object that does some calculations, and what you want is to get to the value of the actual expression defined as a function of a dynamically changing parameter (par1 in your case), than you can simply do that by extracting that expression from a variable defined with the Dynamic head.

var1 = Dynamic[par1 + 1];
Slider[Dynamic@par1, {0, 10, 1}]
Dynamic[var1 + 3]
Dynamic[var1[[1]] + 3]

The first object is not evaluated (it still has a Dynamic head, so it can't be added to the value of 3, but notice that 1 was added to par1 inside Dynamic when it was pushed to the FE, so it is displayed as 2), but the second one is evaluated once we remove the Dynamic wrapper.

In addition, as Kuba suggested, an alternative to Partis Setting. Both extract the first argument, which is important if the Dynamichas multiple arguments, since the expression you are interested in is in the first one.