ดูเหมือนว่าฉันได้พบวิธีทั่วไปในการแปลงขั้นตอนการเรียกซ้ำใด ๆ เป็นการเรียกซ้ำแบบหาง:

1. กำหนดกระบวนการย่อยผู้ช่วยด้วยพารามิเตอร์ "ผลลัพธ์" พิเศษ
2. ใช้สิ่งที่จะนำไปใช้กับค่าส่งคืนของโพรซีเดอร์กับพารามิเตอร์นั้น
3. เรียกขั้นตอนผู้ช่วยนี้เพื่อเริ่มต้น ค่าเริ่มต้นสำหรับพารามิเตอร์ "result" คือค่าสำหรับจุดออกของกระบวนการซ้ำเพื่อให้กระบวนการวนซ้ำผลลัพธ์เริ่มต้นจากจุดที่กระบวนการวนซ้ำเริ่มหดตัว

ตัวอย่างเช่นต่อไปนี้เป็นขั้นตอนการเรียกซ้ำแบบดั้งเดิมที่จะทำการแปลง ( 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))))

นี่คือขั้นตอนการแปลงแบบเรียกซ้ำ (tail-recursive) ( 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
• เมื่อรวมกับthunking และ trampoliningสามารถใช้เพื่อเพิ่มประสิทธิภาพการโทรแบบหางในภาษาที่ไม่ได้มีการเพิ่มประสิทธิภาพการโทรแบบหาง (การปรับ tail-call ของฟังก์ชั่น tail-recursive โดยตรงสามารถทำได้โดยใช้วิธีอื่นเช่นการแปลงการเรียกแบบเรียกซ้ำไปเป็นลูป แต่การเรียกทางอ้อมนั้นไม่เป็นการแปลงในลักษณะนี้)
• ด้วย CPS การต่อเนื่องกลายเป็นวัตถุชั้นหนึ่ง เนื่องจากความต่อเนื่องเป็นหัวใจสำคัญของการควบคุมสิ่งนี้ทำให้ผู้ปฏิบัติงานควบคุมแทบทุกคนสามารถนำไปใช้เป็นห้องสมุดโดยไม่ต้องการการสนับสนุนพิเศษจากภาษา ตัวอย่างเช่น goto, ข้อยกเว้นและเธรดสหกรณ์สามารถสร้างแบบจำลองโดยใช้การดำเนินการต่อเนื่อง

TCO

สำหรับฉันแล้วดูเหมือนว่าเหตุผลเดียวที่เกี่ยวข้องกับการเรียกแบบ tail-recursion (หรือการเรียกแบบ tail-tail ทั่วไป) นั้นมีวัตถุประสงค์เพื่อการเพิ่มประสิทธิภาพ tail-call (TCO) ดังนั้นฉันคิดว่าคำถามที่ดีกว่าที่จะถามคือ "รหัสอัตราผลตอบแทนการแปลงของฉันที่เรียกได้ว่าเหมาะสมที่สุดหรือไม่"

หากเราพิจารณา CPS อีกครั้งหนึ่งในคุณสมบัติของมันคือรหัสที่แสดงออกใน CPS ประกอบด้วยการโทรหางเท่านั้น เนื่องจากทุกอย่างเป็นการโทรแบบหางเราไม่จำเป็นต้องบันทึกจุดกลับไปที่สแต็ก ดังนั้นรหัสทั้งหมดในรูปแบบ CPS จะต้องได้รับการเพิ่มประสิทธิภาพการโทรหางใช่ไหม

ก็ไม่มาก คุณเห็นในขณะที่มันอาจปรากฏว่าเราได้กำจัดสแต็คทั้งหมดที่เราทำคือเพียงเปลี่ยนวิธีที่เราเป็นตัวแทน ตอนนี้สแต็กเป็นส่วนหนึ่งของการปิดที่แสดงถึงความต่อเนื่อง ดังนั้น CPS จึงไม่ทำให้การโทรหางของเรามีประสิทธิภาพสูงสุด

ดังนั้นถ้า CPS ไม่สามารถทำทุกอย่าง TCO มีการแปลงเฉพาะสำหรับการเรียกซ้ำโดยตรงที่สามารถทำได้หรือไม่? ไม่ไม่โดยทั่วไป การเรียกซ้ำบางครั้งเป็นแบบเส้นตรง แต่บางแบบไม่ใช่ การเรียกซ้ำแบบไม่เป็นเชิงเส้น (เช่นต้นไม้) จะต้องรักษาจำนวนตัวแปรของสถานะไว้ที่ใดที่หนึ่ง