Is there a commonly accepted name for functions that are only called in one other function?

Question

Is there a name that is commonly used for functions that are only called in one other function?

(I'm not asking whether it's a good practice; I believe it can improve readability in some cases.)

Right now I'm commenting them as "local shorthand functions", but I'd like a more standardized name, if available.

Example:

function foo(){
  bar(x)
  bar(y)
  bar(z)
}

function bar(){
  ... // bar definition
}

bar() only being used, one to N times, in another single function foo().

Answer 1

I would call it one of the following:

• Helper Function
  • if it was some sort of small detail, like formatting a string correctly
• The "bulk functionality"
  • if it was the bigger detail, like a search algorithm
• Inner Function
  • If the definition was inside the other
• Another function
  • Because that's what it is

I know some people who may say you are "delegating", but that can cause ambiguity due to the word already being used, as in the case of C# delegates. I'd personally stick with helper function.

That being said, this is essentially just an ordinary method, so do you really need to make the distinction? There's absolutely nothing wrong with abstracting out a method for a single use, in fact it's a good idea as you said! Just keep in mind you can't truly guarantee that a function will only ever be called in one place. One day that may not be true, code changes.

Answer 2

You're asking the wrong question.

Just as touching the ball only once when passing is the high art of soccer, storing each bit of information exactly once is the basic principle of good data representation... and performing every task only in one place is the high art of maintainable software. This means that writing a method that is called only in one other place should be the normal case.

To be sure, there is a place for methods that are called all over the place. For instance, a string-trimming method has many uses, and it makes sense to define it once and call it often. They're called utility methods.

But that is a special kind of method. The majority of methods should be dedicated one-purpose methods, and they shouldn't have a special name, because they're the normal kind of methods.