Makes a good quote, but I don't buy it from a practical perspective. Library support is my primary motivation in choosing which scripting language to use for work projects. I don't think much differently at all in Ruby than in Python, but knowing both is extremely helpful.
As to ruby/python, I only have a superficial knowledge of Python, so please correct me if I'm wrong, but my understanding is that ruby blocks let you do thinks you can't in python. Rspec is one of the examples that gets talked about a lot. But if I were asked to sum all the numbers divisible by both 3 and 5 between 1 and 100 in Ruby, I'd do it like this
(1..100).select{|a| a % 3 == 0}.select{|a| a % 5 == 0}.inject(&:+)
sum([x for x in xrange(1, 101) if x % 3 == 0 and x % 5 == 0])
sum([x for x in xrange(1, 101) if x % 15 == 0])sum((x for x in xrange(1, 101) if x % 3 == 0 and x % 5 == 0))
Notice the parenthesis instead of square brackets. Your version actually creates a list in memory. A generator generates the items one by one and doesn't need to store them all at the same time.
sum(x for x in xrange(1,101) if x % 3 == 0 and x % 5 == 0)
One could imagine the question was actually "sum BusyBeaver(n) for n divisible by 3 and 5 between 1 and 100", i.e. no closed form. In Python:
sum(BusyBeaver(x) for x in xrange(1,101) if x % 3 == 0 and x % 5 == 0)
new Array(100).join(1).split(1)
.map((function() { var i = 0; return function() {return ++i;}})())
.filter(function(x) { return !(x % 15); })
.reduce(function(x, a) { return a += x; }, 0);1. Purely declarative animations in a general purpose language http://conal.net/fran/tutorial.htm
2. A recursive descent parser where you can declare your grammar as in yacc i.e. it is not a separate compiler generator but a regular library, and the code is type safe unlike yacc. The best part is that the actual library is just 2 lines of code, thanks to the magic of lazy evaluation and a powerful type system.
result v = \inp -> [(v,inp)]
p `bind` f = \inp -> concat [f v out | (v,out) <- p inp]