Jon H. wrote:

it nests “n” applications of “f” to “x” with “n” defaulting to 2 if it isn’t

specified, e.g. “nest ~n:3 f x” gives f(f(f(x))).

This trivial example encapsulates much of what I love about OCaml and it

doesn’t translate well into any other language that I know.

If I understood your description, and the code correctly, this should

work:

n ||=2; if n == 0; x else n.times do x = f x; end end

or should that be:

n ||=2; f ( x = if n == 0; x; else; n.times do x = f x; end; x; end )

of course, you could recurse using a temporary value rather than x, if

you wanted to.

initialize an example with:

def f x; 2 * x; end; x = 2

I’m sure there’s probably a more ‘functional’ way also.

If I do have your example correct, I should think a generic recursor

function would not be hard to implement in ruby.

In fact:

def recurse func, depth, *initials

working = initials

depth.times do

working = func.call *working

end

working

end

Initialize like so:

def f x, y

[2 * x, 1 * y]

end

x,y=2,10

Use like so:

recurse method(:f), 2, x, y

n.b. this should work for arbitrary argument lengths provided the called

function returns an array of arguments for itself.

Does this satisfy?

Oh, I thought I’d add a block version too, just for all those people

that love blocks (and because it may be useful in this context):

def recurse_blk depth, *initials, &blk

working = initials

depth.times do

working = yield(*working)

end

working

end

example: recurse_blk(2, x, y) do |a,b| f(a,b) end

Enjoy.