Q:

R - procedural call to a function in a list

I'm having troubles in creating a procedural call to a function that is element of a list.
I have a list of functions of the type
> initial
$g452
function (v) 
.approxfun(x, y, v, method, yleft, yright, f)
<bytecode: 0x06bd04e8>
<environment: 0x06c7a4c8>

$g664
function (v) 
.approxfun(x, y, v, method, yleft, yright, f)
<bytecode: 0x06bd04e8>
<environment: 0x06c7a5a8>

$g1431
function (v) 
.approxfun(x, y, v, method, yleft, yright, f)
<bytecode: 0x06bd04e8>
<environment: 0x06be62d4>
...

And i need to create a call to each of these functions procedurally. 
I've tried with 
g<-"g452"
eval(call(paste('initial[["',g,'"]]', sep=""), quote(t)))
Error in eval(expr, envir, enclos) : 
  could not find function "initial[["g452"]]"

And also
a[[1]] <- paste("initial[['",g,"']]", sep="")
a[[2]] <- quote(t)
eval(as.call(a))
Error in eval(expr, envir, enclos) : 
  attempt to apply a non-function

How should I a do?
NOTE: I need to create only the calls that will be evaluated in a separate time

A:

You could try using mapply:
> funs <- list(fn1 = function(x,y) x + y, fn2 = function(x,y) x * y, fn3 = function(x,y) x ** y)
> mapply(do.call, funs, list(list(1,2)))
fn1 fn2 fn3 
  3   2   1 
>

mapply will apply do.call to each function in the list, giving it the corresponding element of the second list as argument. The second list is list with one element (which is thus recycled), itself being a list of two arguments to map to x and y.
Alternatively, as @Jake suggests, you can use lapply:
> lapply(funs, function(f) f(1,2))
$fn1
[1] 3

$fn2
[1] 2

$fn3
[1] 1

to apply the anonymous function function(f) f(1,2) which takes a function as input and outputs the evaluation of the function with arguments 1 and 2, to each element of the list of functions.
A completely approach would be to create functions to be evaluated at a later stage:
> create.fun <- function(index, arg1, arg2) { return (function() funs[[index]](arg1, arg2))}
> create.fun("fn1",1,2)->f1
> create.fun("fn2",1,2)->f2
> f1
function() funs[[index]](arg1, arg2)
<environment: 0x102d12978>
> f2
function() funs[[index]](arg1, arg2)
<environment: 0x102d12e30>

Then, later,
> f1()
[1] 3
> f2()
[1] 2
> 

