Como é chamado esse tipo de “recursão” mútua?

Question

Meu problema é com um certo estilo de código que se assemelha muito à recursão, mas não é bastante que.A recursão é, para citar Wikipédia, "um método de definição de funções em que a função que está sendo definida é aplicada dentro de sua própria definição".Da mesma forma, a recursão mútua aplica outra função que, direta ou indiretamente, aplica a função que estamos definindo.

O problema é que o código que estou pensando e com o qual estou lidando não usa a mesma função!Ele usa o mesmo código em outra função (como método ou fechamento).

O problema aqui é que embora meu código seja o mesmo, as funções não são.Dê uma olhada no seguinte exemplo básico de recursão mútua:

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)

Isso é um tanto intuitivo e claramente mutuamente recursivo.No entanto, se eu agrupar cada função como uma função interna criada uma vez a cada chamada, fica 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)

Desconsiderando otimizações como memoização implícita, etc., isso produz uma cadeia de chamadas de função que não é estritamente recursiva, criando e chamando várias novas funções sem nunca chamar a mesma duas vezes.No entanto, todas estas funções seguem um modelo comum e são apenas a mesma função criada repetidamente (possivelmente com diferentes variáveis ​​livres).

E, novamente, podemos criar uma implementação diretamente equivalente (afinal, as classes são apenas fechamentos, certo;) usando classes.Isto é especialmente significativo, uma vez que este estilo de [insira o nome aqui] é usado, por exemplo, no Padrão Composto.A diferença é que com o padrão de design Composite e a maioria dos usos (até mesmo dos encerramentos), as instâncias geralmente não são criadas dinamicamente.Ainda é essencialmente o mesmo.

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)

Desta vez a cadeia é de criação de objetos e chamadas de métodos, mas o princípio é o mesmo. (Na verdade, eu observaria que é um pouco diferente, pois o Python define um wrapper simples por objeto, que chama a mesma função todas as vezes - mas isso não é necessariamente algo que precisamos saber, e não acontece precisa ser verdadeiro para outras implementações de classes e objetos.Mas sim, estritamente falando é mutuamente recursivos, bem como ...algo mais, e é aquela outra coisa que eu quero saber.)

Answer 1

Como você aponta, isso ainda é recursão mútua.Não acho que o "algo mais" que você está perguntando tenha nome;se isso acontecer, eu nunca ouvi isso.

Answer 2

A recursão mútua é apenas um caso especial de recursão indireta.

Answer 3

Aparentemente, é chamado Recursão Mútua :)

O artigo ainda dá o mesmo exemplo que você, com odd? e even? funções.