Discussion between Mr.Wizard and Jacob

Also mathematica keeps track of all symbols in an expression, so that when a symbol gets a new rule attached to it, it can say the expression must have changed

we can see this at work in

Clear[h, somethingElse, something]
h[something, something = somethingElse]

which evaluates to h[something, somethingElse]

but

Clear[h, somethingElse, something]
Identity[h[something, something = somethingElse]]

evaluates to h[somethingElse, somethingElse]

hmm.. I still find it hard to explain. Also I hope my messages are arriving :)

Mr.Wizard

11:15 AM

They are, I merely didn't want to interrupt. Have you seen Update? I think it is at least related, in case you missed it.

Jacob Akkerboom

anyway.. to see that these updates are tied to symbols, lets use the following definition

Ah, yeah, I've looked at it once

It made me more way about some uses of Condition :)

But maybe I should look at it again (soon)

Anyway, please let me show that some tracking of changing of expressions is tied to symbols

for this purpose have the definition:
myToExpression[x_ /; IntegerQ[ToExpression[x]]] := ToExpression[x]

We then have

Clear[y]
{myToExpression["y"], y = 5}

-> {myToExpression["y"], 5}

but also

Clear[y]
With[
{expr = Identity[{myToExpression["y"], y = 5}]},
Identity[expr]
]

-> {myToExpression["y"], 5}

Mr.Wizard

let me play with that for a minute

Jacob Akkerboom

okido

Mr.Wizard

(Keep writing if you wish; I'll read it soon.)

Jacob Akkerboom

alright

By the way, please feel very free to interrupt. I can see that anytime I tell a long story uninterrupted, it ends up having gaps

Mr.Wizard

11:21 AM

OK, please continue.

Jacob Akkerboom

Again in the above the With thing is just to make it more convincing. But really Identity[{myToExpression["y"], y = 5}] evaluating to.. {myToExpression["y"], y = 5} already shows the point

Mr.Wizard

Incidentally, before you continue, have you seen Rojo's use of "guard" in Module? It's a clever leverage of this very thing I believe.

Jacob Akkerboom

Okido.. Well.. now.. symbols with HoldAllComplete shield symbols against this kind of symbol tracking.. it seems. Or it prevents the expression from having updates on its "time of last change".. or something :P. I will try to show with an expample

ah no I have not seen that

sounds interesting :)

Mr.Wizard

@JacobAkkerboom Please do; this sounds new to me.

Jacob Akkerboom

I think I learned a very nice lesson from all of this. Though I don't know if this is the smartest approach to learning :). But back to the shielding

We can set

ClearAll[myFromHeldExpression]
SetAttributes[myFromHeldExpression, HoldAllComplete];
myFromHeldExpression[x_ /; IntegerQ[x]] := x

and have

{myFromHeldExpression[z], z = 6}

-> {myFromHeldExpression[z], 6}

whereas if we had used HoldAll instead of HoldAllComplete, we would get

ClearAll[myFromHeldExpression]
SetAttributes[myFromHeldExpression, HoldAll];
myFromHeldExpression[x_ /; IntegerQ[x]] := x
{myFromHeldExpression[z], z = 6}

-> {6,6}

Mr.Wizard

11:27 AM

I see this behavior now, and no, I don't think I was aware of that.

Jacob Akkerboom

yay :)

I feel so useful

I guess I should have added in my question in the example of g I had also tried to change the value of x, but that didn't cause an "update". Example:

g[x_Symbol]:=x
x=3;
With[{expr=g[Sequence@Unevaluated@x]}
,
x=4;
Identity[expr]
]

-> g[Unevalauted[x]]

Mr.Wizard

Wait; I may have spoken too soon. :o Surely you are pushing into the corners of the Mathematica evaluator that I seldom explore. However, my first test is to simply remove that attribute, and I still get {6, 6}:

ClearAll[myFromHeldExpression]
(*SetAttributes[myFromHeldExpression,HoldAllComplete];*)
myFromHeldExpression[x_ /; IntegerQ[x]] := x
{myFromHeldExpression[z], z = 6} // Identity

Is this expected by you?

Jacob Akkerboom

Ah you also have to clear z... maybe?

woops, I forgot that mysefl

Mr.Wizard

I still get {6, 6} even if I start with Remove[myFromHeldExpression, z]

Jacob Akkerboom

Ah.. So I may have spoken too soon

Ahh no, I think I am still right :)

Mr.Wizard

11:31 AM

Defininately you should speak to Rojo about this, after searching the site for "guard," as he was also exploring these things.

@JacobAkkerboom Please continue. :-)

Jacob Akkerboom

Its always nice to talk to Rojo :)

It is expected to me that

ClearAll[myFromHeldExpression]
(*SetAttributes[myFromHeldExpression,HoldAllComplete];*)

myFromHeldExpression[x_ /; IntegerQ[x]] := x
Clear[z]
{myFromHeldExpression[z], z = 6} // Identity

-> {6,6}

As here we don't have HoldAllComplete, so that we an "update" happens and mathematica evaluates the first argument of list again

Mr.Wizard

Excuse me, I'll be back in a few minutes.

Jacob Akkerboom

ok, that's fine

I guess I'll take a peak at guard in the meantime :)

