How can I allow a user to input a list using parentheses and convert this to Mathematica notation dynamically?

Question

I have the following dynamic module. It works. The problem is that whenever I try to make the variable list or the variable s dynamic the code doesn't work.

My goal is to allow students to enter a list of points using familiar mathematical notation. That is, user inputs "(4, 5), (9, 0)" and this gets converted to

{{4, 5}, {9,0}}

Suggestions would be greatly appreciated. I can not for the life of me figure this out.

DynamicModule[{list = "((5, 6), (9, 0))", s},
   Panel[
    Column[
      {
       Labeled[InputField[Dynamic[list], String, FieldSize -> {50, 5}],StringForm["Data Points"], Left],
       s = ToExpression[StringReplace[list, {"(" -> "{", ")" -> "}"}] ],
       ListPlot[s]
      }
     ]
   ]
 ]

Answer 1

Here is a simple fix for your problem.

 DynamicModule[{list = "((5, 6), (9, 0))", s}, Panel[Column[{

  InputField[Dynamic[list], String, FieldSize -> {50, 5}], 
  Dynamic[s = ToExpression[StringReplace[list, {"(" -> "{", ")" -> "}"}]]], 
  Dynamic[ListPlot[s, PlotStyle -> PointSize[0.05]]]

  }]]]

When using Dynamic[expression] I would suggest thinking of it as a message to the front-end saying: "Hey, rather then just showing expression, could you keep it updated if something changes?". You can't just wrap Dynamic around every variable and expect expressions down the line to also be Dynamic. And as I stated in a comment, using operations on a Dynamic wrapped object won't give you the dynamic result of that operation on the variable.

This of course seems to clash with every built-in function that accepts dynamic arguments, for instance Slider[Dynamic[a]]. Since that returns a dynamic slider, you wold think that your function f[a_,b_]:=a+b would return a dynamicly updated value if you just ran: f[Dynamic[v1], Dynamic[v2]]. What instead happens is that the dynamic wrappers prevent evaluation of the sum. The imporant point to remember here is that functions like Slider work because they expect a dynamic input, and can rewrap the dynamic around their controlls so it still ends up in the right place. For this example, you would have needed to express how f should handle a dynamic, and could have used: f[Dynamic[a_], Dynamic[b_]] := Dynamic[a + b], which would then work in the way expected above.