Implementing a safe ValueQ that does not evaluate its argument

Question

Mathematica has a built-in function ValueQ. Quoting the docs,

ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise.

...

ValueQ gives False only if expr would not change if it were to be entered as Mathematica input.

This works nicely with symbols that only have OwnValues:

x = Print["boo!"]
ValueQ[x]
(* ==> True *)

It doesn't work so nicely with functions, though:

f[x_] := Print[x]
ValueQ[f[1]]
(*
     1
 ==> True
*)

This gives True, but also evaluates f[1] completely, printing 1. This is clearly dangerous, and it is important to be aware of this. Unfortunately, the docs make no mention of this under the "Possible Issues" section!

Why this happens is clear if we look at the implementation of ValueQ for non-symbols:

ValueQ[expr_] := ! Hold[Evaluate[expr]] === Hold[expr]

Question: Is it possible to implement a more robust version of ValueQ, which does not evaluate its argument in an unexpected an possibly dangerous way?

Answer 1

Preamble

This has been discussed before, and this problem was also identified and partially addressed in the same question. I will use a slightly simpler implementation which also covers UpValues. It is probably not complete either, but it covers many common cases of interest.

Implementation

Here is the code:

ClearAll[symbolicHead];
SetAttributes[symbolicHead, HoldAllComplete];
symbolicHead[f_Symbol[___]] := f;
symbolicHead[f_[___]] := symbolicHead[f];
symbolicHead[f_] := Head[Unevaluated[f]];

ClearAll[valueQ];
SetAttributes[valueQ, HoldAllComplete];
valueQ[a_Symbol] /; OwnValues[a] =!= {} :=
    With[{result = (# =!= (# /. OwnValues[a])) &[HoldComplete[a]]},
       result /; result];

valueQ[a : f_Symbol[___]] /; DownValues[f] =!= {} :=
    With[{result = (# =!= (# /. DownValues[f])) &@HoldComplete[a]},
       result /; result];

valueQ[a_] :=
    With[{sub = SubValues[Evaluate[symbolicHead[a]]]},
      With[{result  = (# =!= (# /. sub)) &[HoldComplete[a]]},
          result /; result] /; sub =!= {}
    ];

valueQ[a_] :=
   With[{upsyms  =
       Flatten@Cases[Unevaluated[a], s_Symbol :> UpValues[s], 1, Heads -> True]},
          With[{result  = (# =!= (# /. upsyms)) &[HoldComplete[a]]},
             result /; result] /; upsyms =!= {}
   ];

valueQ[_] := False;

Symbolic heads are further discussed in this answer. The order of definitions is important, and roughly corresponds to the order of steps applying those global rules, in the main evaluation sequence.

Examples

a := Print["*"];
b[1] := Print["*"];
c[1][4] := Print["*"];
d /: f[x_Integer, d, y_Integer] := Print["*"];

valueQ /@ Unevaluated[{a, b[1], c[1][4], f[1, d, 2]}]

(*
  ==> {True, True, True, True}
*)

Limitations

I did not include the NValues (this can be done, but the question is whether we really want to do that). This seems to pretty much exhaust the set of things we can do without really evaluating an expression in question. In certain cases, the results will be different from ValueQ, for example:

{valueQ[N[Pi]],ValueQ[N[Pi]]}

(*
  ==> {False,True}
*)

Summary

The code above was not meant to be absolutely complete, and probably can not be, since not everything is exposed to the top-level / end user. But it is hoped that it covers many cases of interest, and can be further extended to cover some that it misses currently. Note that, since internal global rules are not available at the top-level, valueQ is mostly limited to user-defined or top-level functions and variables. If one wants to include system symbols with internal rules, I don't see other ways than allowing the expression to evaluate.

This may also explain (to some extent), why built-in ValueQ was written the way it was - to also cover the system symbols and be general. On a deeper level, this seems to reflect that the separation between internal and top-level rules is rather artificial and sometimes flies in the face of the core language semantics, particularly when one wants to write some general functions related to introspection, such as ValueQ.

Answer 2

Using the core of my new step function:

SetAttributes[valueQ1, HoldAll]

valueQ1[expr_] :=
 Module[{P, R = False},
   P = (P = Return[R = True, TraceScan] &) &;
   TraceScan[P, expr, TraceDepth -> 1];
   R 
 ]

SetAttributes[valueQ2, HoldAll]

valueQ2[expr_] :=
 Module[{P, R = False},
   P = (P = Return[R = True, TraceScan] &) &;
   TraceScan[P, expr];
   R 
 ]

SetAttributes[valueQ3, HoldAll]

valueQ3[expr_] :=
  Block[{Print},
    TraceScan[
      Null &, expr, _,
      If[# =!= HoldForm[#2], Return[True, TraceScan]] &
    ] // TrueQ
  ]

---

Long overdue update.

valueQ1 is my proposal for an alternative to ValueQ which leaks far less often. In most cases it returns the same answer that ValueQ does. It gives True if the entire expression is transformed in the course of evaluation.

valueQ2 is a trigger-happy version of Q1 that returns True if any evaluation takes place for the given expression. Leonid favors this one as being the most "pure" within Mathematica's framework, but it also makes for a lot of (arguably) false-positives.

valueQ3 is an attempt to get behavior closer to ValueQ (than Q1), and no leaks, but it may not be robust. The purpose of Blocking Print is NOT to hide the leaks (i below is used to check this), but a work-around because Print caused the method to fail; it is unknown to me what other function calls would also cause failure.

Here is a table of results for these functions compared to ValueQ:

ClearAll[a, b, c, d, f, g, gg, x];
i = 0;
a := Print["*a"];
b[1] := (i++; Print["*b"])
c[1][4] := (i++; Print["*c"])
d /: f[x_Integer, d, y_Integer] := (i++; Print["*d"])
gg[x_] := (i++; Print["*gg"]; False)
g[x_] /; gg[x] := x^2
x = 1;

Results in red are tests that leaked.