เหตุใดการเขียนคอมไพเลอร์ในภาษาที่ใช้งานได้จึงง่ายกว่า [ปิด]

ฉันคิดถึงคำถามนี้มานานมาก แต่ก็ไม่พบคำตอบใน Google และคำถามที่คล้ายกันใน Stackoverflow หากมีการซ้ำกันขออภัยด้วย

หลายคนดูเหมือนจะพูดว่าการเขียนคอมไพเลอร์และเครื่องมือภาษาอื่น ๆ ในภาษาที่ใช้งานได้เช่น OCaml และ Haskell นั้นมีประสิทธิภาพมากกว่าและง่ายกว่ามากจากนั้นจึงเขียนเป็นภาษาที่จำเป็น

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

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

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

งานคอมไพเลอร์จำนวนมากคือการจับคู่รูปแบบกับโครงสร้างแบบต้นไม้

ทั้ง OCaml และ Haskell มีความสามารถในการจับคู่รูปแบบที่มีประสิทธิภาพและรัดกุม

การเพิ่มการจับคู่รูปแบบกับภาษาที่จำเป็นจะทำได้ยากกว่าเนื่องจากค่าใดก็ตามที่ได้รับการประเมินหรือแยกออกเพื่อให้ตรงกับรูปแบบจะต้องปราศจากผลข้างเคียง

ปัจจัยสำคัญอย่างหนึ่งที่ต้องพิจารณาคือส่วนสำคัญของโครงการคอมไพเลอร์คือเมื่อคุณสามารถโฮสต์คอมไพเลอร์ได้เองและ "กินอาหารสุนัขของคุณเอง" ด้วยเหตุนี้เมื่อคุณดูภาษาเช่น OCaml ซึ่งได้รับการออกแบบมาสำหรับการวิจัยภาษาจึงมักจะมีคุณสมบัติที่ยอดเยี่ยมสำหรับปัญหาประเภทคอมไพเลอร์

ในงานคอมไพเลอร์ล่าสุดของฉันเราใช้ OCaml ด้วยเหตุผลนี้ในขณะที่จัดการโค้ด C มันเป็นเพียงเครื่องมือที่ดีที่สุดสำหรับงานนี้ หากคนที่ INRIA สร้าง OCaml ด้วยลำดับความสำคัญที่แตกต่างกันมันอาจจะไม่เหมาะสมนัก

ที่กล่าวว่าภาษาที่ใช้งานได้เป็นเครื่องมือที่ดีที่สุดในการแก้ปัญหาใด ๆ ดังนั้นจึงมีเหตุผลตามมาว่าเป็นเครื่องมือที่ดีที่สุดในการแก้ปัญหานี้โดยเฉพาะ QED

/ me: คลานกลับไปที่งาน Java ของฉันอย่างสนุกสนานเล็กน้อย ...

โดยพื้นฐานแล้วคอมไพเลอร์คือการแปลงจากรหัสชุดหนึ่งไปยังอีกชุดหนึ่ง - จากแหล่งที่มาเป็น IR จาก IR เป็น IR ที่ปรับให้เหมาะสมจาก IR ไปจนถึงการประกอบ ฯลฯ นี่คือประเภทของภาษาที่ใช้งานได้อย่างแม่นยำได้รับการออกแบบมาเพื่อ - ฟังก์ชันที่บริสุทธิ์คือ เพียงแค่การเปลี่ยนแปลงจากสิ่งหนึ่งไปเป็นอีกสิ่งหนึ่ง ฟังก์ชันที่จำเป็นไม่มีคุณสมบัตินี้ แม้ว่าคุณจะสามารถเขียนโค้ดประเภทนี้ในภาษาที่จำเป็นได้ แต่ภาษาที่ใช้งานได้นั้นมีความเชี่ยวชาญเป็นพิเศษ

ดูสิ่งนี้ด้วย

รูปแบบการออกแบบ F #

FP จัดกลุ่มสิ่งต่างๆ 'ตามการดำเนินการ' ในขณะที่ OO จัดกลุ่มสิ่งต่างๆ 'ตามประเภท' และ 'โดยการดำเนินการ' นั้นเป็นธรรมชาติมากกว่าสำหรับคอมไพเลอร์ / ล่าม

ความเป็นไปได้อย่างหนึ่งก็คือคอมไพเลอร์มีแนวโน้มที่จะต้องจัดการอย่างรอบคอบกับหลาย ๆ กรณีที่มีมุม การทำให้โค้ดถูกต้องมักจะทำได้ง่ายขึ้นโดยใช้รูปแบบการออกแบบที่จัดโครงสร้างการใช้งานในลักษณะที่คล้ายคลึงกับกฎที่ใช้ บ่อยครั้งที่มักจะลงเอยด้วยการประกาศ (การจับคู่รูปแบบ "ที่ไหน") มากกว่าการออกแบบที่จำเป็น (การจัดลำดับ "เมื่อ") และทำให้ง่ายต่อการนำไปใช้ในภาษาที่เปิดเผย (และส่วนใหญ่ใช้งานได้)

ดูเหมือนทุกคนจะพลาดเหตุผลสำคัญอีกประการหนึ่ง การเขียนภาษาเฉพาะโดเมนแบบฝัง (EDSL) เป็นเรื่องง่ายมากสำหรับตัวแยกวิเคราะห์ซึ่งมีลักษณะคล้ายกับ (E) BNF ในโค้ดปกติ ตัวแยกวิเคราะห์เช่นพาร์เซกนั้นค่อนข้างง่ายในการเขียนในภาษาที่ใช้งานได้โดยใช้ฟังก์ชันลำดับที่สูงกว่าและองค์ประกอบของฟังก์ชัน ไม่เพียง แต่ง่ายกว่า แต่สวยงามมาก

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

นี่ไม่ใช่วิธีเดียวในการสร้างกรอบความคิดที่แน่นอน