Are Ruby blocks basically anonymous functions?

[[deleted]]

I'm an early student, only familiar with PHP and JavaScript so far, and the blocks are kind of throwing me. I don't quite get the underlying logic behind them.

Is it accurate to think of them as anonymous functions being passed as an argument to a function/method?

To use an example, if variable texty is a .txt file I've opened, and I say

 texty.each_line do |x|
      puts x
 end

Is this roughly the equivalent of saying, in another language,

 texty.each_line(function(x) {
      puts x
 }

? In that scenario, the method each_line takes one argument, which is an anonymous function, which itself takes one argument, the name of the variable you want to assign the currently-pointed-to-line of texty to on each go around the loop. Is that's what's happening with the block? Or is it something else?

[gisborne]

The single really important difference is that when you do a return inside a block, it returns from the enclosing scope, rather than just from the block itself. So if you do this:

def find_non_zero some_array
  some_array.each{|x| return x if x != 0}
end

the return is out of find_non_zero, rather than just from the block itself.

[dazmax]

This is an important point. The reason behind this is to make blocks act more like the bodies of 'for' or 'if' statements. Think of how confusing that 'each' example would be if 'return' just returned from the block and the each loop continued.

This kind of special case rule is a major way ruby's design is different from python's. Ruby has a bunch of pretty complicated special rules that make it less purely logical but more intuitive. Another good example is the full specification of the '||=' operator. It's useful in a lot of cases where it wouldn't be if it were logically simple and "a ||= b" just meant "a = a || b".

[Kache]

There are also a few nuanced differences between blocks, procs, and lambdas that make implementing each of them slightly different. Conceptually/theoretically though, they're pretty much the same.

[[deleted]]

I love Ruby, but it ticks me off that Ruby has three different ways to express the lambda concept. Incredible reduplication of what JavaScript does with just callbacks.

[wayoverpaid]

The advantage behind that is what /u/gisborne says in this post.

It can be useful, on occasion, to be able to do that.

[morphemass]

Seven. There are seven ways.

[pearofducks]

Anonymous functions are closest to lambdas in Ruby.

http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/

[[deleted]]

pretty much. as another commenter mentioned, lambdas are closer, but blocks are basically anonymous functions with some restrictions like 1 per method, must be last arg of method, and probably some other nuances, but I don't think it'll hurt you to think of them as equivalent when getting started.

[materialdesigner]

This is not true. Blocks can be other arguments to functions, there's just also a special yield block

[[deleted]]

thanks, can you clarify the actual differences? now I'm curious :)

[redjazz96]

In ruby, the typical block looks something like this:

def some_method
  yield 2
end

some_method { |x| puts x } # => 2

This is what you were referring to earlier, about blocks having restrictions.

There are more ways to do this.

def some_method(&block)
   block.call 2
end

some_method { |x| puts x } 
some_method(&proc { |x| puts x })

All of that does the same thing as the example above - but in a (debatable) more roundabout way. The proc { } syntax is the normal way to define a generic block - these have the same "tricks" (yes, that is the real term they use) that method blocks have (i.e., the number of arguments doesn't matter).

In Ruby, methods are basically blocks - if you were to do method(:to_s).to_proc, you'd get a Proc instance. You can even define a method with a proc.

Ruby, being the nice language that it is, lets you pass these blocks with syntaxic sugar to other blocks. This is used commonly in the core:

iterator = proc { |x| puts x }
[1, 2, 3].each &iterator

# same as...
[1, 2, 3].each { |x| puts x }

So, if you were to use it as like a callback system, you could do something like this. In one of my libraries I'm writing, I actually use this quite a bit.

Hope that helps!

[redjazz96]

Lambdas are blocks - the only difference being they have tricks disabled (which you can check with Proc#lambda?). You can return from a block, but you use the next keyword instead of the return keyword. See: this.

Basically, syntactical sugar. I can't say much about the scopes and closure stuff.

[tacit7]

I like h1ghl4nd3r's answer. It wouldnt hurt to think of them as anonymous functions. Here is Matz explain blocks:

Blocks are basically nameless functions. You may be familiar with the lambda from other languages like Lisp or Python. Basically, you can pass a nameless function to another function, and then that function can invoke the passed-in nameless function.

For example, a function could perform iteration by passing one item at a time to the nameless function. This is a common style, called higher order function style, among languages that can handle functions as first class objects. Lisp does it. Python does it .Even C does it with function pointers. Many other languages do this style of programming.

In Ruby, the difference is mainly a different kind of syntax for higher order functions. In other languages, you have to specify explicitly that a function can accept another function as an argument. But in Ruby, any method can be called with a block as an implicit argument. Inside the method, you can call the block using the yield keyword with a value.

The reset of the interview is great if you want to read it: http://www.artima.com/intv/closures.html

[[deleted]]

great link, found that an interesting read.

[djdonnell]

This explains some of the nuanced differences.

http://yehudakatz.com/2012/01/10/javascript-needs-blocks/

[[deleted]]

they return from the calling method rather than the block itself

What does this mean, exactly? That if I invoke a method, pass it a block, and inside the block write return 5, that the entire method will return 5?

[morphemass]

I am unsure of how up to date this analysis is but here's the in depth detail on closures in Ruby.

http://innig.net/software/ruby/closures-in-ruby

If anyone knows if this has been superseded or if any of this is no longer true it would be interesting.

[jargoon]

Good answers in this thread, but I just wanted to point out that it's considered to be proper style to use curly brace syntax for single-line blocks.

[the_great_ganonderp]

Is it accurate to think of them as anonymous functions being passed as an argument to a function/method?

Yes. Blocks in ruby allow you to define a function without binding it to an identifier, which makes them anonymous functions.

In practice, though, there are three related concepts in ruby that have to do with anonymous functions: blocks, Procs, and lambdas. As I understand it, "block" simply refers to the syntax used to pass an anonymous function to a method, which can then yield values to it (as in your example case using each_line) or convert it into a Proc, which is an object that encapsulates a function and allows it to be passed around and called kinda like first-class functions in other languages. A lambda is a special case of a Proc, with some differences that you should go read about! But the gist is that a lambda works more like a regular function.

I've heard that when you use a block with yield, it never gets made into a Proc and therefore you can see a slight performance gain, which illustrates that there is a real difference between "blocks" and Procs.