When should I, and when should I not, set the HoldAll attribute on a function I define?

Question

I have seen a number of examples on this site (such as in syntax highlighting and checking evaluation status) in which functions definitions are preceded with

SetAttributes[f, HoldAll]

without comment, and even though it seems unnecessary for the specific task at hand. This leads me to believe that at least in some cases it is simply good practice to do so. Is that the case? If so, why? Are there instances in which it would not be the best practice?

My understanding of the situation is that if, for example, I have x=5 and then pass 1+x to my function f, the argument as seen internally by f will still be represented as 1+x instead of 6. But it seems to me that in most cases if this were true I'd simply want to Evaluate[1+x] before proceeding. This would lead me to conclude that setting HoldAll would be the exception, not the rule.

Update:

My question is not whether the two examples I provided actually require HoldAll to work, but rather

How do I determine, when writing a new function, whether or not to set HoldAll on it?

What I am concerned about is the possibility of creating a function which behaves as desired without the HoldAll setting (or with it, for that matter) for the test cases I throw at it, but which misbehaves later if something else gets passed to it. What possibilities and issues must I consider to ensure I make the correct choice? What are explicit use cases for each of the two options?

Answer 1

The way Mathematica works is that when it encounters a function with arguments it will try to evaluate the arguments first before proceeding to evaluate the function. This behavior can be modified by specifying the various HoldAll, HoldFirst, HoldRest, etc. attributes for a given function.

So in your example f[x+1] will be immediately replaced by f[6] internally.

To answer your question: You need HoldAll or one of it's siblings if you construct functions that need to know the actual parameters with which the function was called. For example, I sometimes need to make file names using ToString on variables that the function is called with regardless of whether those variables evaluate to something.

In general HoldAllis not necessary if you just do arithemtic functions or other simple data manipulating functions. Once you start getting more into the swing of functional programming style of MMA you'll soon realize when and where you need arguments to stay unevaluated.

In the cases you mentioned it becomes obvious why you would want to specify HoldAll. In, e.g., the "checking evaluation" case you want the code argument to only be evaluated once you are inside the Block, not immediately when Mathematica encounters the function that specifies the Block.

The case in the syntax highlighting question is similar; the list of vars you supply should be passed as is to the Block, or the function will not work if the vars evaluate to something that does not make sense within the Block (numerical values in this case):

Answer 2

The Hold functions enable Mathematica's version of what some other languages call "macros." You can use them for a lot of things, but the essential point is that they preserve the structure of the input. The built-in functions are full of examples:

x = 7;
Plot[x^2, {x, -2, 2}]

Type this in and you'll see that Plot draws the parabola even though "x" was assigned to previously. That's because by Holding the input, the Plot function is able to interpret what actually matters, which is the structure of the function that you are plotting. What the independent variable is called doesn't really matter in this case.

An example of what a simple macro would look like is this, where we convert plus to times:

SetAttributes[f, HoldFirst];
f[expr_] := (expr // Hold) /. Plus -> Times // ReleaseHold;

f[6 + 2]

12

Macros also give you the ultimate power when it comes to abstracting code. As a rule you will rarely need macros, especially in a language like Mathematica which is dynamic and functional, but sometimes macros are the cleanest way.