Comments on: Understanding Ruby blocks, Procs and methods

By: Brian

Brian — Thu, 12 Jun 2008 15:32:26 +0000

Great article. Really cleared up a lot of my understanding about this topic!

By: Andriy

Andriy — Tue, 26 Feb 2008 01:39:14 +0000

Great explanation. Finally i understand “how” yield works.

By: Deepak Gole

Deepak Gole — Tue, 15 Jan 2008 07:28:30 +0000

Hello If I want pass arguments to method (&:center), then how to send it
class Symbol

# A generalized conversion of a method name
# to a proc that runs this method.
#
def to_proc
lambda {|x, *args| x.send(self, *args)}
end

end

# Viola !
words = %w(Jane, aara, multiko)
upcase_words = words.map(&:center)

By: shining

shining — Fri, 28 Dec 2007 14:36:12 +0000

Nice and concise!

By: cks2k2

cks2k2 — Mon, 10 Dec 2007 06:10:37 +0000

# this doesn’t (ArgumentError), because &f
# isn’t really an argument - it’s only there
# to convert a block
contrived(25, lambda {|x| puts x})

I tried this on 1.8.6-25 but getting an ArgumentError(2 for 1).
Or am I the only getting this error?
I’ve tried contrived( 25, Proc.new {|x| puts x}) but it’s still not working.

By: elliottcable

elliottcable — Tue, 27 Nov 2007 21:44:15 +0000

In addition to being way cooler a whopping two characters shorter

Or, if you’re really awesomely cool, you could do this instead:
module Kernel alias λ proc # (U+03BB) end

padd = λ {|x, y| puts x + y} padd.call

By: Coffee_fan

Coffee_fan — Sat, 03 Nov 2007 02:17:40 +0000

Eli, this is a very nice article. On a side-note, I also found quite enlightening that the control directives ‘next’, ‘break’ do work in the context of codeblocks in an intuitive way. As such it is possible to replace most loop iterations by an iterator with a codeblock with little or no modification to the control logic.

By: Leet Geezer

Leet Geezer — Sun, 13 May 2007 08:15:17 +0000

Thanks for great article. Clarified alot.

By: Tarmo

Tarmo — Mon, 02 Apr 2007 23:27:47 +0000

kybernetikos, the reason neither of your examples could work is that ruby has to be able to differentiate between methods and local variables as methods can be called without parentheses. And the way ruby does it is this: if a local variable for some name “x” is not defined then “x” is the same as “x()”, meaning a method call; but when a local variable “x” is defined then “x” refers to the variable not the method and “x()” still refers to the method. In your example you are creating a local variable “func” in which case “func(2)” is the only way to refer to a method named “func” as opposed to a variable named “func”.

What you are trying to do is quite similiar to what is described here: http://www.thekode.net/ruby/techniques/DefiningMethodsWithClosures.html but with the downside of not being able to do this in a global context, define_method can only be called for a class or a module.

By: kybernetikos

kybernetikos — Tue, 20 Mar 2007 11:49:20 +0000

I like ruby so far, but procs and lambda seem like a hack to allow functional programming. What happened to the principle of least surprise? Why can’t I do (which I tried immediately)

func = do |x|
x+5
end
func(2)

So I read your page and try

func = lambda {|x| x+5 }
func(2)

And that still doesn’t work. Why on earth would I want to do func.call(2)? Putting square brackets after something calls the [] method, why doesn’t putting () brackets after something call the call method? I would say that although you are able to program in a functional style in ruby, it makes it hard for you. It’s a piece of nonorthogonality that is ugly. There should be no need for wrapping blocks in procs.