How do you return two values from a single method?

Question

When your in a situation where you need to return two things in a single method, what is the best approach?

I understand the philosophy that a method should do one t

Answer 1

I generally use tuples. I mainly work in C# and its very easy to design generic tuple constructs. I assume it would be very similar for most languages which have generics. As an aside, 1 is a terrible idea, and 3 only works when you are getting two returns that are the same type unless you work in a language where everything derives from the same basic type (i.e. object). 2 and 4 are also good choices. 2 doesn't introduce any side effects a priori, its just unwieldy.

Answer 2

1. Some languages make doing #3 native and easy. Example: Perl. "return ($a, $b);". Ditto Lisp.

2. Barring that, check if your language has a collection suited to the task, ala pair/tuple in C++

3. Barring that, create a pair/tuple class and/or collection and re-use it, especially if your language supports templating.

Answer 3

I think the most preferred approach is to build a container (may it be a class or a struct - if you don't want to create a separate class for this, struct is the way to go) that will hold all the parameters to be returned.

Answer 4

I will usually opt for approach #4 as I prefer the clarity of knowing what the function produces or calculate is it's return value (rather than byref parameters). Also, it lends to a rather "functional" style in program flow.

The disadvantage of option #4 with generic tuple classes is it isn't much better than returning a collection (the only gain is type safety).

public IList CalculateStuffCollection(int arg1, int arg2)
public Tuple<int, int> CalculateStuffType(int arg1, int arg2)

var resultCollection = CalculateStuffCollection(1,2);
var resultTuple = CalculateStuffTuple(1,2);

resultCollection[0]    // Was it index 0 or 1 I wanted? 
resultTuple.A          // Was it A or B I wanted?

I would like a language that allowed me to return an immutable tuple of named variables (similar to a dictionary, but immutable, typesafe and statically checked). But, sadly, such an option isn't available to me in the world of VB.NET, it may be elsewhere.

I dislike option #2 because it breaks that "functional" style and forces you back into a procedural world (when often I don't want to do that just to call a simple method like TryParse).

Answer 5

Not my own thoughts (Uncle Bob's):

If there's cohesion between those two variables - I've heard him say, you're missing a class where those two are fields. (He said the same thing about functions with long parameter lists.)

On the other hand, if there is no cohesion, then the function does more than one thing.

Answer 6

Haskell also allows multiple return values using built in tuples:

sumAndDifference        :: Int -> Int -> (Int, Int)
sumAndDifference x y    = (x + y, x - y)

> let (s, d) = sumAndDifference 3 5 in s * d
-16

Being a pure language, options 1 and 2 are not allowed.

Even using a state monad, the return value contains (at least conceptually) a bag of all relevant state, including any changes the function just made. It's just a fancy convention for passing that state through a sequence of operations.