def objectify(&ablock)
ablock
end

block_object=objectify{|x| x*2}

block_object.call(5) #=>10

def use(block_obj,param)
puts block_obj.call(param)
end

use(block_object,4) # =>8
use(block_object,3) #=>6
block_object=objectify{|x| x*10}
use(block_object,4) #=>40

I would add one more thing though: if use hash as argument, default values are set differently.

E.g. for regular argument with default value, it will look like this

def do_something timeout = 30, retry = 3
…
end

If use hash, in order to achieve same behavior, it should be

def do_something options = {}
default_options = {:timeout => 30, :retry => 3}
options = default_options.merge(options)
…
end

That’s a lot more typing.

I am aware of first class function and yeah I agree with you if an argument is a function it certainly makes sense for it to be able to have arguments. I guess my colorful way of making a point wasn’t as clever as I thought it was :).

Well, yes they _can_ be actually. If you define a method that accepts a block, you can create a parameter for it. You’re then free to call it, or pass it to another method, just like any other argument.

The only kink is the need to prefix the block parameter with ‘&’ and that you can only have the one.

def accept_block(first, second, &blk)
blk.call(“do something block”)
end

Most iterators just use the yield construct, in which case the block isn’t assigned to an argument.

“Does it really make sense for arguments to have arguments?”

Yep, those are called first-class-functions in other languages. A block is essentially an anonymous function which you pass into a method — with some special syntax to make it easier and look neater.