Create a list of functions from a vector of charac

Question

Thanks in advance, and sorry if this question has been answered previously - I have looked pretty extensively. I have a dataset containing a row of with concatenated information, specifically: name,color code,some function expression. For example, one value may be:

cost#FF0033@log(x)+6.

I have all of the code to extract the information, and I end up with a vector of expressions that I would like to convert to a list of actual functions.

For example:

func.list <- list()
test.func <- c("x","x+1","x+2","x+3","x+4")

where test.func is the vector of expressions. What I would like is:

func.list[[3]]

To be equivalent to

function(x){x+3}

I know that I can create a function using:

somefunc <- function(x){eval(parse(text="x+1"))} 

to convert a character value into a function. The problem comes when I try and loop through to make multiple functions. For an example of something I tried that didn't work:

for(i in 1:length(test.func)){
  temp <- test.func[i]
  f <- assign(function(x){eval(expr=parse(text=temp))})
  func.list[[i]] <- f
}

Based on another post (http://stats.stackexchange.com/questions/3836/how-to-create-a-vector-of-functions) I also tried this:

makefunc <- function(y){y;function(x){y}}
for(i in 1:length(test.func)){
   func.list[[i]] <-  assign(x=paste("f",i,sep=""),value=makefunc(eval(parse(text=test.func[i]))))
 }

Which gives the following error: Error in eval(expr, envir, enclos) : object 'x' not found

The eventual goal is to take the list of functions and apply the jth function to the jth column of the data.frame, so that the user of the script can specify how to normalize each column within the concatenated information given by the column header.

Answer 1

This is what I do:

f <- list(identity="x",plus1 = "x+1", square= "x^2")
funCreator <- function(snippet){
  txt <- snippet
  function(x){
    exprs <- parse(text = txt)
    eval(exprs)   
  }
}
listOfFunctions <- lapply(setNames(f,names(f)),function(x){funCreator(x)}) # I like to have some control of the names of the functions
listOfFunctions[[1]] # try to see what the actual function looks like?
library(pryr)
unenclose(listOfFunctions[[3]]) # good way to see the actual function http://adv-r.had.co.nz/Functional-programming.html
# Call your funcions
listOfFunctions[[2]](3) # 3+1 = 4
do.call(listOfFunctions[[3]],list(3)) # 3^2 = 9
attach(listOfFunctions) # you can also attach your list of functions and call them by name
square(3)  # 3^2 = 9
identity(7) # 7 ## masked object identity, better detach it now!
detach(listOfFunctions)

Answer 2

Maybe initialize your list with a single generic function, and then update them using:

foo <- function(x){x+3}
> body(foo) <- quote(x+4)
> foo
function (x) 
x + 4

More specifically, starting from a character, you'd probably do something like:

body(foo) <- parse(text = "x+5")

Answer 3

Just to add onto joran's answer, this is what finally worked:

test.data <- matrix(data=rep(1,25),5,5)
test.data <- data.frame(test.data)

test.func <- c("x","x+1","x+2","x+3","x+4")
func.list <- list()

for(i in 1:length(test.func)){
  func.list[[i]] <- function(x){}
  body(func.list[[i]]) <- parse(text=test.func[i])
}

processed <- mapply(do.call,func.list,lapply(test.data,list))

Thanks again, joran.