การใช้การอนุมานประเภท

ฉันเห็นการอภิปรายที่น่าสนใจเกี่ยวกับการพิมพ์แบบคงที่และแบบไดนามิก โดยทั่วไปฉันชอบการพิมพ์แบบคงที่เนื่องจากการตรวจสอบประเภทการคอมไพล์โค้ดเอกสารที่ดีกว่าเป็นต้นอย่างไรก็ตามฉันยอมรับว่ามันทำให้โค้ดรกถ้าทำแบบที่ Java ทำ

ดังนั้นฉันกำลังจะเริ่มสร้างภาษาสไตล์การทำงานของตัวเองและการอนุมานประเภทเป็นหนึ่งในสิ่งที่ฉันต้องการนำไปใช้ ฉันเข้าใจว่ามันเป็นเรื่องใหญ่และฉันไม่ได้พยายามสร้างสิ่งที่ยังไม่เคยทำมาก่อนเพียงแค่การอนุมานขั้นพื้นฐาน ...

มีคำแนะนำเกี่ยวกับสิ่งที่ต้องอ่านที่จะช่วยฉันในเรื่องนี้หรือไม่? โดยเฉพาะอย่างยิ่งสิ่งที่เป็นประโยชน์ / ปฏิบัติมากกว่าเมื่อเทียบกับทฤษฎีหมวดหมู่เชิงทฤษฎี / ตำราทฤษฎีประเภทอื่น ๆ หากมีข้อความอภิปรายเกี่ยวกับการนำไปใช้งานพร้อมโครงสร้างข้อมูล / อัลกอริทึมนั่นก็น่าจะดี

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

1. บทที่ 30 (อนุมานชนิด) ของหนังสือมีอิสระ PLAI , การเขียนโปรแกรมภาษา: การประยุกต์ใช้และการตีความ , ภาพวาดรวมกันตามประเภทการอนุมาน
2. หลักสูตรภาคฤดูร้อนการตีความประเภทเป็นค่านามธรรมนำเสนอผู้ประเมินที่สวยงามตัวตรวจสอบประเภทตัวสร้างใหม่และผู้อนุมานโดยใช้ Haskell เป็นภาษาโลหะ
3. บทที่ 7 (ประเภท) ของEOPL หนังสือ , Essentials ของการเขียนโปรแกรมภาษา
4. บทที่ 22 (ชนิดฟื้นฟู) ของTAPL หนังสือ , ประเภทและภาษาการเขียนโปรแกรมและการใช้งานที่สอดคล้องกัน OCaml ลาดตระเวนและfullrecon
5. บทที่ 13 (ชนิดฟื้นฟู) ของหนังสือเล่มใหม่ Dcpl , แนวคิดการออกแบบในการเขียนโปรแกรมภาษา
6. การเลือกของเอกสารทางวิชาการ
7. TypeInferenceของคอมไพเลอร์ปิดเป็นตัวอย่างของวิธีการวิเคราะห์โฟลว์ข้อมูลเพื่อพิมพ์การอนุมานซึ่งเหมาะกับภาษาไดนามิกที่แนวทางของ Hindler Milner

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

ขอแนะนำการบ้านที่สามารถเข้าถึงได้ทั้งสองแบบนี้ใน ML ซึ่งคุณสามารถทำได้ภายในเวลาไม่ถึงวัน

1. PCF Interpreter ( โซลูชัน ) เพื่ออุ่นเครื่อง
2. การอนุมานประเภท PCF ( โซลูชัน ) เพื่อใช้อัลกอริทึม W สำหรับการอนุมานประเภท Hindley-Milner

งานเหล่านี้มาจากหลักสูตรขั้นสูงกว่า:

1. การใช้ MiniML

2. Polymorphic, Existential, Recursive types (PDF)

3. การตรวจสอบการพิมพ์สองทิศทาง (PDF)

4. การพิมพ์ย่อยและวัตถุ (PDF)

โชคไม่ดีที่วรรณกรรมในเรื่องนี้มีเนื้อหาหนาแน่นมาก ฉันก็อยู่ในรองเท้าของคุณเช่นกัน ฉันได้รับการแนะนำครั้งแรกในหัวข้อนี้จาก Programming Languages: Applications and Interpretation

http://www.plai.org/

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

สำหรับภาษาที่ไม่มีletคุณสามารถแก้ข้อ จำกัด ข้างต้นแบบสุ่มสี่สุ่มห้าได้โดยการแทนที่ ตัวอย่างเช่น:

