Question

I have a couple questions about Ruby’s methods, procedures, and blocks that strike me as rather odd. They’re not so much about syntax or function as the logic behind the decisions made.

Question 1:

Why is it that blocks can be passed to methods (e.g. each) but they cannot be assigned to a variable?

I know you can pass them around in procedures, i.e. p = Proc.new {...} (accessed with &p), but it doesn’t make much sense to make the programmer go through these means.

Question 2:

Why is there a differentiation between methods and procedures?

For instance, I can accomplish the task of defining a function and calling that function in the following two ways:

def square(x)
    x**2
end

square(3)
=> 9

or

square = lambda {|x| x**2}
square.call(3)
=> 9

Why the differentiation? In Python for example both defining a function in the standard way and by square = lambda x: x**2 accomplish the same task of creating the function and assigning it to square.

Answer 1

Question 1: Blocks are not objects, they are syntactic structures; this is why they cannot be assigned to a variable. This is a privilege reserved for objects.

Question 2: Methods are not objects, so they cannot receive messages. Inversely, procs and lambdas are objects, so they cannot be invoked like methods, but must receive a message that tells them to return a value on the basis of the parameters passed with the message.

Procs and Lambdas are objects, so they can receive the call message and be assigned to names. To summarize, it is being an object that makes procs and lambdas behave in ways you find odd. Methods and blocks are not objects and don’t share that behavior.