Ruby方法，Proc和块混淆

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 (eg each) but they cannot be assigned to a variable?

I know you can pass them around in procedures, ie 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.

Answer 2

To some extent at least, methods are objects:

class ABC
  def some_method
  end
end
ABC.instance_method(:some_method) #=> #<UnboundMethod: ABC#some_method>

Further to that, there is a built-in class: Method, as documented here .

See also this: http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls

Haphazardly <bseg> , it does rather seem to bear out the everything-is-an-object thing. In this particular case, it just appears to take a little more digging to see.

(I really must make an effort to understand this better: I'm starting to think it's fundamental to getting a deeper understanding.)

Answer 3

Methods are methods — that is, they're actions that an object can take in response to messages. They are not functions.

Blocks are closures — they're functions that close over the enclosing scope. They don't conceptually "belong to" a given object.

In some languages, methods are merely functions that are members of an object, but Ruby does not view them this way. Separating a method from its owning object is more akin to surgery than simple assignment. Ruby takes its object-orientation model from Smalltalk , the granddaddy of modern OO.