Functional languages allows us to treat functions as types. This brings us a distinct advantage of being able to write a code that generates further code, this practise is generally known as
metaprogramming. As a functional language
R project provides tools to perform well structured code generation. In this post, I will present a simple example that generates functions on the fly based on different parametrisation in the function body. Consider the following simple function taking a vector as an argument and returning the number of element that are higher than a given threshold.
1
2
3
4
| myFun <- function(vec) {
numElements <- length(which(vec > threshold))
numElements
}
|
If somehow we need to have a different threshold value within the body, for a moment accept that it is a requirement rather than proposing to have an other argument in the function definition. Instead of rewriting the function by hand we will write a function that generates all these functions in our work space. Problematic bit of this exercise will be to beat
lazy evalution. Here is the function that produces losts of
myFun type functions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| genMyFuns <- function(thresholds) {
ll <- length(thresholds)
print("Generating functions:")
for(i in 1:ll) {
fName <- paste("myFun.", i, sep="")
print(fName)
assign(fName, eval(
substitute(
function(vec) {
numElements <- length(which(vec > tt));
numElements;
},
list(tt=thresholds[i])
)
),
envir=parent.frame()
)
}
}
|
Let's shortly analyse this function. If we don't use
substitute explicitly there, due to lazy evalution our value for the threshold will not be assigned at the loop value but the last value of
thresholds[i]. Here is one numeric example on the R CLI session:
1
2
3
4
5
6
7
8
9
10
11
12
| > genMyFuns(c(7, 9, 10))
[1] "Generating functions:"
[1] "myFun.1"
[1] "myFun.2"
[1] "myFun.3"
> myFun.1(1:20)
[1] 13
> myFun.2(1:20)
[1] 11
> myFun.3(1:20)
[1] 10
>
|
To be able to generate code is very powerful tool. However, a caution should be taken in practicing code generation in a large project. This may bring more problems in debugging. Every powerful method comes with a hidden cost.
