Standard Evaluation with UpValues

• To: mathgroup at smc.vnet.net
• Subject: [mg19355] Standard Evaluation with UpValues
• From: "Ersek, Ted R" <ErsekTR at navair.navy.mil>
• Date: Fri, 20 Aug 1999 23:09:35 -0400
• Sender: owner-wri-mathgroup at wolfram.com

```Section 7.1.3 of the excellent book "Power Programming With Mathematica The
Kernel" by David B. Wagner explains the main evaluation loop.  In that
Section it indicates UpValues for a symbol are applied before DownValues for
the symbol are applied.

OK then consider the case below where (f) has both an UpValue and a
DownValue defined by the user.

At Out[4] the UpValue for (f) was used.  In that case the DownValue couldn't
be used to evaluate f[t].
Then at Out[5] the DownValue for (f) is used to evaluate  f[E] --> 1+E
before the kernel checked to see if the UpValue would apply (and it would
have).  I get the same result using Versions 3 and 4.

When the kernel evaluates g[f[E]] it must figure out that the Head is (g)
before it evaluates f[E].  After determining that the Head is (g) it checks
to see if (g) has any Hold* attributes, and continues with evaluation as
required.  So by the time the kernel evaluates f[E] it has all the
information it needs to know that the UpValue for (f) can be used.  However,
the DownValue is used instead.  Wait a minute, aren't UpValues applied
before DownValues are applied?

Can someone convince me that the main evaluation loop performs as explained
by David Wagner when evaluating In[5] below?  Also can someone give a
different example that more clearly shows that UpValues are used first?
------------------------------

In[1]:=
ClearAll[f,g,t];
f[x_?NumericQ]:=1+x;
f/:g[f[x_]]:=x+4;

In[4]:=
g[f[t]]

Ou[4]=
4+t

In[5]:=
g[f[E]]

Out[5]=
g[1+E]

--------------------
Regards,
Ted Ersek

For Mathematica tips, tricks see
http://www.dot.net.au/~elisha/ersek/Tricks.html

```

• Prev by Date: ContourShading with ListContourPlot
• Next by Date: changing character set??