Not a question or anything... I just wanted to share this snippet with
any non-computer-scientist who thinks this is cool 
I come from very much an imperative programming background - originally
machine code. Computer science books tend to use LISP, and I find anything
other than the simplest example to be impenetrable. However, translating
them to Ruby makes it much clearer to me what's going on.
路路路
---------------------------------------------------------------------------
# Simple start: implement the 'times' iterator recursively, applied
# to an explicit proc argument rather than an implicit block.
def my_times(n, f)
聽聽if n >= 1
聽聽聽聽f.call()
聽聽聽聽my_times(n-1, f)
聽聽end
end
my_times(3, proc { puts "testing" } )
聽聽聽聽
# OK, now implement the 'times' iterator as an anonymous function (proc)
times = proc { |n, f|
聽聽if n >= 1
聽聽聽聽f.call()
聽聽聽聽times.call(n-1, f)
聽聽end
}
times.call(3, proc { puts "hello world" } )
# However, I cheated The proc isn't really anonymous because I assigned
# it to 'times', and this was essential because I referred to the name
# inside the function in order to call itself recursively.
#
# But in fact it's possible to write fully anonymous functions which are
# recursive.
#
# The following example is translated from "Structure and Interpretation
# of Computer Programs" (Abelson, Sussman and Sussman), second edition p393
# - it's an anonymous function which calculates factorial recursively
puts proc { |n|
聽聽proc { |fact| fact.call(fact, n) }.call(
聽聽聽聽proc { |ft, k|
聽聽聽聽聽聽k <= 1 ? 1 : k * ft.call(ft, k-1)
聽聽聽聽}
聽聽)
}.call(10)
# Using this pattern we can recast our iterator as follows, without using
# its name internally:
proc { |*a|
聽聽proc { |iter| iter.call(iter, *a) }.call(
聽聽聽聽proc { |me, n, f|
聽聽聽聽聽聽if n >= 1
聽聽聽聽聽聽聽聽f.call()
聽聽聽聽聽聽聽聽me.call(me, n-1, f)
聽聽聽聽聽聽end
聽聽聽聽}
聽聽)
}.call(3, proc { puts "hello again" } )
