Subtle difference in conditional rules placement

Question

I had gotten used to thinking of the placement of a condition in a rule definition as logically immaterial. In my specific example, namely

ClearAll[f,g,h];
SetAttributes[f,HoldAllComplete];
f[x_ /; Head@Unevaluated@x === Symbol] := x;

SetAttributes[g,HoldAllComplete];
g[x_] := x /; Head@Unevaluated@x === Symbol;

SetAttributes[h,HoldAllComplete];
h[x_] /; Head@Unevaluated@x === Symbol := x;

all three produce the same results when applied to the same symbol

In[13]:= f[foo] === g[foo] === h[foo] === foo

(* Out[13]= True *)

But now I try to get fancy and write the following

ClearAll[f, g, h, foo];
SetAttributes[f,HoldAllComplete];
f[x_ /; Head@Unevaluated@x === Symbol] := Unevaluated@x;

SetAttributes[g,HoldAllComplete]
g[x_] := Unevaluated@x /; Head@Unevaluated@x === Symbol;

SetAttributes[h,HoldAllComplete]
h[x_] /; Head@Unevaluated@x === Symbol := Unevaluated@x;

In[20]:= {f[foo], g[foo], h[foo]}

and the results are very different

(* Out[20]= {foo, Unevaluated[foo], foo} *)

I try to figure it out with traceView2; I can see the differences

but I get quickly lost in the documents trying to understand what, why, and how. Seems even this example is not so simple and probes dark (at least to me) corners of the evaluator. I'd be grateful for advice, explanations, ideas.

Answer 1

This isn't a runtime issue, so you won't find the answer by tracing f[foo] and family.

It's a definition thing. If you look at the downvalues you'll see that in f as well as in h the Unevaluated got stripped off when running the SetDelayed

Let's look at the fullform of your definitions

f:

SetDelayed[
 f[Condition[Pattern[x, Blank[]], 
   SameQ[Head[Unevaluated[x]], Symbol]]],
 Unevaluated[x]]

So, Mathematica sees this code. First it evaluates SetDelayed, it is inert.

It checks its attributes: HoldAll, SequenceHold.

Now it strips off the Unevaluated of its arguments... (!!)

Evaluates the expression as a whole, and stores the definition (the Unevaluated is gone already)

g:

SetDelayed[
 g[Pattern[x, Blank[]]],
 Condition[Unevaluated[x], SameQ[Head[Unevaluated[x]], Symbol]]]

Now, in this case, no argument has head Unevaluated so it survives :)

h:

SetDelayed[
 Condition[h[Pattern[x, Blank[]]], 
  SameQ[Head[Unevaluated[x]], Symbol]], Unevaluated[x]]

Same as f, goodbye Unevaluated

Answer 2

This highlights a subtle difference in Condition expressions but at its heart I believe is the behavior of Unevaluated, not Condition.

Consider first:

List[Unevaluated[1 + 1], "foo"]

Plus[Unevaluated[1 + 1], "foo"]

{Unevaluated[1 + 1], "foo"}

2 + "foo"

Unevaluated is only stripped when Mathematica determines that further evaluation is necessary (or perhaps conversely, it remains when Mathematica does not evaluate). Consider now:

List[#, "foo"] & @ Unevaluated[1 + 1]

{2, "foo"}

Because the pure function is not HoldAllComplete an additional evaluation is triggered that does not occur when using List directly.

You can strip down your question example to this observation:

ff := Unevaluated[1 + 1]

gg := Unevaluated[1 + 1] /; True

{ff, gg}

{2, Unevaluated[1 + 1]}

Apparently the use of Condition causes Mathematica to consider that the RHS expression has already been evaluated.