Intro

A common piece of programming advice is only have a single return statement. This is sometimes called the ‘Single Return Law’. It is even codified in some coding standards such as MISRA C ^{1 2}.

The origin of this law is misunderstood. I wrote this based on my understanding but haven’t done an extensive historical investigation.

History

Single Entry, Single Exit actually predates C and originates from Structured Programming from Dijkstra. ³⁴⁵

Single Entry referred to their being only a single entrypoint to a method (recall that you can use goto to enter a method outside of its normal starting position) and Single Exit meant that you should only exit to a single location - i.e., don’t use goto to a different location in for for error handling).

Here is a pseudocode example of the types of code that was being argued against. (I don’t know the languages like Fortran where this used to be more common).

FILE* file;

int do_a_thing_with_a_file() {
  int num;
  int tmp;

  file = fopen("filename","r");
  if (!file) {
    goto file_not_open;
  }

  already_open:

  tmp = fread(&num, sizeof(int), 1, file);

  if (tmp == 0) {
    goto file_not_read;
  }

  return num;
}

More Recent

I don’t know the full history here, but I believe exceptions are actually a structured way of doing goto file_not_open; and goto file_not_read; (and relies on stack unwinding instead of goto).

C programmers then turned this into something different than what Dijkstra meant, and it primarily had to do with resource management (and what Go solves with ‘defer’ functions)

I’d argue that the “best” modern thing to do is true monadic optionals (like scala, rust, etc.) and better exemplify the ‘single exit’.

Alternatively, consider the use of ‘COMEFROM’. ⁶

More Sources

(since I can’t figure out how to get footnotes to render without citation)

^{7 8 9}

References