從其關聯的塊內遞歸地調用Ruby方法。任何其他方式？

Question

我想出這個：

def f x, &b 
    yield x, b 
end 
f 4 do |i, b| 
    p i 
    f i - 1, &b if i > 0 
end 

結果：

4 
3 
2 
1 
0 

有另一種方式？

Answer 1

這取決於你的實際代碼的細節，但是舉個例子，如果你事先給塊命名，你可以避免產生函數中的值和塊。例如：

def f(x, &b) 
    yield x 
end 

foo = lambda do |i| 
    p i 
    f(i-1,&foo) if i > 0 
end 
f(4,&foo) 

但是，我想找到一個更優雅的解決方案來解決這個問題。我懷疑這將是Y組合器的一個很好的應用。只要我有更好的東西給你，我會更新這條消息。

Answer 2

def f(x, &b) 
    b.call x 
    f(x-1,&b) if x>0 
end 

f(4) do |x| 
p x 
end 

Answer 3

塊可以遞歸調用自己，只要它存儲在塊本身可訪問的變量中。例如：

def f(x) 
    block = lambda do |y| 
    # some calculation on value, or simply yield to the block passed to f() 
    yield y 
    block.call(y - 1) if y > 0 
    end 
    block.call(x) 
end 

f(4) do |x| 
    puts "Yielded block: #{x}" 
end 

或者，您可以返回遞歸塊，綁定到調用者塊，然後調用該塊。例如：

def g 
    block = lambda do |y| 
    # some calculation on value, or simply yield to block passed to g() 
    yield y 
    block.call(y - 1) if y > 0 
    end 
end 

printing_descender = g do |x| 
    puts "Encapsulated block: #{x}" 
end 
printing_descender.call(4) 

輸出：

Yielded block: 4 
Yielded block: 3 
Yielded block: 2 
Yielded block: 1 
Yielded block: 0 
Encapsulated block: 4 
Encapsulated block: 3 
Encapsulated block: 2 
Encapsulated block: 1 
Encapsulated block: 0 

Answer 4

馬特的回答是好。它也是實現從深度遞歸搜索立即返回的唯一方法。請注意，從塊中返回實際上是從調用函數返回的。一舉解除所有遞歸塊調用。

Answer 5

有很多方法可以使用callcc或catch/throw（它總是可以從深度遞歸調用返回）執行此操作。這裏是使用線程局部變量的非高爾夫版本

def f x, &b 
    t = Thread.current 
    t[:b] ||= b 
    b ||= t[:b] 
    b.call(x) 
ensure 
    t[:b] = nil 
end 

f 4 do |i| 
    p i 
    f i - 1 if i > 0 
end