How to chain a list of binary functions - r

Question

I am interested in the following construction:
Let's suppose I have a list of n binary functions and a vector of n+1 arguments. For arguments sake lets use
flist = c(`+`,`-`)
args = 1:3
What I would like to do is create the following function call f2(f1(x1,x2),x3) i.e in this example
`-`(`+`(1,2),3)
where the return value is the vector of cumulative results
[1] 3 0
I have a solution of the form
f = function(x,op,res = NULL){
if(is.null(res)){
res = op[[1]](x[1],x[2])
x = x[-1]
} else{
res = c(res,op[[1]](res[length(res)],x[1]))
}
if(length(op) == 1) res
else f(x[-1],op[-1],res)
}
such that is gives the correct answer
f(x,flist)
[1] 3 0
but it doesn't feel particularly R like or elegant. Is there a better way to do this. I suspect that my implementation isn't the most efficient either and so anything that is more efficient would also be of interest.
Any one got any ideas?
Alternatively if relaxing the requirement to have cumulative answers, i.e just the final answer 0 returned, was imposed is there a nice R way to do this? I know I could modify my f to deal with this alternative but if there exists a way to do this already I would love to hear about either option.
Edit:
A comment suggested a for loop implementation so we could have
falt = function(x,op){
res = numeric(length(op))
res[1] = op[[1]](x[1],x[2])
for(i in 2:length(res)) res[i] = op[[i]](res[i-1],x[i+1])
res
}
which does work out more efficient. But I still feel there must be a neater way to do this.

Answer 1

If your functions are already in curried form, it's a lot easier
comp <- function (f) function (g) function (x) f(g(x))
comp2 <- comp (comp) (comp) # if this is confusing, details later
add <- function (x) function (y) y + x
mult <- function (x) function (y) y * x
comp2 (mult) (add) (3) (4) (5)
# 5 * (4 + 3)
# 5 * 7
# 35
Because everything is curried, you can apply as many arguments as you want, then apply the rest later
compute <- comp2 (mult) (add)
compute (5) (6) (7)
# 7 * (6 + 5)
# 7 * 30
# 210
If you have list of binary functions, you can use a left fold (or "reduce") to create an entire sequence
identity <- function(x) x
comp <- function (f) function (g) function (x) f(g(x))
comp2 <- comp (comp) (comp)
uncurry <- function (f) function (x,y) f(x)(y)
reduce <- function(f) function(y) function (xs) Reduce(uncurry(f), xs, y)
comp2All <- reduce (comp2) (identity)
# some binary functions to use in our sequence
sub <- function (x) function (y) y - x
add <- function (x) function (y) y + x
mult <- function (x) function (y) y * x
# create a sequence of N binary functions
compute <- comp2All (list(mult, sub, mult, add))
# apply the computation to N+1 args
compute (3) (4) (5) (100) (0.2)
# 0.2 * (100 - (5 * (3 + 4))
# 0.2 * (100 - (5 * 7))
# 0.2 * (100 - 35)
# 0.2 * 65
# => 13
So you probably don't like having to apply the computation one argument at a time...
# this kind sucks, right?
compute (3) (4) (5) (6) (7)
Well we can fix that by making a function that applies a curried function to a list or arguments
capply <- reduce (identity)
capply (compute) (3:7)
# 7 * (6 - (5 * (4 + 3)))
# 7 * (6 - (5 * 7))
# 7 * (6 - 35)
# 7 * -29
# => -203
If your binary functions are not yet curried:
You can easily curry a binary function using curry2
curry2 <- function(f) function(x) function(y) f(x,y)
curry2 (`+`) (3) (4)
# => 7
If you have an entire list of binary functions that are not already curried, you can transform the entire list using map
map <- function (f) function (xs) Map(f,xs)
compute <- comp2All (map (curry2) (list (`*`, `+`, `*`, `+`)))
compute (3) (4) (5) (6) (7)
# 7 * (6 + (5 * (3 + 4)))
# 7 * (6 + (5 * 7))
# 7 * (6 + 35)
# 7 * 41
# => 287
comp vs comp2
Because you want to create a sequence of binary functions, I used
comp2All <- reduce (comp2) (identity)
If you wanted a sequence of unary functions, you would use
compAll <- reduce (comp) (identity)
what is comp2?
The comp2 definition might seem baffling, but don't let it confuse you
comp2 <- comp (comp) (comp)
If we were to expand this, we'd first see
comp2 <- function (x) comp(comp(x))
Upon further expansion (this is a fun exercise for you to do), you should see
comp2 <- function (f) function (g) function (x) function (y) f(g(x)(y))
Which can be easily understand as the composition of unary function, f, with binary function, g