Your variables can be kept in a List[]. X={a,b,c,d,...}. There is no reason to make them "arguments to a function" like you'd do using "a programming language". The list can be (Evalutate[]'ed) as expressions inside any function or without any function at all.
X=Get["file.part"]
(* will read file as mathematica expressions, evaluated upon reading *)
If file contains: List[ {expr1, expr2, expr3}, then X is a List of variables, Plus@@X adds them all without using Part[], meaning X[[1]]+X[[2]+X[[3]].
If file contains "expr1,expr2,expr3" I might write, to satisfy expression syntax,
X=List[Get["file.part"]]
Function arguments, in Mathematica, can act like a FILTER, calling a correct function on the basis of the PATTERN of arguments given or even altering the pattern of the arguments to fit a function argument. (this would protect a function from giving a result on spurious or incomplete arguments, and from errors that might cause the Kernel to Quit[]). Functions act as an expression that expect parameters - so if your math expects to give arguments you might use a function to take them (on the other hand, mathematica allows you to convert arguments, which are a Sequence[], to type List, so you are not forced to use a function). Also, functions do not "need to be defined" like a programming language. this un-named "dis-appearing function" takes argument 1 and does it job without ever being named.
(1+#)&[1] == 2
But it doesn't really dis-appear. All your Input[] and Output is remembered! You can change the length of how many Input[] of the past Mathematica remembers.
I am just discouraging "making a function that takes the variables". A List should "take the variables". A function will not "hold them" (it doesn't in lower level languages like C either).
f[x__] := With[{args = {x}}, Sum[args[[i]], {i, Length@args}]]
The problem here x is an unkown Sequence. (we didn't use f[x_List] wich would certainly be a simple list). So then needlessly you've asked another function Which to count AND evaluate btw all of the sequences one at a time (which is what you want to avoid ALWAYS) to create {x} and args (args becomes a list), and use X[[i]] in all your computations. If x expands strangely, you could get in allot of trouble. Another problem is you were not told how to "get x into f as a bound sequence object", which you might have been wondering.
So I can't agree that f[x__] used with With[ ..., i, Lenght@foo] is what you are looking for. It is the opposite of what would be "simplest" and also most efficient.