MathGroup Archive 1999

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Standard Evaluation with UpValues

  • To: mathgroup at
  • Subject: [mg19405] Re: [mg19355] Standard Evaluation with UpValues
  • From: "Andrzej Kozlowski" <andrzej at>
  • Date: Mon, 23 Aug 1999 13:57:17 -0400
  • Sender: owner-wri-mathgroup at

It seems to me that the problem with your example is that g does not hold 
its arguments so they are evaluated before naything else is done. When this
happens naturally the DownValue for f is used. To see this just give g the
HoldAll attribute:

ClearAll[f, g, t];

f[x_?NumericQ] := 1 + x;

f /: g[f[x_]] := x + 4;

SetAttributes[g, HoldAll]

4 + E

which agrees with Wagner's book.
Andrzej Kozlowski
Toyama International University

>From: "Ersek, Ted R" <ErsekTR at>
To: mathgroup at
>To: mathgroup at
>Subject: [mg19405] [mg19355] Standard Evaluation with UpValues
>Date: Sat, Aug 21, 1999, 4:09 AM

> 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

  • Prev by Date: RE:Any examples of FEA in Mathematica?
  • Next by Date: Re: Simulation
  • Previous by thread: Re: Standard Evaluation with UpValues
  • Next by thread: Re: Standard Evaluation with UpValues