automatic folds from for loops

a common idiom in python is something like:

x = 0
for y in z:
  x += y
return x

This does not look so functional, but it could be. We could convert for comprehensions like this into folds. We could do this by considering x += y to be rebinding a new x to x + y and we could look at all such rebound variables in the loop. Then we could convert it to something like:

z.foldLeft(0, \y, x -> x + y)

This is not so dissimilar to having the do notation in haskell which allows you to write imperative looking code that still returns a value.

Similarly, we could do the same translation for map-like for comprehensions: [f(x) for x in y] to y.map(f)

There may be some subtlety with making these fully composable which we would want to support.

[johnynek]

yeah, that’s fine. translate to (noting rebinding lets is already allowed):

sum = 3
z = sum * 2
sum = xs.foldLeft(sum, \sum, x ->
  sum = sum + x
  sum)
fn(sum, z)

so, you just build a tuple of the values bound in the for loop, then put those bindings into a tuple and return it a fold. Isn’t that what you intend?

[avibryant]

let me give a more concrete example. Is something like this legal?

sum = 3
z = sum*2
for x in xs:
  sum = sum + x
fn(sum, z)