Your way to define a function func = Function[x^2][x] is very bizarre. It is totally equivalent to writing

func = x^2

so that it is more an algebraic expression than a function. You cannot write func[2] to get its value when x=2, but you have to do something like func/.x->2 or Block[{x = 2}, func]. Your use of the global variable x is dangerous for various reason.

The usual, elementary way to define a function is this:

func[x_] := x^2

You can also use Function, but the correct syntax would be something like this:

func = Function[x, x^2]

Either way you evaluate func[2] and get 4.

Note that it's a bad practice to use x from Globalbecause (users/you) may be using it for something else and other "bad" packages may introduce further confusion. For this reason when it's necessary to offer convenience to use Global use a LONG NAME (and not something cryptic). However: use of Options[run] is a better way to handle allowing (user) to set variables generally used by parts of a package. Yet another way is to define something outside of Private that can be replaced by user without need of Unprotect[], ex runx (note this can still become a problem with Global).

Note also that your code "could work" (the x inside table will be runPrivatex if you check ?runPrivate*, in general if x does not exist Mathematica will create it - in this case not in Global). If a Private defined function that is also public (outside of Private) takes arguments, the arguments can of course, be functions. However you need to study Context[] closely. It's well likely your problem is a corrupt runtime environment confusing things (you may have Global`run defined and not realize it).

Finally, if you find Mathematica is USING Globalx in the Table (it shouldn't), then use run[func_]:=Module[...]. Also note Mathematica WONT use Globalx if you define x in runor runPrivate.

Study more about Context[]

Hi Gianlunca and thanks for the reply.

Original problem was I wanted to take a list of functions and pass them into a package which had a plotting function. This did not work, so I started stripping things down and found the core of the problem was that the functions were not evaluating. I had written the functions like so:

funcs = {x^2, x^3, x^4}

I thought it might be because I wasn't explicitly defining an anonymous function, so that's why I used the Function call above.

I did try to use global x in the package like so:

BeginPackage["run`"]
    run::usage = "run[func]"
    Begin["`Private`"]
        run[func_] :=
            Module[{x = Global`x},
                Table[func, {x, 1, 6}]
            ]
    End[]
EndPackage[]

But this didn't help. I think the x is local to the Table block and so should just be replaced in the anonymous function. Either using global x or not shouldn't matter.