RCR 227: Make blocks default to zero arguments

def block_arity(&block)

   block.arity

end

Present behaviour:

block_arity { }           => -1
block_arity { || }        => 0
block_arity { |*unused| } => -1

In other words, a block with nothing specified now accepts any number of arguments, silently discarding these.

This makes for risky code: People generally do not specify argument lists for blocks they do not expect to take any arguments, and this result in arguments being discarded in an error situation. It also result in it being hard to implement meta-programming around these blocks (it "looks weird").

For instance: I discovered this while attempting to use meta-programming to remove duplication in my initialize-methods. I'd discovered that a large fraction of my initializers looked like this:

def initialize(a, b, c)

    @a = a
    @b = b
    @c = c
    ... calculate some things based on a, b, and c ...

end

Thus, I wanted to add a meta-method to get rid of the duplication in that code, resulting in

   simple_initializer(:a, :b, :c) do
        ... calculate some things based on @a, @b, and @c ...
   end

I wanted to keep the flexibility to add an argument d by doing

   simple_initializer(:a. :b, :c) do |d|
   end

Due to blocks defaulting to taking |*unused| instead of ||, this requires extra syntax for the normal case - and it means that if that syntax is forgotten and a mistake is made somewhere else (and number of parameter errors is a type of error I've noticed crop up reasonably often), the code silently does the wrong thing.

block_arity { }           => 0
block_arity { || }        => 0
block_arity { |*unused| } => -1

(with associated behaviour when arguments are passed).

The present behaviour is risky (errors lead to widespread failure far from the point of call and potentially much later), and it surprised at least me.

Pros of the change:

• It makes the behaviour more obvious.
• It avoid the subtle errors that can happen with the present semantic.
• It makes for less code for what at least for me is the common case (that when you do not specify any arguments, you do not want anything passed).

Cons of the change:

• It makes for a trifle more code (an extra |*unused| in the case where people want to use an iterator just to count repeats for some operation.
• It is not backwards compatible where people have made assumptions for the above case.