คำถามติดแท็ก type-inference

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

42 undecidability  type-theory  type-inference  dependent-types 

เป็นที่ทราบกันดีว่าการอนุมานของ Hindley-Milner (การพิมพ์ -calculus พร้อม polymorphism) นั้นมีการอนุมานประเภทที่สามารถตัดสินใจได้: คุณสามารถสร้างชนิดหลักการสำหรับโปรแกรมใด ๆ โดยไม่มีคำอธิบายประกอบใด ๆλλ\lambda การเพิ่มประเภทของสไตล์ Haskell ดูเหมือนจะรักษาความสามารถในการถอดรหัสได้ แต่การเพิ่มเติมเพิ่มเติมทำให้การอนุมานโดยไม่มีการเพิ่มความคิดเห็นไม่สามารถอธิบายได้ (ตระกูลตระกูล, GADTs, ชนิดพึ่งพา, ประเภท Rank, N, Systemเป็นต้น)ωω\omega ฉันสงสัยว่า: อะไรคือระบบพิมพ์ที่แข็งแกร่งที่สุดที่มีการอนุมานได้อย่างสมบูรณ์? มันจะอยู่ที่ไหนสักแห่งระหว่าง Hindley-Milner (decidable อย่างสมบูรณ์) และ dependent-types (undecidable สมบูรณ์) มีแง่มุมของ DT ที่สามารถเพิ่มซึ่งรักษาความสามารถในการตัดสินใจอนุมานได้หรือไม่? มีงานวิจัยใดที่ทำเพื่อดูว่าสามารถผลักดันสิ่งนี้ได้ไกลแค่ไหน? ฉันรู้ว่าไม่มีระบบที่แข็งแกร่งที่สุดเพียงระบบเดียวที่มีความเป็นไปได้ที่จะเกิดการเปลี่ยนแปลงเล็ก ๆ น้อย ๆ ที่ไม่สิ้นสุดและเพิ่มขึ้นซึ่งสามารถเพิ่มเข้าไปในการอนุมาน HM แต่มีแนวโน้มว่าผู้สมัครที่ใช้งานได้ไม่กี่คนของระบบที่ถูกค้นพบ แก้ไข: เนื่องจากไม่มีระบบที่ "แข็งแกร่งที่สุด" ฉันจะยอมรับคำตอบที่แสดงถึงระบบที่น่าทึ่งซึ่งขยาย Hindley Milner ด้วยการอนุมานที่แน่นอน …

22 undecidability  type-theory  type-inference  dependent-types 

ฉันกำลังอ่านเกี่ยวกับอัลกอริทึมการพิมพ์ของ Hindley-Milnerในขณะที่เขียนการนำไปใช้และดูว่าตราบใดที่ตัวแปรทุกตัวถูกผูกไว้คุณจะได้รับประเภทอะตอมมิกหรือประเภทที่อาร์กิวเมนต์จะกำหนดประเภทสุดท้ายเช่นt1 -> t1หรือ(t1 -> t2) -> (t1 -> t2)ที่ไหนt1และt2เป็นตัวแปรประเภท ฉันไม่สามารถคิดวิธีที่คุณจะได้รับสิ่งที่ชอบt1 -> t2หรือง่ายๆt1ซึ่งฉันเข้าใจว่าหมายความว่าอัลกอริทึมเสียเนื่องจากไม่มีวิธีกำหนดประเภทของนิพจน์ที่แท้จริง คุณจะรู้ได้อย่างไรว่าคุณจะไม่ได้รับประเภทเช่นคนที่ "เสีย" เหล่านี้ตราบใดที่ตัวแปรทุกตัวถูกผูกไว้ ฉันรู้ว่าประเภทอัตราผลตอบแทนขั้นตอนวิธีการที่มีตัวแปร t1 -> t2แต่เหล่านี้ได้รับการแก้ไขเสมอเมื่อคุณผ่านการขัดแย้งกับการทำงานซึ่งจะไม่เป็นกรณีในการทำงานกับชนิด นี่คือเหตุผลที่ฉันต้องการทราบว่าเรารู้ได้อย่างไรว่าอัลกอริทึมจะไม่ให้ผลเช่นนั้น (ดูเหมือนว่าคุณจะได้รับประเภท "เสีย" ใน MLแต่ฉันถามเกี่ยวกับแคลคูลัสแลมบ์ดา)

14 lambda-calculus  type-theory  typing  type-inference 