(if (= 1 2) 
    1 
    2)

ในที่นี้เราสามารถพูดได้ว่าเงื่อนไขของคำสั่ง if ต้องเป็นบูลีนและประเภทของคำสั่ง if นั้นเหมือนกับประเภทของคำสั่งthenและelseประโยค เนื่องจากเรารู้1และ2เป็นตัวเลขโดยการแทนที่เราจึงรู้ว่าifคำสั่งคือตัวเลข

สิ่งที่น่ารังเกียจและสิ่งที่ฉันไม่เข้าใจมาระยะหนึ่งคือการจัดการกับให้:

(let ((id (lambda (x) x)))
    (id id))

ที่นี่เราผูกไว้idกับฟังก์ชันที่ส่งคืนสิ่งที่คุณส่งผ่านหรือที่เรียกว่าฟังก์ชันเอกลักษณ์ ปัญหาคือประเภทของพารามิเตอร์ของฟังก์ชันที่มีความแตกต่างกับการใช้งานของแต่ละx idประการที่สองidคือฟังก์ชันประเภทa -> aที่aสามารถเป็นอะไรก็ได้ (a -> a) -> (a -> a)ครั้งแรกเป็นประเภท สิ่งนี้เรียกว่า let-polymorphism กุญแจสำคัญคือการแก้ข้อ จำกัด ตามลำดับที่กำหนด: ก่อนอื่นให้แก้ข้อ จำกัด สำหรับคำจำกัดความของid. a -> aนี้จะเป็น จากนั้นสดสำเนาแยกต่างหากจากประเภทของidสามารถทดแทนเข้าไปในข้อ จำกัด สำหรับแต่ละสถานที่idจะใช้สำหรับตัวอย่างและa2 -> a2a3 -> a3

สิ่งนี้ไม่สามารถอธิบายได้ในแหล่งข้อมูลออนไลน์ พวกเขาจะพูดถึงอัลกอริทึม W หรือ M แต่ไม่ใช่วิธีการทำงานในแง่ของการแก้ข้อ จำกัด หรือทำไมมันถึงไม่ barf เกี่ยวกับความหลากหลายของตัวอักษร: แต่ละอัลกอริทึมเหล่านั้นบังคับใช้คำสั่งในการแก้ข้อ จำกัด

ฉันพบว่าแหล่งข้อมูลนี้มีประโยชน์อย่างมากในการผูก Algorithm W, M และแนวคิดทั่วไปของการสร้างข้อ จำกัด และการแก้ปัญหาทั้งหมดเข้าด้วยกัน มีความหนาแน่นเล็กน้อย แต่ดีกว่ามาก:

http://www.cs.uu.nl/research/techreps/repo/CS-2002/2002-031.pdf

เอกสารอื่น ๆ อีกมากมายก็ดีเช่นกัน:

http://people.cs.uu.nl/bastiaan/papers.html

ฉันหวังว่าจะช่วยชี้แจงโลกที่ค่อนข้างมืดมน

นอกจากนี้ในการ Hindley abstract interpretationมิลเนอร์สำหรับภาษาที่ใช้งานได้อีกวิธีที่นิยมในการอนุมานชนิดสำหรับภาษาแบบไดนามิก

แนวคิดของการตีความนามธรรมคือการเขียนล่ามพิเศษสำหรับภาษาแทนที่จะรักษาสภาพแวดล้อมของคุณค่าที่เป็นรูปธรรม (1, เท็จ, การปิด) มันทำงานกับค่านามธรรมประเภทที่เรียกว่า (int, bool ฯลฯ ) เนื่องจากเป็นการตีความโปรแกรมด้วยค่านามธรรมจึงเรียกว่าการตีความนามธรรม

Pysonar2 เป็นการใช้การตีความนามธรรมสำหรับ Python อย่างสวยงาม Google ใช้เพื่อวิเคราะห์โครงการ Python โดยทั่วไปจะใช้visitor patternเพื่อส่งการเรียกการประเมินไปยังโหนด AST ที่เกี่ยวข้อง ฟังก์ชันผู้เยี่ยมชมtransform ยอมรับcontextโหนดปัจจุบันที่จะได้รับการประเมินและส่งคืนชนิดของโหนดปัจจุบัน

ประเภทและภาษาโปรแกรมโดย Benjamin C. Pierce

แลมบ์ดาสุดยอดเริ่มต้นที่นี่