Ahh.. yeah, now that I found your answer with guard in it, I think I recall seeing this before. Anyway it is very Rojo-ish :). With a lot of Condition's and probably also transparancy of Module to Condition... I came across this when fooling around with tail recursion

Mr.Wizard

@Jacob I'm back.

Jacob Akkerboom

connection still bad. Welcome back!

wb!

Mr.Wizard

11:43 AM

@JacobAkkerboom I'm confused; I thought you were saying that the updates happen with HoldAllComplete, but not without it; now you seem to be saying the opposite.

Jacob Akkerboom

@Mr.Wizard welcome back! My connection is still bad

Oh I am sorry. No I meant to say that HoldAllComplete prevents these updates

Mr.Wizard

@JacobAkkerboom Going back to this then, there is no HoldAllComplete, and yet it does not "update" -- how does this fit in?

Jacob Akkerboom

You mean in your example with the argument HoldAllComplete commented out right?

Let assume that we used Clear[z] though

Here I consider an "update" to take place. Mathematica tracks which symbols are present, notes that z has changed and re-evaluates

Mr.Wizard

@JacobAkkerboom No, I mean the code you get to if you follow the little left-arrow next to my message (left of "@JacobAkkerboom")

Jacob Akkerboom

Ah, thats a nice trick :P

Mr.Wizard

11:49 AM

Sorry, I take certain things for granted; it must have been hard for you to follow certain chat discussions that were heavily linked!

Jacob Akkerboom

Ah... well in this case, there is no symbol present in the expression.. only the string. So mathematica also does not track the symbol and does not realise myToExpression["x"] might now evaluate to something else

Haha yeah I guess :)

Mr.Wizard

I am starting to form/refresh my own understanding of the updating evaluation, but I'd like to hear you express the rest of what you had to say without me interrupting again. I'm certainly going to be exploring this in the next few days.

@JacobAkkerboom Good point; I see that now.

Jacob Akkerboom

Haha I now enjoy following your links

Also I'm proud that you would spend time on this :)

Em.. I think I have made most of the points I had really. Let's see if there is something missing

also a warning: my battery is running low. I might suddenly leave :)

15 minutes until I reach my destination by train anyway. Though I would gladly speak more later today if there is something to say :)

Mr.Wizard

If you have time/battery: I still have trouble seeing a clear example where HoldAllComplete alone changes the update behavior. Your examples with and without the updating were different in other aspects as well. Can you isolate this?

Jacob Akkerboom

Ok. I'll try. Moment

later you will have to teach me how to link :)

Mr.Wizard

11:57 AM

@JacobAkkerboom When you mouse-over a comment you should see a little right-arrow at the bottom right corner; click that to reply to the comment.

Jacob Akkerboom

Lets have

ClearAll[myFromHeldExpression]
SetAttributes[myFromHeldExpression, HoldAllComplete];
myFromHeldExpression[x_ /; IntegerQ[x]] := x

and

ClearAll[myFromHeldExpression2]
SetAttributes[myFromHeldExpression2, HoldAll];
myFromHeldExpression2[x_ /; IntegerQ[x]] := x
{myFromHeldExpression2[z], z = 6}

Mr.Wizard

@JacobAkkerboom If I clear z as well they behave the same on my system.

Jacob Akkerboom

We have

Clear[z]
Identity[{myFromHeldExpression[z], z = 6}]

-> {myFromHeldExpression[z], z = 6}

But

Clear[z]
Identity[{myFromHeldExpression2[z], z = 6}]

-> {6,6}

But now my battery is really dead. Gotta go! Hope to catch you later!

We have

Clear[z]
Identity[{myFromHeldExpression[z], z = 6}]

-> {myFromHeldExpression[z], z = 6}

But

Clear[z]
Identity[{myFromHeldExpression2[z], z = 6}]

-> {6,6}

Mr.Wizard

Okay, good --- whatever time it is there ---, Jacob!

@JacobAkkerboom FWIW this example finally works; if I clear z along with myFromHeldExpression before the definition they behave the same.

Jacob Akkerboom

2:26 PM

@Mr.Wizard Your remark to take a look at Update was very good indeed. It seems we can speak of an Update instead of an "update" in the above ;). Also consider

gggg[y_Symbol, x_Symbol] := "yay";

Clear[y, x]
First[{gggg[Sequence[y, Unevaluated[x]]], Update[y]}]
-> "yay"

First[{gggg[Sequence[y, Unevaluated[x]]], Update[x]}]
-> gggg[y, Unevaluated[x]]

indeed MMA does not look for x inside Unevaluated :)

@Mr.Wizard I also said I learned a lot investigating these examples. The most important thing I learned is simpler than all this, so you may have seen it, but if not, it is probably nice to compare the following

Trace[{1, 2, 3}, TraceOriginal -> True]
-> {1, 2, 3}

Trace[{1, 2, oki}, TraceOriginal -> True]
-> {{1,2,oki},{List},{1},{2},{oki},{1,2,oki}}

With[
{expr = {1, 2, oki}},
Trace[expr, TraceOriginal -> True]
]

-> {{1,2,oki}}

Mathematica truly remembers what has been evaluated :). Also it does not go through expressions consisting only of basic types like List and Integer.

Transcript for

Discussion between Mr.Wizard and Jacob