Is there a well-known name for this?

[ewx]

From time to time I and colleagues find ourselves extending some function in C in a way that requires extra arguments. Often this happens in a context where it's impractical to change all the callers (for instance, because some of them are in customer code) so the extended version of the function gets a new name and the original name just calls that with some default value of the new arguments.

For instance I might go from this:

int refine_glorp(glorp *g) {
  /* refinement */
}

…to this:

int refine_glorp(glorp *g) {
  return refine_glorp_ex(g, 0);
}

int refine_glorp_ex(glorp *g, int arg) {
  /* extended refinement, based on arg */
}

Is there a well-known name for this transformation?

A colleague who did this a week or so ago started out with 'decapitation' but changed his mind to 'recapitation' on the grounds that he was really adding a second head to the function rather than removing one. But neither of us knew if there was already a name for this.

Comments

[ewx.livejournal.com]

I'm not looking for a name for "new function with an extra int argument and the old one becomes a wrapper", I'm looking for a name for "new function with an extra argument and the old one becomes a wrapper".
Indeed most of the examples in our code use an indefinitely extensible approach.

[gareth-rees.livejournal.com]

That's the thing about using made-up examples — it's hard to know which features are salient and which are accidental.

The Windows API suffers from this anti-pattern: a typical example is VirtualAllocExNuma (https://msdn.microsoft.com/en-us/library/windows/desktop/aa366891.aspx), which adds a node argument to VirtualAllocEx (https://msdn.microsoft.com/en-us/library/windows/desktop/aa366890.aspx), which adds a process argument to VirtualAlloc (https://msdn.microsoft.com/en-us/library/windows/desktop/aa366887.aspx). You'd think that when they came to extend it a second time they would have recognized the anti-pattern.