Question

I have a question that I cannot answer myself, but it seems like a fundamentally good question to clear up:

Why do some languages restrict the data returned from a function to a single item?

Is this serving some benefit? Or is it a practice brought over from Maths?

An example being (in Scala):

def login(username: String, password: String): User

If I wanted to return multiple items I cannot say it in the same manner as I just did for the input arguments (now entering imaginary Scala land)

def login(username: String, password: String): (User, Context, String)

Or even with named data returned:

def login(username: String, password: String): (user: User, context: Context, serverMessage: String)

Answer 1

There is no relationship: as observed, an arbitrary number of values can be returned, even if they must be “packaged” into a single value.

Imagine a language that can only accept a single tuple and can only return a single tuple from a function (the tuples can be any size). These functions then resemble math function transforming a vector from one space to another.

However, some reasons why it might be so:

1. Most functions only return one value, which may be a collection of values (object, sequence, etc.) Decompositions of the single value is supported in a number of languages, even though “only one value is returned”.
2. The calling conventions and signatures are simpler: there is no special case/overhead to signal that n-values are being returned: there is no need to use part of the stack to return multiple values, a single register will do.
3. The need to fit in with the target architecture: earlier, especially lower-level languages, were heavily influenced by the computer architecture. In the case of Scala, for instance, it must work on the JVM.
4. It’s just how the language was designed. Many (most?) languages borrow heavily — syntax and/or methodologies — from existing languages. Sometimes this is good, sometimes it is not so good. C# appeased Java appeased C++ appeased C, for instance: it’s all about the market share.
5. It Just Works.

---

Even while “returning only one value”, programming languages already have different ways of dealing with it. As noted in the post, some languages allow decomposition (the tuple returned as “decomposed” into it’s two values during an assignment):

def multiMath (i):
  return (i + i, i * i)

double, squared = multiMath(4)
# doubled is 8
# squared is 16

Additionally, other languages like C# which lacks decomposition, allow pass-by-reference (or emulate it in with mutation of an object):

void multiMath (int a, out int doubled, out int squared) {
  doubled = a + a;
  squared = a * a;
}

int d, s;
multiMath(4, out d, out s);
// d is now 8
// s is now 16

And, of course… 😉

class ANewClassForThisFunctionsReturn {
  ...
}

There are likely more methods I am not aware of.

Happy coding.