Zrozumienie powracania z proców w Rubim

Question

Zastanawiam się, jak przekazać blok do metody, która uczyni metodę return na yield.

Naiwny aproach nie działa:

def run(&block) 
    block.call 
end 

run { return :foo } # => LocalJumpError 

owijania w innym proc ma ten sam efekt:

def run(&block) 
    proc { block.call }.call 
end 

run { return :bar } # => LocalJumpError 

więc pomyślałem, że oświadczenie return jest związany z receiver prądu binding. Jednakże, próbując go z instance_eval okazał mi źle:

class ProcTest 
    def run(&block) 
    puts "run: #{[binding.local_variables, binding.receiver]}" 
    instance_eval(&block) 
    end 
end 

pt = ProcTest.new 
binding_inspector = proc { puts "proc: #{[binding.local_variables, binding.receiver]}" } 
puts "main: #{[binding.local_variables, binding.receiver]}" 
    # => main: [[:pt, :binding_inspector], main] 
binding_inspector.call 
    # => proc: [[:pt, :binding_inspector], main] 
pt.run(&binding_inspector) 
    # => run: [[:block], #<ProcTest:0x007f4987b06508>] 
    # => proc: [[:pt, :binding_inspector], #<ProcTest:0x007f4987b06508>] 
pt.run { return :baz } 
    # => run: [[:block], #<ProcTest:0x007f4987b06508>] 
    # => LocalJumpError 

więc pytania są:

1. Jak można to zrobić?
2. W jaki sposób kontekst powrotu jest powiązany z instrukcją return. Czy to połączenie jest dostępne za pośrednictwem interfejsu API języka?
3. Czy zostało to celowo wdrożone w taki sposób? Jeśli tak, dlaczego? Jeśli nie - jakie są przeszkody, aby to naprawić?

Answer 1

return w bloku zwraca z otaczającej metody, gdy blok jest zdefiniowany (tj. Zamknięcie, w którym blok jest tworzony). W twoim przykładzie nie ma zamkniętego bloku, z którego można by powrócić, stąd twój wyjątek.

to łatwo wykazać:

def foo(&block) 
    puts yield 
    puts "we won't get here" 
end 

def bar 
    foo { return "hi from the block"; puts "we never get here" } 
    puts "we never get here either" 
end 

puts bar # => "hi from the block" (only printed once; the puts in `foo` is not executed) 

powrotny w proc natychmiast powrócić z proc, a nie z tym sposobem na stosie pod proc:

def foo(&block) 
    puts yield 
    puts "we will get here" 
end 

def bar 
    foo &->{ return "hi from the proc"; puts "we never get here" } 
    puts "we will get here too" 
end 

puts bar 
# hi from the proc  # puts from foo 
# we will get here  # puts from foo 
# we will get here too # puts from bar 

powodu tych zachowań, nie ma sposobu osiągnięcia pożądanego zachowania, w którym return w danym bloku będzie wykonywał return w metodzie, z której blok jest wywoływany, chyba że blok został zdefiniowany w tym zakresie, ponieważ wymagałoby to jednego z istniejące zachowania nie działają.

Można osiągnąć coś takiego z rzutów ... CATCH, która jest trochę-jakoś użyteczny jako sposób na zip stos z dowolnej głębokości, ale nie można powrócić dowolne wartości z nim:

def foo(&block) 
    yield 
    puts "we won't get here" 
end 

catch(:escape) do 
    foo &->{ throw :escape } 
end 

Answer 2

Myślałem, że oświadczenie return jest związany z receiver bieżącego binding.

Tylko metody mają odbiornik.return nie jest metoda:

defined? return #=> "expression" 

Próbuje wywołać go jako metoda nie działa:

def foo 
    send(:return, 123) 
end 

foo #=> undefined method `return' 

próbuje ją z instance_eval okazał mi źle

Choć instance_eval ocenia blok w kontekście odbiornika (dzięki czemu masz dostęp do metod instancji odbiorników i zmiennych instancji):

class MyClass 
    def foo(&block) 
    @var = 123 
    instance_eval(&block) 
    end 
end 

MyClass.new.foo { instance_variables } 
#=> [:@var] 

... robi nie ocenić bloku w bieżącym wiązania (więc nie ma dostępu do żadnych zmiennych lokalnych):

class MyClass 
    def foo(&block) 
    var = 123 
    instance_eval(&block) 
    end 
end 

MyClass.new.foo { local_variables } 
#=> [] 

Jak można to zrobić ?

Można użyć eval, ale to wymaga ciąg:

def foo 
    var = 123 
    eval yield 
    nil 
end 

foo { "return var * 2" } 
#=> 246 

lub przepuszczanie wiązanie do bloku (znowu przy użyciu eval):

def foo 
    var = 123 
    yield binding 
    nil 
end 

foo { |b| b.eval "return var * 2" } 
#=> 246