How automatically perform an action each time a function is invoked?

Question

Please, consider these functions:

f[x_] := Module[{},
   Return[x + 1];
   ];
g[x_] := Module[{},
   Return[x - 1];
   ];

I want evaluate doSomething each time f (or g) is invoked. The obvious way

f[x_] := Module[{},
   doSomething;
   Return[x + 1];
   ];
g[x_] := Module[{},
   doSomething;
   Return[x - 1];
   ];

presents a serious drawback, because it delivers on the programmer's shoulders the responsibility to add the required command inside each function. Little it may seems, in large projects it's a major source of (my...) , hard to trace back, oversights. Leaving aside metaprogramming, is it possible escape from this boilerplate code by means of a function whenInvoked[{f,g,...} , doSomething] ?

Addendum

I'm not "looking to alter the definition of a function", let's say f, although I acknowledge that such an error can be carried out using the hypothetical function when, mentioned above. I'm looking for a practical way to log the calls to f. As I see the topic, the maintenance of the log is a task of the program that makes use of f, not of f itself, mainly because it can be accomplished in many ways. To dictate any modality to f, simply invalidate its portability.

Answer 1

Here is what you requested. The basic idea is to edit the DownValues of a function you defined. Let's define the fibbonacci function as an example:

fib[1] = 1; 
fib[2] = 2; 
fib[n_] := fib[n - 1] + fib[n - 2]

We can see what the definition of fib internally looks like by using DownValues:

DownValues[fib]

{HoldPattern[fib[1]] :> 1, 
 HoldPattern[fib[2]] :> 2, 
 HoldPattern[fib[n_]] :> fib[n - 1] + fib[n - 2]}

Let's say we want to change the function so that it prints "test" whenever it is called. We can make a function that edits the DownValues:

functionChanger[a_ :> b_] := (a :> (Print["test"]; b))

And then let's make a function that applies this to the DownValues:

changeMyFunction[myFunction_] := (DownValues[myFunction] = 
   Map[functionChanger, DownValues[myFunction]])

We can now use this on fib:

changeMyFunction[fib]

{HoldPattern[fib[1]] :> (Print["test"]; 1), 
 HoldPattern[fib[2]] :> (Print["test"]; 2), 
 HoldPattern[fib[n_]] :> (Print["test"]; fib[n - 1] + fib[n - 2])}

Now "test" will print every time that fib is called.

---

This is all an incredibly bad idea. If you decide to code like this, don't be surprised if people avoid your code.

Answer 2

You shouldn't do this. This sounds like the kind of feature that smart people who don't have experience with software engineering dream up.

But, there are ways to do this. I think maybe the most reasonable (to me) would to make a decorator (most popularly known thru python) of sorts.

We can make a higher order function that does arbitrary things to a function. For example, it could print a message before evaluating the actual function. This example creates a decorator that warns that the function is Deprecated:

deprecated[function_] := 
    Function[args, 
        Module[{}, Print["This function has been deprecated"]; 
        function[args]]
    ]

We can use this when defining a function, like test here:

test = deprecated@
   Function[x, x + 1];

Or if we want to, we could define a new function using it.