Llamar a un método de Ruby recursivamente desde dentro de su bloque asociado. ¿Cualquier otra manera?

Question

Yo he llegado con esto:

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

Resultado:

4 
3 
2 
1 
0 

¿Hay otra manera?

Answer 1

Depende de los detalles de su código real, pero dado su ejemplo, si nombra el bloque de antemano, puede evitar dar el valor y el bloqueo en su función. Por ejemplo:

def f(x, &b) 
    yield x 
end 

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

Sin embargo, me gustaría encontrar una solución más elegante a este problema. Sospecho que esta sería una buena aplicación del combinador Y. Tan pronto como tenga algo mejor para ti, actualizaré este mensaje.

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

Un bloque puede llamarse de forma recursiva siempre que esté almacenado en una variable a la que pueda acceder el bloque. Por ejemplo:

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 

Alternativamente, puede volver al bloque recursiva, con destino a las personas que llaman bloquear y luego llamar a ese bloque. Por ejemplo:

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) 

Salidas:

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

respuesta de Matt es buena. También es la única forma de implementar un retorno inmediato de una búsqueda recursiva profunda. Tenga en cuenta que al regresar del bloque en realidad regresa de la función de invocación. desenrollando todas las llamadas de bloque recursivas de una sola vez.

Answer 5

hay muchas formas de hacerlo usando callcc o catch/throw (que siempre puede regresar de llamadas recursivas profundas). aquí está la versión no golfística que utiliza los vars locales del hilo

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