ในจาวาคุณต้องส่งอย่างชัดเจนเพื่อลดตัวแปร public class Fruit{} // parent class public class Apple extends Fruit{} // child class public static void main(String args[]) { // An implicit upcast Fruit parent = new Apple(); // An explicit downcast to Apple Apple child = (Apple)parent; } มีเหตุผลสำหรับข้อกำหนดนี้นอกเหนือจากข้อเท็จจริงที่ว่า Java ไม่ได้ทำการอนุมานประเภทใด? มี "gotchas" ในการติดตั้ง downcasting อัตโนมัติในภาษาใหม่หรือไม่? ตัวอย่างเช่น …

11 object-oriented  type-inference  language-design 

ที่ทำงานฉันได้รับมอบหมายให้อนุมานข้อมูลบางประเภทเกี่ยวกับภาษาแบบไดนามิก ฉันเขียนลำดับของข้อความไปยังletนิพจน์ที่ซ้อนกันเช่น: return x; Z => x var x; Z => let x = undefined in Z x = y; Z => let x = y in Z if x then T else F; Z => if x then { T; Z } else { F; Z } เนื่องจากฉันเริ่มต้นจากข้อมูลประเภททั่วไปและพยายามอนุมานประเภทที่เฉพาะเจาะจงมากขึ้นตัวเลือกที่เป็นธรรมชาติคือประเภทการปรับแต่ง ตัวอย่างเช่นตัวดำเนินการตามเงื่อนไขส่งคืนการรวมของประเภทของสาขาที่เป็นจริงและเท็จ …

11 programming-languages  logic  type-theory  type-inference  machine-learning  data-mining  clustering  order-theory  reference-request  information-theory  entropy  algorithms  algorithm-analysis  space-complexity  lower-bounds  formal-languages  computability  formal-grammars  context-free  parsing  complexity-theory  time-complexity  terminology  turing-machines  nondeterminism  programming-languages  semantics  operational-semantics  complexity-theory  time-complexity  complexity-theory  reference-request  turing-machines  machine-models  simulation  graphs  probability-theory  data-structures  terminology  distributed-systems  hash-tables  history  terminology  programming-languages  meta-programming  terminology  formal-grammars  compilers  algorithms  search-algorithms  formal-languages  regular-languages  complexity-theory  satisfiability  sat-solvers  factoring  algorithms  randomized-algorithms  streaming-algorithm  in-place  algorithms  numerical-analysis  regular-languages  automata  finite-automata  regular-expressions  algorithms  data-structures  efficiency  coding-theory  algorithms  graph-theory  reference-request  education  books  formal-languages  context-free  proof-techniques  algorithms  graph-theory  greedy-algorithms  matroids  complexity-theory  graph-theory  np-complete  intuition  complexity-theory  np-complete  traveling-salesman  algorithms  graphs  probabilistic-algorithms  weighted-graphs  data-structures  time-complexity  priority-queues  computability  turing-machines  automata  pushdown-automata  algorithms  graphs  binary-trees  algorithms  algorithm-analysis  spanning-trees  terminology  asymptotics  landau-notation  algorithms  graph-theory  network-flow  terminology  computability  undecidability  rice-theorem  algorithms  data-structures  computational-geometry 

ฉันทราบว่าค่าใช้จ่ายของการอนุมานประเภทในภาษาที่ใช้งานได้เช่น OCaml อาจสูงมาก การอ้างสิทธิ์คือมีลำดับของนิพจน์เช่นนั้นสำหรับแต่ละนิพจน์ความยาวของประเภทที่สอดคล้องกันนั้นจะเป็นเลขชี้กำลังบนความยาวของนิพจน์ ฉันกำหนดลำดับด้านล่าง คำถามของฉันคือ: คุณรู้จักลำดับที่มีนิพจน์ที่กระชับกว่าซึ่งประสบความสำเร็จในประเภทเดียวกันหรือไม่? # fun a -> a;; - : 'a -> 'a = <fun> # fun b a -> b a;; - : ('a -> 'b) -> 'a -> 'b = <fun> # fun c b a -> c b (b a);; - : (('a …

11 lambda-calculus  type-theory  functional-programming  type-inference  type-checking 

