Y combinator และการปรับหางเรียกให้เหมาะสม

คำจำกัดความของ Y combinator ใน F # คือ

let rec y f x = f (y f) x

f คาดว่าจะเป็นอาร์กิวเมนต์แรกที่มีความต่อเนื่องสำหรับปัญหาย่อยแบบเรียกซ้ำ การใช้ yf เป็นสิ่งต่อเนื่องเราจะเห็นว่า f จะถูกนำไปใช้กับการโทรติดต่ออย่างต่อเนื่องในขณะที่เราสามารถพัฒนาได้

let y f x = f (y f) x = f (f (y f)) x = f (f (f (y f))) x etc...

ปัญหาคือโครงร่างนี้ precludes โดยใช้การปรับ tail call ใด ๆ : แน่นอนว่าอาจมีการดำเนินการบางอย่างที่ค้างอยู่ใน f's ซึ่งในกรณีนี้เราไม่สามารถกลายพันธุ์ local stack frame ที่เกี่ยวข้องกับ f

ดังนั้น:

• ในด้านหนึ่งการใช้ Y combinator ต้องมีความต่อเนื่องที่แตกต่างกันอย่างชัดเจนกว่าฟังก์ชั่นของตัวเอง
• บน othe เพื่อใช้ TCO เราต้องการให้ไม่มีการดำเนินการที่ค้างอยู่ใน f และเรียก f เท่านั้น

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

คุณรู้วิธีใดบ้างที่จะสามารถปรับความสมดุลทั้งสองได้

ไม่และด้วยเหตุผลที่ดี IMHO

Y-combinator เป็นสิ่งก่อสร้างเชิงทฤษฎีและจำเป็นต้องทำแลมบ์ดาแคลคูลัสเท่านั้น (โปรดจำไว้ว่าไม่มีลูปในแคลคูลัสแลมบ์ดาหรือแลมบ์ดามีชื่อที่เราสามารถใช้เรียกซ้ำได้)

ด้วยเหตุนี้ combinator Y จึงน่าหลงใหลอย่างแท้จริง

แต่ : ไม่มีใครใช้ Y-combinator สำหรับการสอบถามซ้ำ! (ยกเว้นอาจจะเพื่อความสนุกเพื่อแสดงว่ามันใช้งานได้จริง)

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

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

ฉันไม่แน่ใจเกี่ยวกับคำตอบนี้อย่างสมบูรณ์ แต่มันเป็นสิ่งที่ดีที่สุดที่ฉันจะได้รับ

y combinator ขี้เกียจโดยเนื้อแท้ในภาษาที่เข้มงวดต้องเพิ่มความขี้เกียจด้วยตนเองโดยใช้ lambdas เสริม

let rec y f x = f (y f) x

ลักษณะความหมายของคุณเหมือนว่ามันจะต้องมีความเกียจคร้านในการสั่งซื้อที่จะยุติหรือ(y f)ข้อโต้แย้งที่ไม่เคยจะเสร็จสิ้นการประเมินและจะต้องมีการประเมินหรือไม่ว่าfใช้มัน TOC ในบริบทที่ขี้เกียจมีความซับซ้อนมากขึ้นและยิ่งไปกว่านั้นผลลัพธ์ของ(y f)การจัดองค์ประกอบฟังก์ชั่นซ้ำโดยไม่ต้องใช้แอพพลิเคชั่xน ฉันไม่แน่ใจว่าสิ่งนี้จำเป็นต้องใช้หน่วยความจำ O (n) โดยที่ n คือความลึกของการเรียกซ้ำ แต่ฉันสงสัยว่าคุณสามารถบรรลุ TOC ประเภทเดียวกับที่เป็นไปได้กับบางสิ่งเช่น (เปลี่ยนเป็น Haskell เพราะไม่รู้จริงๆ F #)

length acc []    = acc
length acc (a:b) = length (acc+1) b 

หากคุณไม่ทราบมาก่อนความแตกต่างระหว่างfoldlและfoldl'ในแฮสเค็ลล์อาจทำให้สถานการณ์มีความชัดเจน foldlเขียนตามที่ควรจะเป็นภาษากระตือรือร้น แต่แทนที่จะเป็น TOC ที่จริงแล้วมันแย่กว่าfoldrเพราะตัวเก็บเสียงนั้นมีขนาดใหญ่ที่ไม่สามารถประเมินได้บางส่วน (สิ่งนี้เกี่ยวข้องกับสาเหตุที่ทั้ง foldl และ foldl 'ไม่ทำงานในรายการอนันต์) ดังนั้นใน Haskell รุ่นล่าสุดที่foldl'เพิ่มเข้ามาซึ่งบังคับให้มีการประเมินการสะสมในแต่ละครั้งที่ฟังก์ชั่นเกิดขึ้นเพื่อให้แน่ใจว่าจะไม่มีการสร้างอันมหาศาล ฉันแน่ใจว่าhttp://www.haskell.org/haskellwiki/Foldr_Foldl_Foldl%27สามารถอธิบายสิ่งนี้ได้ดีกว่า I.