¿Por qué la declaración de interrupción en ruby ​​se comporta de manera diferente cuando se utiliza Proc.new v. El signo de ampersand?

Question

La sentencia break para los bloques (según The Ruby Programming Language) se define de la siguiente manera:

que hace que el bloque de volver a su repetidor y el repetidor para volver al método que se invoca.

Por lo tanto, cuando se ejecuta el siguiente código, se produce 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 

Mientras que el código siguientes no hace lanzar una LocalJumpError. ¿Qué tiene de especial el signo de ampersand? ¿El signo ampersand no usa implícitamente 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 

En otras palabras, leo el signo de ampersand como un medio de alinear la llamada Proc.new. En ese punto, el comportamiento debería ser el mismo que el primer fragmento de código.

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

Negación: estoy Novato aprendizaje de la lengua (rubí 1.9.2), y por lo tanto a apreciar las referencias y una sinopsis detallada.

Answer 1

break hace que el bloque y la persona que llama del retorno bloque. En el siguiente código:

proc = Proc.new { break } 

El "Llamada" del bloque que se convierte en un objeto Proc es Proc.new. Se supone que break hace que regrese la persona que llama del bloque, pero Proc.new ya ha regresado.

En este código:

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

El llamador del bloque es iterator, así que tiene iterator retorno.

Answer 2

Aquí está el answer.

Ampersand se utiliza para convertir un proceso a un bloque y un bloque a un proceso.

me cambió el ejemplo con el fin de relacionarse con su 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 

Como se puede ver que no alcanzó la 'después 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>' 

En el segundo ejemplo tiene un proceso en el resultado, el proceso se rompe desde iterator y vuelve a la función 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

Tiene que ver con la diferencia entre bloques, procs y lambdas - y sus respectivos ámbitos.

escribí un post sobre ello en el 2009 que le puede resultar útil: http://www.leonardoborges.com/writings/2009/07/22/procs-lambdas-blocks-whats-the-difference/

Espero que esto ayude.