Question

I was thinking about patterns which allow me to return both computation result and status:

There are few approaches which I could think about:

• function returns computation result, status is being returned via out parameter (not all languages support out parameters and this seems wrong, since in general you don’t expect parameters to be modified).

• function returns object/pair consisting both values (downside is that you have to create artificial class just to return function result or use pair which have no semantic meaning – you know which argument is which by it’s order).

• if your status is just success/failure you can return computation value, and in case of error throw an exception (look like the best approach, but works only with success/failure scenario and shouldn’t be abused for controlling normal program flow).

• function returns value, function arguments are delegates to onSuccess/onFailure procedures.

• there is a (state-full) method class which have status field, and method returning computation results (I prefer having state-less/immutable objects).

Please, give me some hints on pros, cons and situations’ preconditions of using aforementioned approaches or show me other patterns which I could use (preferably with hints on preconditions when to use them).

---

EDIT:
Real-world example:
I am developing java ee internet application and I have a class resolving request parameters converting them from string to some business logic objects. Resolver is checking in db if object is being created or edited and then return to controller either new object or object fetched from db. Controller is taking action based on object status (new/editing) read from resolver. I know it’s bad and I would like to improve code design here.

Answer 1

function returns computation result, status is being returned via out
parameter (not all languages support out parameters and this seems
wrong, since in general you don’t expect parameters to be modified).

If the language supports multiple output values, then the language clearly was made to support them. It would be a shame not to use them (unless there are strong opinions in that particular community against them – this could be the case for languages that try and do everything)

function returns object/pair consisting both values (downside is that
you have to create artificial class just to return function result or
use pair which have no semantic meaning – you know which argument is
which by it’s order).

I don’t know about that downside. It seems to me that a record or class called MyMethodResult should have enough semantics by itself. You can always use such a class in an exception as well, if you are in an exceptional condition only of course. Creating some kind of array/union/pair would be less acceptable in my opinion: you would inevitably loose information somewhere.

if your status is just success/failure you can return computation
value, and in case of error throw an exception (look like the best
approach, but works only with success/failure scenario and shouldn’t
be abused for controlling normal program flow).

No! This is the worst approach. Exceptions should be used for exactly that, exceptional circumstances. If not, they will halt debuggers, put colleagues on the wrong foot, harm performance, fill your logging system. If you create a method to test something, then the test should return a status, not an exception: to the implementation, returning a negative is not exceptional.

Of course, if you run out of bytes from a file during parsing, sure, throw the exception, but don’t throw it if the input is incorrect and your method is called checkFile.

function returns value, function arguments are delegates to
onSuccess/onFailure procedures.

I would only use those if you have multiple results to share. It’s way more complex than the class/record approach, and more difficult to maintain. I’ve used this approach to return multiple results while I don’t know if the results are ignored or not, or if the user wants to continue. In Java you would use a listener. This kind of operation is probably more accepted for functional languages.

there is a (state-full) method class which have status field, and
method returning computation results (I prefer having
state-less/immutable objects).

Yes, I prefer those too. There are producers of results and the results themselves. There is little need to combine the two and create a statefull object.

In the end, you want to go to producer.produceFrom(x): Result in my opinion. This is either option 1 or 2a, if I’m counting correctly. And yes, for 2a, this means writing some extra code.