Robert W Hasker 2011 2016 BLOCKED RUBY Blocked

Robert W. Hasker, 2011 -2016 BLOCKED RUBY

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 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 Lazy list nats = 0. . (1. 0/0) nats. take(100) nats. step(2). first(10) Skipping: nats. step(2). lazy. drop(50). first(10)

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 initialize(&block) @block = block @delayed = true end def force @value = @block. call if @delayed = false @value 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 Wonder. Application def do_something doc = Document. load ‘masterwork. txt’ … doc. save end

Adding logging class Wonder. Application def initialize(logger) @logger = logger end def do_something @logger. post ‘Starting load’ doc = Document. load ‘masterwork. txt’ @logger. post ‘Completed load’ … @logger. post ‘Starting save’ doc. save @logger. post ‘Completed save’ end

And rescues… def do_something begin @logger. post ‘Starting load’ doc = Document. load ‘masterwork. txt’ @logger. post ‘Completed load’ rescue @logger. post ‘Load failed’; raise end … begin @logger. post ‘Starting save’ doc. save @logger. post ‘Completed save’ rescue @logger. post ‘Save failed’; raise end

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

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

Blocks and initialization Basic concept behind lazy lists: delayed initialization Consider: class Archival. Document attr_reader : title, : author def initialize(title, author, path) @title = title @author = author Assumption: don’t usually need @path = path content for archived object end def content @content = @content || File. read(path) end

Blocks and initialization Basic concept behind lazy lists: delayed initialization Consider: class Archival. Document attr_reader : title, : author def initialize(title, author, path) @title = title @author = author Assumption: don’t usually need @path = path content for archived object end def content @content = @content || File. read(path) end Limitation: only works for files

Blocks to the rescue: class Archival. Document attr_reader : title, : author def initialize(title, author, &reader_block) @title = title @author = author @reader = reader_block end def content if @reader @content = @reader. call @reader = nil end @content end

Usage simple_file_doc = Archival. Document. new(‘Rubies Forever’, ‘Tim’) { File. read(‘c: /books/rubies_forever. txt’) } google_doc = Archival. Document. new(‘Sherlock Holmes’, ‘Conan Doyle’) { Net: : HTTP. get_response(‘books. google. com’, ‘/books? id=Qh. Pg. Eq 5 Ze. Y 8 C’). body } boring_doc = Archival. Document. new(‘silly’, ‘Rob’) { ‘Yada’ * 100 }

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