ผมทำงานเกี่ยวกับคอมไพเลอร์แคลคูลัสแลมบ์ดาขนาดเล็กที่มีการทำงาน Hindley-มิลเนอร์ระบบอนุมานชนิดและตอนนี้ยังสนับสนุนการปล่อย recursive ของ (ไม่อยู่ในรหัสที่เชื่อมโยง) ซึ่งผมเข้าใจว่าควรจะเพียงพอที่จะทำให้มันสมบูรณ์ทัวริง ปัญหาคือตอนนี้ฉันไม่รู้ว่าจะสนับสนุนรายการหรือไม่ว่าจะสนับสนุนพวกเขาแล้วและฉันก็ต้องหาวิธีการเข้ารหัสพวกเขา ฉันต้องการที่จะสามารถกำหนดได้โดยไม่ต้องเพิ่มกฎใหม่ในระบบประเภท วิธีที่ง่ายที่สุดที่ฉันสามารถนึกถึงรายการxคือเป็นสิ่งที่เป็นnull(หรือรายการที่ว่างเปล่า) หรือคู่ที่มีทั้งxรายการxและ แต่การทำเช่นนี้ฉันต้องสามารถกำหนดคู่และหรือของซึ่งฉันเชื่อว่าเป็นผลิตภัณฑ์และประเภทผลรวม ดูเหมือนว่าฉันสามารถกำหนดคู่ด้วยวิธีนี้: pair = λabf.fab first = λp.p(λab.a) second = λp.p(λab.b) เนื่องจากpairจะมีคนประเภทที่a -> (b -> ((a -> (b -> x)) -> x))หลังจากผ่านการพูดเป็นintและstringก็ต้องการให้ผลอะไรกับชนิด(int -> (string -> x)) -> xซึ่งจะเป็นตัวแทนของคู่ที่และint stringสิ่งที่รบกวนจิตใจฉันอยู่ที่นี่คือถ้านั่นหมายถึงคู่ทำไมมันไม่สมเหตุสมผลเชิงเหตุผลหรือไม่บอกเป็นนัย ๆint and string? อย่างไรก็ตามเทียบเท่ากับ(((int and string) -> x) -> x)ราวกับว่าฉันสามารถมีชนิดผลิตภัณฑ์เป็นพารามิเตอร์ของฟังก์ชันเท่านั้น คำตอบนี้ดูเหมือนจะแก้ไขปัญหานี้ได้ …

10 lambda-calculus  type-theory  type-inference 

@ Babou ของคำตอบของคำถามที่ผ่านมาทำให้ผมนึกถึงว่าครั้งหนึ่งผมคิดว่าผมอ่านกระดาษเกี่ยวกับความเท่าเทียมกัน (ในแง่ทั้งข้อเท็จจริงที่ว่าจะสามารถสรุปหรือได้รับการพิสูจน์และความซับซ้อนเวลาของการทำงานขั้นตอนวิธีการอนุมาน) ของการวิเคราะห์ข้อมูลการไหล , การตีความที่เป็นนามธรรมและอนุมานชนิด ในบางกรณีย่อย (เช่นระหว่างการวิเคราะห์การไหลของข้อมูลระหว่างบริบทและการตีความนามธรรม) ความเท่าเทียมกันนั้นค่อนข้างชัดเจนสำหรับฉัน แต่คำถามดูเหมือนจะละเอียดกว่าสำหรับการเปรียบเทียบอื่น ๆ ตัวอย่างเช่นฉันไม่สามารถทราบได้ว่าการอนุมานประเภท Hindley-Milner สามารถใช้ในการพิสูจน์คุณสมบัติบางอย่างที่สามารถพิสูจน์ได้ด้วยการวิเคราะห์การไหลของข้อมูลที่มีความอ่อนไหวต่อการไหล อะไรคือการอ้างอิงน้ำเชื้อที่พูดถึงการเทียบเท่า (หรือความแตกต่าง) ระหว่างการวิเคราะห์การไหลของข้อมูลการตีความที่เป็นนามธรรมและการอนุมานประเภท?

9 reference-request  compilers  type-inference  program-optimization 

ฉันกำลังมองหาอัลกอริทึมการอนุมานแบบสำหรับภาษาที่ฉันกำลังพัฒนา แต่ฉันไม่พบสิ่งที่ตรงกับความต้องการของฉันเพราะพวกเขามักจะเป็น: à la Haskell ด้วยความหลากหลาย แต่ไม่มีโฆษณามากเกินไป à la C ++ (อัตโนมัติ) ที่คุณมีการโหลดมากเกินไปแบบ ad-hoc แต่ฟังก์ชั่นเป็น monomorphic โดยเฉพาะอย่างยิ่งระบบพิมพ์ของฉันคือ (ลดความซับซ้อน) (ฉันใช้ไวยากรณ์ Haskellish แต่นี่คือภาษาที่ไม่เชื่อเรื่องพระเจ้า): data Type = Int | Double | Matrix Type | Function Type Type และฉันมีโอเปอเรเตอร์ * ซึ่งมีโอเวอร์โหลดค่อนข้างมาก Int -> Int -> Int (Function Int Int) -> Int -> Int Int …

9 type-theory  type-inference