เหตุใดฟังก์ชันใน F # และ Ocaml (และอาจเป็นภาษาอื่น ๆ ) จึงไม่เรียกใช้ซ้ำตามค่าเริ่มต้น
กล่าวอีกนัยหนึ่งว่าเหตุใดนักออกแบบภาษาจึงตัดสินใจว่าควรกำหนดให้คุณพิมพ์recคำประกาศอย่างชัดเจนเช่น:
let rec foo ... = ...
และไม่ให้ฟังก์ชันเรียกซ้ำตามค่าเริ่มต้น? ทำไมต้องมีrecโครงสร้างที่ชัดเจน?
คำตอบ:
ลูกหลานชาวฝรั่งเศสและอังกฤษของ ML ดั้งเดิมได้เลือกทางเลือกที่แตกต่างกันและทางเลือกของพวกเขาได้รับการสืบทอดมาหลายทศวรรษจนถึงรูปแบบที่ทันสมัย ดังนั้นนี่เป็นเพียงมรดก แต่ส่งผลต่อสำนวนในภาษาเหล่านี้
ฟังก์ชันจะไม่เรียกซ้ำตามค่าเริ่มต้นในกลุ่มภาษาฝรั่งเศส CAML (รวมถึง OCaml) ตัวเลือกนี้ทำให้ง่ายต่อการใช้คำจำกัดความของฟังก์ชัน (และตัวแปร) โดยใช้letในภาษาเหล่านั้นมากเนื่องจากคุณสามารถอ้างถึงคำจำกัดความก่อนหน้าภายในเนื้อหาของคำจำกัดความใหม่ F # สืบทอดไวยากรณ์นี้จาก OCaml
ตัวอย่างเช่นการใช้ฟังก์ชัน superceding pเมื่อคำนวณเอนโทรปีของ Shannon ของลำดับใน OCaml:
let shannon fold p =
let p x = p x *. log(p x) /. log 2.0 in
let p t x = t +. p x in
-. fold p 0.0
สังเกตว่าอาร์กิวเมนต์pของshannonฟังก์ชันลำดับที่สูงกว่าจะถูกแทนที่ด้วยอีกรายการหนึ่งpในบรรทัดแรกของเนื้อหาอย่างไรpในบรรทัดที่สองของเนื้อหาอย่างไร
ในทางกลับกันสาขา SML ของอังกฤษของกลุ่มภาษา ML ได้ใช้ตัวเลือกอื่นและfunฟังก์ชัน -bound ของ SML จะเรียกซ้ำตามค่าเริ่มต้น เมื่อนิยามฟังก์ชันส่วนใหญ่ไม่จำเป็นต้องเข้าถึงการเชื่อมโยงก่อนหน้าของชื่อฟังก์ชันผลลัพธ์นี้จะทำให้โค้ดง่ายขึ้น แต่ฟังก์ชั่นแทนที่จะทำเพื่อให้ใช้ชื่อที่แตกต่างกัน ( f1, f2ฯลฯ ) ซึ่งเป็นมลพิษขอบเขตและทำให้มันเป็นไปได้ที่จะเผลอเรียกผิด "รุ่น" ของฟังก์ชั่น และตอนนี้จะมีความแตกต่างระหว่างปริยาย-recursive funฟังก์ชั่น -bound และไม่ใช่ recursive valฟังก์ชั่น -bound
Haskell ทำให้สามารถอนุมานการอ้างอิงระหว่างคำจำกัดความได้โดย จำกัด ให้บริสุทธิ์ ทำให้ตัวอย่างของเล่นดูเรียบง่ายขึ้น แต่มีราคาแพงกว่าที่อื่น
สังเกตว่าคำตอบที่พระพิฆเนศและเอ็ดดี้ให้ไว้คือปลาชนิดหนึ่งสีแดง พวกเขาอธิบายว่าเหตุใดกลุ่มของฟังก์ชันจึงไม่สามารถวางไว้ในยักษ์ได้let rec ... and ...เนื่องจากมีผลต่อเมื่อตัวแปรประเภทได้รับการทำให้เป็นแบบทั่วไป สิ่งนี้ไม่เกี่ยวข้องกับrecการเป็นค่าเริ่มต้นใน SML แต่ไม่ใช่ OCaml
เหตุผลสำคัญประการหนึ่งสำหรับการใช้ไฟล์ recคือการใช้การอนุมานประเภท Hindley-Milner ซึ่งอยู่ภายใต้ภาษาการเขียนโปรแกรมเชิงฟังก์ชันที่พิมพ์แบบคงที่ทั้งหมด (แม้ว่าจะมีการเปลี่ยนแปลงและขยายในรูปแบบต่างๆ)
หากคุณมีคำจำกัดความlet f x = xคุณคาดว่าจะมีประเภท'a -> 'aและสามารถใช้ได้กับ'aประเภทต่างๆในจุดต่างๆ แต่ถ้าคุณเขียนlet g x = (x + 1) + ...คุณคาดหวังว่าxจะได้รับการปฏิบัติเหมือนเป็นintส่วนที่เหลือของเนื้อหาgในส่วนที่เหลือของร่างกายของ
วิธีที่การอนุมานของ Hindley-Milner เกี่ยวข้องกับความแตกต่างนี้คือผ่านขั้นตอนการวางนัยทั่วไปอย่างชัดเจน ในบางจุดเมื่อประมวลผลโปรแกรมของคุณระบบประเภทจะหยุดและพูดว่า "ตกลงประเภทของคำจำกัดความเหล่านี้จะได้รับการสรุปโดยทั่วไป ณ จุดนี้ดังนั้นเมื่อมีคนใช้ตัวแปรประเภทฟรีใด ๆ ในประเภทของพวกเขาจะสดใหม่สร้างอินสแตนซ์ดังนั้น จะไม่รบกวนการใช้งานอื่น ๆ ของคำจำกัดความนี้ "
ปรากฎว่าสถานที่ที่เหมาะสมในการทำลักษณะทั่วไปนี้คือหลังจากตรวจสอบชุดฟังก์ชันที่เรียกซ้ำซึ่งกันและกัน ก่อนหน้านี้และคุณจะสรุปมากเกินไปจนนำไปสู่สถานการณ์ที่ประเภทต่างๆอาจชนกัน ในภายหลังและคุณจะสรุปน้อยเกินไปทำให้คำจำกัดความที่ไม่สามารถใช้กับอินสแตนซ์ประเภทต่างๆได้
ดังนั้นเนื่องจากตัวตรวจสอบประเภทจำเป็นต้องทราบเกี่ยวกับชุดคำจำกัดความที่เรียกซ้ำร่วมกันมันสามารถทำอะไรได้บ้าง? ความเป็นไปได้อย่างหนึ่งคือทำการวิเคราะห์การพึ่งพาคำจำกัดความทั้งหมดในขอบเขตและจัดลำดับใหม่เป็นกลุ่มที่เล็กที่สุดเท่าที่จะเป็นไปได้ Haskell ทำสิ่งนี้จริง แต่ในภาษาเช่น F # (และ OCaml และ SML) ซึ่งมีผลข้างเคียงที่ไม่ จำกัด นี่เป็นความคิดที่ไม่ดีเพราะอาจจัดลำดับผลข้างเคียงใหม่ด้วย ดังนั้นแทนที่จะขอให้ผู้ใช้ทำเครื่องหมายอย่างชัดเจนว่าคำจำกัดความใดที่เกิดซ้ำร่วมกันและด้วยส่วนขยายที่ควรเกิดการวางนัยทั่วไป
recแต่ SML ไม่ได้เป็นตัวอย่างที่ชัดเจน หากการอนุมานประเภทเป็นปัญหาด้วยเหตุผลที่คุณอธิบาย OCaml และ SML ไม่สามารถเลือกวิธีแก้ปัญหาที่แตกต่างกันได้ แน่นอนว่าเหตุผลก็คือคุณกำลังพูดถึงandเพื่อให้ Haskell มีความเกี่ยวข้อง
มีเหตุผลสำคัญสองประการที่เป็นความคิดที่ดี:
ขั้นแรกหากคุณเปิดใช้งานคำจำกัดความแบบเรียกซ้ำคุณจะไม่สามารถอ้างถึงการเชื่อมโยงก่อนหน้าของค่าที่มีชื่อเดียวกันได้ นี่มักจะเป็นสำนวนที่มีประโยชน์เมื่อคุณทำบางอย่างเช่นการขยายโมดูลที่มีอยู่
ประการที่สองค่าที่เกิดซ้ำและโดยเฉพาะอย่างยิ่งชุดของค่าที่เกิดซ้ำซึ่งกันและกันนั้นยากกว่ามากที่จะให้เหตุผลเกี่ยวกับคำจำกัดความที่ดำเนินไปตามลำดับซึ่งแต่ละคำนิยามใหม่จะสร้างขึ้นเหนือสิ่งที่ได้กำหนดไว้ เป็นการดีเมื่ออ่านโค้ดดังกล่าวเพื่อให้มีการรับประกันว่ายกเว้นคำจำกัดความที่ระบุไว้อย่างชัดเจนว่าเป็นแบบเรียกซ้ำคำจำกัดความใหม่สามารถอ้างถึงคำจำกัดความก่อนหน้านี้เท่านั้น
บางส่วนเดา:
letไม่เพียงใช้เพื่อผูกฟังก์ชันเท่านั้น แต่ยังรวมถึงค่าปกติอื่น ๆ ด้วย รูปแบบของค่าส่วนใหญ่ไม่ได้รับอนุญาตให้เรียกซ้ำ อนุญาตให้ใช้ค่าแบบวนซ้ำบางรูปแบบได้ (เช่นฟังก์ชันการแสดงออกที่ขี้เกียจ ฯลฯ ) ดังนั้นจึงต้องมีไวยากรณ์ที่ชัดเจนเพื่อระบุสิ่งนี้letสร้างคล้ายกับletการสร้างเสียงกระเพื่อมและโครงการ; ซึ่งไม่เกิดซ้ำ มีโครงสร้างแยกต่างหากletrecใน Scheme สำหรับการเรียกซ้ำ Let'slet rec xs = 0::ys and ys = 1::xsที่คุณสามารถทำได้
ให้สิ่งนี้:
let f x = ... and g y = ...;;
เปรียบเทียบ:
let f a = f (g a)
ด้วยสิ่งนี้:
let rec f a = f (g a)
อดีตนิยามใหม่fที่จะใช้ที่กำหนดไว้ก่อนหน้านี้fถึงผลของการใช้เพื่อg aคำจำกัดความหลังใหม่fให้ใช้ loop ตลอดgไปaซึ่งโดยปกติจะไม่ใช่สิ่งที่คุณต้องการในตัวแปร ML
ที่กล่าวว่ามันเป็นสไตล์ของนักออกแบบภาษา เพียงแค่ไปกับมัน
ส่วนใหญ่คือช่วยให้โปรแกรมเมอร์สามารถควบคุมความซับซ้อนของขอบเขตในพื้นที่ได้มากขึ้น สเปกตรัมของlet, let*และlet recข้อเสนอในระดับที่เพิ่มขึ้นของทั้งพลังงานและค่าใช้จ่าย let*และlet recอยู่ในเวอร์ชันที่ซ้อนกันของ Simpleletดังนั้นการใช้อย่างใดอย่างหนึ่งจึงมีราคาแพงกว่า การให้คะแนนนี้ช่วยให้คุณปรับแต่งการเพิ่มประสิทธิภาพโปรแกรมของคุณได้ในระดับเล็กเพราะคุณสามารถเลือกระดับที่คุณต้องการสำหรับงานในมือได้ หากคุณไม่ต้องการการเรียกซ้ำหรือความสามารถในการอ้างถึงการเชื่อมโยงก่อนหน้านี้คุณสามารถถอยกลับไปง่ายๆเพื่อประหยัดประสิทธิภาพเล็กน้อย
คล้ายกับเพรดิเคตความเท่าเทียมกันที่ให้คะแนนใน Scheme (เช่นeq?, eqv?และequal?)