1 / 10

Understanding Ruby: Blocks, Procs, and Closures in Functional Programming

This overview discusses the use of blocks, procs, and closures in Ruby, showcasing how methods can yield control to blocks and the implications for variable access within method calls. It explains the difference between blocks and Proc objects, including their closure behavior and variations like lambdas. With practical examples, the content elucidates how to create Proc objects, use the '&' operator to turn blocks into Procs, and highlights the differences in return behavior between Procs and lambdas. Dive into this guide for insights into functional programming in Ruby.

fausta
Télécharger la présentation

Understanding Ruby: Blocks, Procs, and Closures in Functional Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CSE 413 Autumn 2008 Ruby Blocks, Procs, and Closures

  2. Blocks • Recall that any method call can have a trailing block, which can be executed by the method (almost like a coroutine) all_words = “” words.each { | w | all_words = all_words + w + “ ” }

  3. Block Execution • A block is executed in the context of the method call. • Implications: Access to variables at the call location; return from a block returns from surrounding method def search(it, words) words.each { | w | if it == w return } puts “not found” end

  4. yield • Any method call can include a trailing block. A method “calls” the block with a yield statement. def repeat Output: yield hello yield hello end repeat { puts “hello” }

  5. yield with arguments • If the block has parameters, you can provide expressions with yield to pass arguments def xvii yield 17 end xvii { | n | puts n+1 } • This is exactly what an iterator does

  6. Blocks and Procs • Blocks (and methods) are not objects in Ruby – i.e., not things that can be passed around as first-class values • But we can create a Proc object from a block • Procs are closures consisting of the block and the surrounding environment • Variations: procs and lambdas; slightly different behavior • Several different ways to construct these; see the language documentation for details

  7. Making Procs • In a method, can have a parameter that explicitly represents the block def return_a_block (& block) block.call(17) return block end • The ‘&’ turns the block into a proc object • Proc objects support a call method

  8. Proc.new; lambdas • Can also create a proc object explicitly p = Proc.new { | x, y | x+y } … p.call(x,y) • The kernel’s lambda method also creates proc objects is_positive = lambda {|x| x > 0 }

  9. Procs vs. Lambdas • A Proc is a block wrapped in an object – and behaves just like a block • In particular, a return in a Proc will return from the surrounding method where the Proc’s closure was created • Error if that method has already terminated • A Lambda is more like a method • Return just exits from the lambda

  10. Functional Programming in Ruby Ruby is definitely not a functional programming language, but with blocks, procs, and lambdas, you can do most anything you could in a functional language For a good discussion, see ch. 6 in The Ruby Programming Language by Flanagan and Matsumoto

More Related