Comments on: Ruby: Python for Lisp Programmers

By: Marc

Marc — Thu, 22 Jun 2006 05:02:36 +0000

Very interesting post and comments. I believe that Ruby and Lisp have a lot in common because Matz was influenced by Lisp (in addition to Smalltalk and Perl).
I can see how Lisp programmers might appreciate Ruby a bit more than Python, though I’m sure there’s people who go the other way as well.

The bummer for me is that Ruby, Python, and Lisp are all very interesting languages, but I don’t get a lot of opportunities to play with them.

By: hyperstruct

hyperstruct — Tue, 20 Jun 2006 12:22:11 +0000

Stuart,

actually Ruby methods can be passed any number of lambdas:

foo = proc {|a| … }
bar = proc {|b| … }
doSomething(foo, bar)

(”proc” is even aliased to “lambda”)

The form:

doSomething {|c|
…
}

…is syntactical sugar on the outer side of doSomething for when you need just one lambda, and enables some syntactical sugar on the inner side: it lets you pass control and data to the block with “yield x” instead of “block.call(x)”.

I got interested in Lisp (and eventually fell in love with it) while programming in Ruby. I really hope the two communities will be friendly to each other because they have so much in common.

By: Johann

Johann — Tue, 20 Jun 2006 03:40:00 +0000

Ruby’s blocks are more than simple lambda’s, since they support control statements like “break”, “next”, etc.

Of course, you could create a sufficiently powerful macro that would handle these properly. Or you could use enough levels of blocks and return-from. It’s just not as trivial as a first glance might make it appear.

By: Adrian

Adrian — Tue, 20 Jun 2006 02:24:47 +0000

Ruby has been a “gateway” to Lisp for some of my friends who wouldn’t even look at Lisp before. So you could title the article “Ruby is a Gateway to Lisp Programming”. ;o)

By: bill a

bill a — Tue, 20 Jun 2006 02:21:18 +0000

“A function or method in Ruby can have only one functional argument, which must be the last argument. Functional arguments, or “blocks,” as they’re called in Ruby, appear outside the argument list of the function when it is called.”

A block is not the same thing as a functional argument. Your statement is false:

def meth( a, b )
puts a.call( 4 )
puts b.call( 4 )
end

meth( lambda { |a| a }, lambda { |a| a + 2 } )

By: John Wiseman

John Wiseman — Tue, 20 Jun 2006 01:23:30 +0000

I’m not sure, but I think the functional argument has to be the last argument to a function only if you want to use the special iterator-style block syntax with that function, which uses yield.

If you just want to pass method A to method B and call method A, I think A.call is good enough.

It does seem like Ruby did away with some of the Python annoyances.