So Mathematica is different from other dialects of lisp because it blurs the lines between functions and macros. In Mathematica if a user wanted to write a mathematical function they would likely use pattern matching like `f[x_]:= x*x` instead of `f=Function[{x},x*x]` though both would return the same result when called with `f[x]`. My understanding is that the first approach is something equivalent to a lisp macro and in my experience is favored because of the more concise syntax.

So I have two questions, is there a performance difference between executing functions versus the pattern matching/macro approach? Though part of me wouldn't be surprised if functions were actually transformed into some version of macros to allow features like `Listable` to be implemented. 

The reason I care about this question is because of the recent set of questions [(1)](https://stackoverflow.com/questions/4174791/preventing-avalanche-of-runtime-errors-in-mathematica) [(2)](https://stackoverflow.com/questions/4176612/setting-up-diagnostic-error-messages-in-large-mathematica-projects) about trying to catch Mathematica errors in large programs. If most of the computations were defined in terms of Functions, it seems to me that keeping track of the order of evaluation and where the error originated would be easier than trying to catch the error after the input has been rewritten by the successive application of macros/patterns.