Lo que es este tipo de “recursividad” mutua llama?

Question

Mi problema es con un cierto estilo de código que se asemeja mucho a la recursividad, pero no es muy que. La recursión es, para citar Wikipedia ", se aplica un método de funciones que definen en el que se define la función de dentro de su propia definición". Del mismo modo recursión mutua corresponde otra función que, directa o indirectamente, se aplica la función que estamos definiendo.

El problema es que el código que piense de, y tratando, no utiliza la misma función! Se utiliza el mismo código en otra función (como un método o cierre).

El problema aquí es que mientras mi código es el mismo, las funciones no están. Echar un vistazo a la siguiente ejemplo básico recursión mutua:

def is_even(x):
    if x == 0:
        return True
    else:
        return is_odd(x - 1)

def is_odd(x):
    if x == 0:
        return False
    else:
        return is_even(x - 1)

Esto es algo intuitivo, y muy claramente mutuamente recursivo. Sin embargo, si envuelvo cada función como una función interna que se crea una vez cada llamada, se vuelve menos claro:

def make_is_even(): 
    def is_even(x):
        if x == 0:
            return True
        else:
           return make_is_odd()(x - 1)
    return is_even

def make_is_odd(): 
    def is_odd(x):
        if x == 0:
            return False
        else:
            return make_is_even()(x - 1)
    return is_odd

def is_even2(x):
    return make_is_even()(x)

def is_odd2(x):
    return make_is_odd()(x)

Haciendo caso omiso de optimizaciones como memoization implícita etc., esto produce una cadena de llamadas a funciones que no sea estrictamente recursiva, crear y llamar a varias nuevas funciones sin tener que llamar a la misma dos veces. No obstante todas estas funciones siguen un modelo común, y son de la misma función creada una y otra vez (posiblemente con diferentes variables libres.

Y una vez más, podemos llegar a un equivalente directo (después de todo, las clases son en realidad los cierres, a la derecha;) aplicación usando clases. Esto es especialmente significativo, ya que este estilo de [insertar nombre aquí] se utiliza en, por ejemplo, la patrón Composite . La diferencia es que con el patrón de diseño compuesto, y la mayoría de los usos (incluso de los cierres), las instancias son por lo general no crean sobre la marcha. Todavía es esencialmente el mismo.

class EvenChecker(object):
    def check(self, x):
        if x == 0:
            return True
        else:
            return OddChecker().check(x - 1)

class OddChecker(object):
    def check(self, x):
        if x == 0:
            return False
        else:
            return EvenChecker().check(x - 1)

def is_even3(x):
    return EvenChecker().check(x)

def is_odd3(x):
    return OddChecker().check(x)

Esta vez, la cadena es de creación de objetos y llamadas de método, pero el principio es el mismo. (De hecho, me cuenta que es un poco diferente, en la que Python define un contenedor simple en un objeto por objeto que a su vez llama a la misma función de cada tiempo-- pero esto no es necesariamente algo que necesitamos saber, y no tiene por qué ser cierto para otras implementaciones de clases y objetos. Pero sí, estrictamente hablando es mutuamente recursivo, así como ... algo más, y es esa otra cosa que quiero saber.)

Answer 1

Como usted señala, esto sigue siendo recursión mutua. No creo que el "algo más" que estás preguntando acerca tiene un nombre; si lo hace nunca he oído a él.

Answer 2

recursión mutua es sólo un caso especial de la repetición indirecta .

Answer 3

Al parecer, se llama Mutua recursividad :)

El artículo incluso da el mismo ejemplo que usted, con funciones odd? y even?.