# Strange results of definitions using OwnValues

I am asking this question simultatenously with this one, which is strongly related.

I was trying to see if I could create the behaviour as in that question without using Condition by setting OwnValues. I ran into the following strange behaviour.

The following gives an infinite recursion

Clear[c]
OwnValues[c] = {HoldPattern[c] -> {c}}


So does this

Clear[d]
OwnValues[d] := {HoldPattern[d] -> {d}}


But this does not

Clear[e]
OwnValues[e] := {HoldPattern[e] -> Unevaluated@{e}}


Actually this last piece evaluates to something other than Null, which is not what we expect from SetDelayed. Simpler expressions of similar form will also return something. This is what the aside here is about.

Question: Can somebody explain what is going on here? Why do these definitions cause infinite recursions?

## Aside

Tool

I have made the following tool that can show us when a particular function is being called, and with what arguments. It uses Print to display this information. Note that it is quite buggy. For now let's only use it on SetDelayed. Making both SetDelayed and Set print this way crashes the kernel I think. This is the tool.

SetAttributes[letPrint, HoldAll];
letPrint[symb_] :=
(
ClearAttributes[symb, Protected];
DownValues[symb] = {};
With[
{uq = Unique[]},
uq = False;
expr : symb[___] /; (uq = ! uq) := (Print[
Column[{uq, ToString[Unevaluated[symb]],
HoldForm@InputForm[expr]}]]; expr)
]
)


Now we can do

(*warning, overloads and Unprotects SetDelayed*)
letPrint@SetDelayed


We then have that

Clear[aaa, bbb]
aaa := bbb


Prints

True (*not really meaningful*)
SetDelayed
aaa:=bbb


but

Clear[a]
OwnValues[a] = {HoldPattern[a] :> 1};


does not print anything. My suspicion is that there is some internal code associated with OwnValues that prevents the expression with head SetDelayed from being evaluated like normal.

To restore SetDelayed, I think you can do

Clear@SetDelayed; Protect@SetDelayed


I don't think it is related to your other question.

It seems that SetDelayed applied to the XValues functions behaves like Set in the sense that it returns the stuff it has assigned instead of returning Null.

OwnValues[c] = {HoldPattern[c] -> {c}} will give an infinite recursion because it will want to return something that requires the evaluation of c, after it was assigned to {c}.

The second example is the same, due to the above mentioned peculiarity.

OwnValues[e] := {HoldPattern[e] -> Unevaluated@{e}} will not because it returs something that doesn't require the evaluation of e. And even if it did, that last assignment would replace e with Unevaluated@{e} which won't iterate again

• But why evaluation of OwnValues[e] := {HoldPattern[e] -> Unevaluated@{e}} returns something other than Null? "Usual" delayed definitions do not return anything. Jan 11, 2014 at 1:58
• @AlexeyPopkov. The behaviour of SetX for the XValues is different in more than one way, it is overloaded. For example, it checks that you are assigning valid rules. Perhaps they just forgot to return Null when they overloaded it, or perhaps there's a reason :P. It is clearly inconsistent, but it seems to be that way
– Rojo
Jan 11, 2014 at 3:34