Your challenge doesn't make sense from a Perl perspective. You are abusing the terminology.

• A subroutine can be called in a void context, in which case, it returns nothing.
• A subroutine can be called in a scalar context, in which case it always returns a scalar.
• A subroutine can be called in a list context, in which case it always returns a list.

The types of values a subroutine returns is not decided by the subroutine, but by the caller. Therefore, your challenge is meaningless. And it can never return "an array" or "a hash". It'll be a scalar or a list, depending on the context in which it's called.

I think I'm just not explaining myself well.

Here's a rough example...

$result = $obj->functionA($obj->functionB());

I want whatever function B returns to be passed as a reference to function A. I don't know what function B is going to return because that whole line is generated by a Parse::RecDescent grammar which is writing the Perl script based on the parsing of a scripting language I designed.

If I knew functionB was always going to return a list, I could do...

$result = $obj->functionA([ $obj->functionB() ]);

Or if I knew it was going to be a hash...

$result = $obj->functionA({ $obj->functionB() });

I've thought of writing a function which takes in some values and returns a reference to them, whatever they might be...

$result = $obj->functionA($obj->createrightreftype($obj->functionB()));

But I can't think of any way to make createrightreftype do the right thing.

Does that make any more sense? I'm finding it difficult to describe this.

$result = $obj->functionA($obj->functionB());
[download]

That's going to be calling method functionB in a list context. Therefore, the one and only answer you can have in Perl is "it is returning a list". Every other thing you think it might be doing is not happening.

Your statement of "always going to return a list" is therefore true. Your statement of "going to be a hash" is therefore always false.

I don't see the confusion here. It's the caller that decides what the called routine returns. It's that simple.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Obviously the correct way would be always to pass Function A a reference to whatever Function B returned, but how can I create the reference to it when I don't know what it's going to be?

Update
The note below is correct. Ignore this.

Not if funcB returns a list. Then funcA would get a single reference to the last item in the list. Not to the whole list.

Are you sure?

$ perl -e "
sub a{return (1,2)}
sub b{print scalar @_,
            map $$_, @_}
b(\a());"
[download]

prints 212

The problem I have is that I'm not sure what Function B is going to return. It may return a scalar, it may return an array or it may return a hash. It may even be a reference to one of these

That's not exactly right. Perl subroutines can return list of scalars. That's it. If you try to return something that isn't, it gets converted. The conversion occurs inside the function, so there's no way for the outside to know what was passed to return inside the function. Unfortunately, what you request cannot be done in Perl.

However, that doesn't mean there's no solution to your problem. There might be an alternative way of achieving what you want. Maybe there's a way of causing Function B that hasn't occured to you. Parse::RecDescent is very powerful and very flexible, so I'm sure we could find a way to help you if you were to post some of your code.