Is this a bug in Control[] when combined with InputField[]?

Question

So that you don't have to read all of the below, the crux of the matter was when using custom controls in Control or Manipulate, you have to use pure functions. As WReach pointed out, this is hidden in the Manipulate documentation at the end of Scope, Controls.

So defining a function like inField[x_Dynamic] below is fine, so long as it's passed to Control[] as the pure function inField[##]&.

The confusing aspect of this question was that my inField was a customized InputField. And, as pointed out by joebolte, InputField is the default fall-back position of Control if it's given a nonsensical function. It does this without any warning, making the debugging a little tricky.

---

Original Question (slightly modified to address WReach's 1st point)

Let's define a custom InputField[]

inField[Dynamic[x_]] := InputField[Dynamic[x], Expression, FieldSize -> 5]

Then use it in a Manipulate[] command

Manipulate[Table[{h, i, j, k}^n, {n, 1, 5}] // TableForm,
 {{h, 1, "hhh"}, inField},
 {{i, 1, "iii"}, inField[#] &},
 {{j, 2, "jjj"}, InputField[#, Expression, FieldSize -> 5] &}, 
 {{k, 3, "kkk"}, InputField[#, Expression, FieldSize -> 20] &},
 ControlPlacement -> Left]

Note this problem does not occur when inField[] is called by itself

but does when Control[] is used (which is implicit in the Manipulate construction)

My question is: Why does the Controler wtih inField different to inField[#]&? Is there an underlying reason or is it a bug? This behaviour occurs in Mathematica 7 and 8.

---

Edit: My motivation for wanting a custom inField is to catch and correct user inputs - more than just the validation than InputField provides. E.g.

inFieldRat[Dynamic[var_]] := Dynamic[If[TrueQ[Element[N[var] // Chop, Reals]], 
       var = Rationalize[var, .05], var = Null, var = Null]; 
       InputField[Dynamic[var], Expression, FieldSize -> 5]]

Answer 1

Try changing your definition of inField as follows:

Clear@inField
inField[x_Dynamic] := InputField[x, Expression, FieldSize -> 5]

The original definition was stripping the Dynamic wrapper from the argument, causing it to be evaluated immediately and remain constant thereafter.

I suspect that the observed behaviour differences are due to non-standard evaluation in Control (which is HoldFirst).

Responding to @Simon's Comment

My misunderstanding: I was addressing the problem where the control was not updating its value correctly, as opposed to the visual disparity.

The documentation for Manipulate states that the function must be a pure function (under Scope, Controls). The documentation for Control is silent on the matter, but presumably it is the same since Manipulate is built upon Control. Control[{h, inField}] is not a valid form. However, Mathematica is not issuing an error message in this case. Rather, it is simply ignoring inField altogether and acting as if Control[{h}] had been specified. I would call this a bug.

I suspect that Control demands a pure function because a symbol has ambiguous meaning. Should it use the down-values or the own-values of the symbol (or even the up-values)? WRI apparently has gone for the own-values answer. I still think a message is justified if the expression evaluates to something not understood by Control.

Answer 2

Just an observation

Control and Manipulate are masking whatever happens inside InputField, syntax errors included.

Try this nonsensical construct:

Control[{h, InputField[1, 1, 1, 1, pp -> 1, , FieldSize -> MyError]}]

Answer 3

Your example is somewhat confused because InputField is what Control returns when the domain doesn't evaluate to anything sensible. Consider Control[{h, z}] (where z is undefined) as an even more striking version of belisarius's example.

inField2 = Function[{x}, InputField[x, Expression, FieldSize -> 5]]

works correctly, though if you just want to set the size of the input field, I recommend

Manipulate[x, {{x, 5, "x"}, InputField, FieldSize -> 5} ]

Edit: If you want a Manipulate that can dynamically reset its own variables, as your edit indicates, I recommend something like

Manipulate[ If[x < 5, x = 5]; x, {x, 0, 10, InputField} ]