Что это - вид взаимной названной “рекурсии”?

Моя проблема с определенным стилем кода, так очень напоминает рекурсию, но не вполне это. Рекурсия, для заключения в кавычки Википедии, "метод определения функционирует, в котором определяемая функция применяется в рамках ее собственного определения". Столь же взаимная рекурсия применяет другую функцию, которая, прямо или косвенно, применяет функцию, которую мы определяем.

Проблема состоит в том, что код я думаю и имею дело с, не использует ту же функцию! Это использует тот же код в другой функции (как метод или закрытие).

Проблема здесь состоит в том, что, в то время как мой код является тем же, функции не. Смотрите следующий основной взаимный пример рекурсии:

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)

Это несколько интуитивно, и очень ясно взаимно рекурсивно. Однако, если я оборачиваю каждую функцию как внутреннюю функцию, которая создается один раз в вызов, она разбирается меньше:

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)

Игнорируя оптимизацию как неявный memoization и т.д., это производит цепочку вызовов функции, которая не является строго рекурсивной, создавая и вызывая различные новые функции, никогда не называя того же дважды. Тем не менее, все эти функции следуют за общим шаблоном и являются просто той же функцией, созданной много раз (возможно с различными свободными переменными.

И снова, мы можем придумать непосредственно эквивалентное (в конце концов, классы являются действительно просто закрытиями, правом ;) реализация с помощью классов. Это особенно значительно, начиная с этого стиля [вставляют имя здесь], используется в, например, Составной Шаблон. Различие - то, что с Составным шаблоном разработки и большей частью использования (даже закрытий), экземпляры обычно не создаются на лету. Это - все еще по существу то же.

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)

На этот раз цепочка имеет создание объекта и вызовы метода, но принцип является тем же. (Я на самом деле отметил бы, что это немного отличается, в том, что Python определяет простую обертку на основе на объект, которая самой вызывает ту же самую функцию каждый раз - но это - не обязательно что-то, что мы должны знать, и это не должно быть верно для других реализаций классов и объектов. Но да, строго говоря это взаимно рекурсивно, а также... что-то больше, и именно, что другая вещь я хочу знать.)