Perché l'istruzione break in ruby ​​si comporta diversamente quando si utilizza Proc.new v. Il segno e commerciale?

Question

L'istruzione break per i blocchi (come da The Ruby Programming Language) è definito come segue:

provoca il blocco di ritornare alla sua iteratore e l'iteratore tornare al metodo invocato.

Pertanto, quando viene eseguito il codice seguente, risulta un LocalJumpError.

def test 
    puts "entering test method" 
    proc = Proc.new { puts "entering proc"; break } 
    proc.call # LocalJumpError: iterator has already returned 
    puts "exiting test method" 
end 
test 

Mentre il seguente codice non lo fa gettare un LocalJumpError. Qual è la particolarità del segno e commerciale? Il segno e commerciale non usa implicitamente Proc.new?

def iterator(&proc) 
    puts "entering iterator" 
    proc.call # invoke the proc 
    puts "exiting iterator" # Never executed if the proc breaks 
end 

def test 
    iterator { puts "entering proc"; break } 
end 
test 

In altre parole, ho letto il cartello commerciale come mezzo di in-rivestimento chiamata Proc.new. A quel punto il comportamento dovrebbe essere lo stesso del primo snippet di codice.

def iterator (p = Proc.new { puts "entering proc"; break}) 
... 
end 

responsabilità: Sto newb imparare la lingua (ruby 1.9.2), e quindi apprezzerò riferimenti e una sinossi dettagliata.

Answer 1

break rende il blocco e il chiamante del ritorno blocco. Nel codice seguente:

proc = Proc.new { break } 

Il "chiamante" del blocco che viene convertito in un oggetto Proc è Proc.new. break si suppone che renda il chiamante del blocco restituito, ma Proc.new è già stato restituito.

In questo codice:

def iterator(&b); b.call; end 
iterator { break } 

Il chiamante del blocco è iterator, in modo che rende iterator ritorno.

Answer 2

Ecco lo answer.

E commerciale è utilizzato per convertire un proc in un blocco e un blocco in un proc.

ho cambiato l'esempio in modo da mettere in relazione al vostro caso:

def run_my_code(&my_code) 
puts 'before proc' 
my_code.call 
puts 'after proc' 
end 
run_my_code { puts "passing a block, accepting a proc"; break} 
=> before proc 
    passing a block, accepting a proc 

Come si può vedere che non ha raggiunto il 'dopo proc'

def run_my_code 
yield 
end 
my_proc = Proc.new { puts "passing a proc instead of block"; break} 
run_my_code &my_proc 
=> passing a proc instead of block 
    LocalJumpError: break from proc-closure 
    from (pry):75:in `block in <main>' 

Nel suo secondo esempio si dispone un proc in risultato, il proc si interrompe da iterator e torna alla funzione test.

def iterator(&proc) 
    puts 'entering iterator' 
    proc.call 
    puts 'exiting iterator' 
end 

def test 
    puts 'before test' 
    iterator { puts 'entering proc'; break } 
    puts 'after test' 
end 

=>before test 
entering iterator 
entering proc 
after test 

Answer 3

ha a che fare con la differenza tra blocchi, procs e lambda - ei rispettivi ambiti.

ho scritto un post su di esso già nel 2009 che potreste trovare utili: http://www.leonardoborges.com/writings/2009/07/22/procs-lambdas-blocks-whats-the-difference/

Spero che questo aiuti.