Robert W. Hasker,

 Previous uses of blocks  words.each { |w| puts “word: #{w}” }  words.find { |x| x.size > 2 }  words.select { |x| x.size % 2 == 0 }  Another use: infinite computations  Open irb and type nats = 0..(1.0/0) nats.take(100) nats.step(2).first(10)  Skipping: nats.step(2).lazy.drop(50).first(10) Blocked

 Previous uses of blocks  words.each { |w| puts “word: #{w}” }  words.find { |x| x.size > 2 }  words.select { |x| x.size % 2 == 0 }  Another use: infinite computations  Open irb and type nats = 0..(1.0/0) nats.take(100) nats.step(2).first(10)  Skipping: nats.step(2).lazy.drop(50).first(10) Blocked Lazy list

Uses of infinity  squares = nats.lazy.map { |n| n * n }  Prime numbers:  require ‘prime’  Prime.first(10)  Prime.lazy.drop(1000). select { |x| (x+1)%3 == 0 }.first(5)

How does this work?  Ruby code to delay evaluation: class Promise def = = true end def @delayed = end

How does this work?  In general:  Delay: promise to provide value when requested  Force: call in the promise  Processing list:  force head when required, delay rest  Ruby implementation: blocks  Useful tool when want to delay execution in general

Yet more blockhead actions  Computing Fibonacci numbers: fibonacci = Hash.new{ |h,k| h[k] = k < 2 ? k : h[k-1] + h[k-2] }  From Ruby documentation:  If a block is specified, it will be called with the hash object and the key, and should return the default value. It is the block’s responsibility to store the value in the hash if required.

Using blocks creatively  From Eloquent Ruby by Russ Olsen, 2011  How to log events smoothly?  Consider: class WonderApplication def do_something doc = Document.load ‘masterwork.txt’ … doc.save end

Adding logging class WonderApplication def = logger end def ‘Starting load’ doc = Document.load ‘Completed load’ ‘Starting save’ ‘Completed save’ end

And rescues… def do_something ‘Starting load’ doc = Document.load ‘Completed load’ ‘Load failed’; raise end … ‘Starting save’ ‘Completed save’ ‘Save failed’; raise end

Fix: def with_logging(description) “Starting #{description}” “Completed #{description}” “#{description} failed”; raise end def do_something with_logging(‘load’) = Document.load ‘masterwork.txt’ } … with_logging(‘save’) } end

Fix: def with_logging(description) “Starting #{description}” “Completed #{description}” “#{description} failed”; raise end def do_something with_logging(‘load’) = Document.load ‘masterwork.txt’ } … with_logging(‘save’) } end “Execute around”

Blocks and initialization  Basic concept behind lazy lists: delayed initialization  Consider: class ArchivalDocument attr_reader :title, :author def initialize(title, author, = = = path end def || File.read(path) end

Blocks and initialization  Basic concept behind lazy lists: delayed initialization  Consider: class ArchivalDocument attr_reader :title, :author def initialize(title, author, = = = path end def || File.read(path) end

Blocks and initialization  Basic concept behind lazy lists: delayed initialization  Consider: class ArchivalDocument attr_reader :title, :author def initialize(title, author, = = = path end def || File.read(path) end

Blocks to the rescue: class ArchivalDocument attr_reader :title, :author def initialize(title, author, = = = reader_block end def @reader = nil end

Usage simple_file_doc = ArchivalDocument.new(‘Rubies Forever’, ‘Tim’) do File.read(‘c:/books/rubies_forever.txt’) end google_doc = ArchivalDocument.new(‘Sherlock Holmes’, ‘Conan Doyle’) do Net::HTTP.get_response(‘books.google.com’, ‘/books?id=QhPgEq5ZeY8C’).body end boring_doc = ArchivalDocument.new(‘silly’, ‘Rob’) do ‘Ya’ * 100 end

Summary  Infinite ranges, lists  Generating streams  Execute around  Embed computations in a context  Lazy initialization  Application of lazy list concept to initialization  Basic principles:  Delayed execution  Stored behaviors