Out of curiosity, are there any languages that let you tag a function with an attribute that indicates that it may only be called from a single call-site, such that if any code tries to call the function from a second call site, the second call-site is flagged as a compile-time error?

For example (pseudocode):

unique_call_site void myFunction(int a, int b, int c) {...}


myFunction(1, 2, 3);  // ok
myFunction(1, 2, 3);  // error -- second call site not allowed!

Motivation for the question: it's sometimes desirable to break functionality out of a function and into its own separate sub-function (if only to keep the original function from getting too large and complicated), but once you do that, then anyone examining the sub-function now has to consider all the different calling-contexts that the sub-function might possibly be called from, and that consideration re-introduces a bit of complexity. Having the sub-function tagged with a keyword that indicates that it can be called from only a single context (and having the compiler enforce that property) would allow the reader to know right away that they only need to consider that single calling-context when studying how the sub-function might be used.

| improve this question | | | | |
  • 2
    Would you not be calling that function several times from test code? If its complex enough to break off, then its complex enough to warrant individually unit testing it. – Kain0_0 Mar 14 '19 at 5:08
  • 3
    FWIW, C++ classes have a "friend" mechanism, and C# an "InternalsVisibleTo", which work both at the granularity of classes, not functions (but these can be utilized to accomplish what you are asking for). However, list-of-things questions are not welcome here . – Doc Brown Mar 14 '19 at 5:21
  • Javascript Function.caller (non-standard) would let you get close to what you describe. It would be a run-time error, not compile time. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… I don't think it's a practical answer and would NOT recommend using it. – joshp Mar 14 '19 at 6:51
  • 1
    to avoid closing this question as beeing to broad: can you add a specific language so we can discuss here how this language handles this? – k3b Mar 14 '19 at 9:55
  • 1
    Rust has this in the std::ops::FnOnce trait – Alexander - Reinstate Monica Sep 22 '19 at 1:11

Not that I am aware of, but many languages allow something like this:

void SomeFunction() {
  void InnerFunction(int a, int b, int c) {
    // do stuff!

  // blah blah

// some other context
InnerFunction(1,2,3); // error!

Which allows you to limit the scope of your sub-functions to the single place they're used.

I personally don't care for this syntax since it hinders testability, adds complexity to the language (parser, name resolution, tooling to name a few), and doesn't provide a whole lot of readability benefit over a more general feature (like simple private functions). If you need to know how often something is used, something like CodeLens does that better without modifying the language. YMMV.

| improve this answer | | | | |
  • 1
    A different way to achieve that, also supported in many languages, is storing a lambda and calling it a bit later. – Deduplicator Mar 15 '19 at 1:29

Many OO languages support private methods/functions, that are located within a class, and can only be called from within that class.
You can simply make a small class that conatins only your private method and the method that is allowed to call it.

| improve this answer | | | | |
  • This does not do what the question asks for. The 'unique' method could still be called multiple times by the containing small class. – Graham Mar 15 '19 at 16:50
  • @Graham - if the class cannot be extended, then only if someone edits the class to do so. At which point they could also just delete whatever protection specifier was being used, make the private function public, etc... – Chris Stratton Mar 18 '19 at 2:53

Not the answer you're looking for? Browse other questions tagged or ask your own question.