evaluation - Using Through with SlotSequence

I have an expression consisting of a few pure functions added together like so:

f+g+h

I want to add the bodies of these functions together and make that a pure function. Usually I would do this by finding the maximum number of arguments (maxArgs) required to fill the functions f, g and h, and then create my added function like so:

newFunc = Evaluate[Through[(f+g+h)@@Slot/@Range@maxArgs]] &;

The Evaluate here is important for a couple of reasons impertinent to this question. Just know that it is necessary to evaluate the function body.

The problem with this method is that in general, I won't always know what maxArgs will be. Technically, I could find this value by using this answer, but I'm worried about the performance and robustness of this method.

I thought that I might circumvent the need to specify a number of slots by doing this:

newFunc = Evaluate[Through[(f+g+h)[##]]]&

But Mathematica's output at this point throws an error, saying that the slots of the functions f, g and h cannot be filled from ##. I understand that this is because ## appears as just one symbol to Mathematica.

So how might I evaluate Through without specifying the number of slots I will need?

Example:

Given:

f = #&;
g = Function[{a,b,c}, a^3 - b];
h = - #1^2 + #2 &;

My desired output is produced by:

myFunc = Evaluate[Through[(f+g+h)[#1,#2,#3]]&;

The important bit here is the Evaluate. I want to evaluate the function body completely before creating the function. The problem with the code above is that I had to explicitly enter the maximum number of slots required by the pure functions. In this case, three slots were required. In general, I may be using functions that take 3 arguments, or 5, or 72, etc.

In my notebook, I will not know ahead of time how many slots will be used by these functions.

Answer

Reading your question and comments again, and assuming that none of your pure functions contain SlotSequence, I think maybe this will work for you:

combine[expr_] := Max[
   Cases[expr, Slot[n_] :> n, {-2}],
   Cases[expr, Verbatim[Function][x_List, __] :> Length@Unevaluated@x, {1}]
 ] // Function @@ {Through[expr @@ Array[Slot, #]]} &

Test:

f = # &;
g = Function[{a}, a^2];

h = (-2 #1 + #3) &;

combine[f + g + h]

-#1 + #1^2 + #3 &

And now also:

f = Function[{a}, a];
g = Function[{a}, a^2];

h = Function[{a, b, c}, (-2 a + c)];

combine[f + g + h]

-#1 + #1^2 + #3 &

Of course as rasher/ciao points out this doesn't work with e.g. combine[f+g+h+f+g+h] but that is because f + f evaluates to 2 f and Through only works on the level one head. If something besides Through behavior is desired that will need to be specified.