Здається, я знайшов загальний спосіб перетворити будь-яку рекурсивну процедуру в хвостову рекурсію:

1. Визначте допоміжну допоміжну процедуру з додатковим параметром "результат".
2. Застосуйте те, що було б застосовано до зворотного значення процедури до цього параметра.
3. Для початку зателефонуйте на цю процедуру допомоги. Початкове значення параметра "результат" - це значення для точки виходу рекурсивного процесу, так що отриманий ітераційний процес починається з того місця, де рекурсивний процес починає скорочуватися.

Наприклад, ось оригінальна рекурсивна процедура, яку потрібно перетворити ( SICP, вправа 1.17 ):

(define (fast-multiply a b)
  (define (double num)
    (* num 2))
  (define (half num)
    (/ num 2))
  (cond ((= b 0) 0)
        ((even? b) (double (fast-multiply a (half b))))
        (else (+ (fast-multiply a (- b 1)) a))))

Ось перетворена хвостово-рекурсивна процедура ( вправа SICP 1.18 ):

(define (fast-multiply a b)
  (define (double n)
    (* n 2))
  (define (half n)
    (/ n 2))
  (define (multi-iter a b product)
    (cond ((= b 0) product)
          ((even? b) (multi-iter a (half b) (double product)))
          (else (multi-iter a (- b 1) (+ product a)))))
  (multi-iter a b 0))

Хтось може це довести чи спростувати?

Ваш опис алгоритму дійсно занадто розпливчастий, щоб оцінити його на даний момент. Але, ось деякі речі слід врахувати.

CPS

Насправді, існує спосіб перетворити будь-який код у форму, яка використовує лише хвостові дзвінки. Це перетворення CPS. CPS ( стиль продовження передачі ) - це форма вираження коду, передаючи кожній функції продовження. Продовження - це абстрактне поняття, що представляє "решту обчислень". У коді, вираженому у формі CPS, природний спосіб повторити продовження - це функція, яка приймає значення. У CPS замість функції, яка повертає значення, вона замість цього застосовує функцію, що представляє поточне продовження, до того, що функція "повертається".

Наприклад, розглянемо таку функцію:

(lambda (a b c d)
  (+ (- a b) (* c d)))

Це можна виразити в CPS так:

(lambda (k a b c d)
  (- (lambda (v1)
       (* (lambda (v2)
            (+ k v1 v2))
          a b))
     c d))

Це некрасиво і часто повільно, але має певні переваги:

• Перетворення може бути повністю автоматизованим. Тому немає необхідності писати (або бачити) код у формі CPS.
• У поєднанні з громом та батутом , це може бути використано для забезпечення оптимізації виклику хвостами мовами, які не забезпечують оптимізацію хвостових викликів. (Оптимізація хвостових викликів безпосередньо хвостово-рекурсивних функцій може бути здійснена за допомогою інших засобів, таких як перетворення рекурсивного виклику в цикл. Але непряма рекурсія не настільки тривіальна для перетворення таким чином.)
• З CPS продовження перетворюються на першокласні об'єкти. Оскільки продовження є сутністю управління, це дозволяє практично будь-якому оператору управління реалізовуватися як бібліотека, не вимагаючи особливої ​​підтримки з боку мови. Наприклад, гото, винятки та кооперативна нитка можуть бути змодельовані за допомогою продовження.

ТСО

Мені здається, що єдиною причиною турбуватися з рекурсією хвоста (або взагалі закликами хвоста) є цілі оптимізації хвостових викликів (TCO). Тож я думаю, що краще задати питання: "чи мій код вихідної трансформації, який можна оптимізувати?"

Якщо ми ще раз розглянемо CPS, одна з її характеристик полягає в тому, що код, виражений у CPS, складається виключно з хвостових викликів. Оскільки все є хвостиком, нам не потрібно зберігати точку повернення до стеку. Таким чином, весь код у формі CPS повинен бути оптимізований для зворотного дзвінка, правда?

Ну, не зовсім. Розумієте, хоча може здатися, що ми усунули стек, все, що ми зробили, - це просто змінити спосіб їх представлення. Стек тепер є частиною закриття, що представляє собою продовження. Таким чином, CPS не робить магічним чином оптимізований весь наш код.

Отже, якщо CPS не може зробити все TCO, чи існує трансформація спеціально для прямої рекурсії, яка може? Ні, не взагалі. Деякі рекурсії є лінійними, але деякі - ні. Нелінійні (наприклад, дерево) рекурсії просто повинні десь підтримувати змінну кількість стану.