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

ฉันได้อ่านบทความบนอินเทอร์เน็ตเกี่ยวกับการเลือกภาษาโปรแกรมในองค์กร เมื่อเร็ว ๆ นี้ภาษาที่พิมพ์แบบไดนามิกจำนวนมากได้รับความนิยมเช่น Ruby, Python, PHP และ Erlang แต่องค์กรจำนวนมากยังคงอยู่กับภาษาที่พิมพ์แบบคงที่เช่น C, C ++, C # และ Java และใช่หนึ่งในประโยชน์ของภาษาที่พิมพ์แบบคงที่คือข้อผิดพลาดการเขียนโปรแกรมที่ถูกจับก่อนหน้านี้ในเวลารวบรวมมากกว่าในเวลาทำงาน แต่ยังมีข้อได้เปรียบกับภาษาที่พิมพ์แบบไดนามิก ( เพิ่มเติมเกี่ยวกับ Wikipedia ) เหตุผลหลักที่องค์กรไม่เริ่มใช้ภาษาอย่าง Erlang, Ruby และ Python ดูเหมือนว่าพวกเขาเป็นแบบไดนามิก นั่นก็เป็นเหตุผลหลักว่าทำไมคนใน StackOverflow ตัดสินใจต่อต้าน Erlang ดูทำไมคุณตัดสินใจ "กับ" Erlang แต่มีดูเหมือนจะเป็นคำวิจารณ์ที่แข็งแกร่งกับพิมพ์แบบไดนามิกในองค์กร แต่ฉันไม่ได้รับมันจริงๆว่าทำไมมันเป็นที่แข็งแกร่ง ทำไมมีการวิพากษ์วิจารณ์อย่างมากต่อการพิมพ์แบบไดนามิกในองค์กร? มันส่งผลกระทบต่อต้นทุนของโครงการมากหรือไม่? แต่บางทีฉันผิด

35 programming-languages  dynamic-typing  static-typing  type-systems 

ฉันมีโปรแกรมเล็ก ๆ สองโปรแกรมนี้: C #include <stdio.h> int main() { if (5) { printf("true\n"); } else { printf("false\n"); } return 0; } ชวา class type_system { public static void main(String args[]) { if (5) { System.out.println("true"); } else { System.out.println("false"); } } } ซึ่งรายงานข้อผิดพลาด: type_system.java:4: error: incompatible types: int cannot be …

33 java  c  type-systems 

ฉันกำลังศึกษา Haskell เพื่อจุดประสงค์ในการทำความเข้าใจเกี่ยวกับการเขียนโปรแกรมฟังก์ชั่นด้วยความคาดหวังว่าฉันจะใช้ความเข้าใจที่ฉันได้รับในภาษาอื่น ๆ (Groovy, Python, JavaScript เป็นหลัก) ฉันเลือกแฮสเค็ลล์เพราะฉันรู้สึกว่ามันใช้งานได้อย่างหมดจดและไม่ยอมพึ่งพารัฐ ฉันไม่ได้เลือกที่จะเรียนรู้ Haskell เพราะฉันสนใจที่จะสำรวจระบบที่เข้มงวดมาก ๆ คำถามของฉันคือสิ่งนี้: ระบบพิมพ์ที่แข็งแกร่งเป็นผลพลอยได้ที่จำเป็นของภาษาที่ใช้งานได้อย่างสมบูรณ์หรือเป็นตัวเลือกการออกแบบที่ไม่เกี่ยวข้องกับ Haskell โดยเฉพาะหรือไม่?

33 functional-programming  haskell  language-features  type-systems 

ฉันอ่านคำถามที่เกี่ยวข้องมีรูปแบบการออกแบบใดที่ไม่จำเป็นในภาษาไดนามิกเช่น Python หรือไม่? และจดจำคำพูดนี้บน Wikiquote.org สิ่งมหัศจรรย์เกี่ยวกับการพิมพ์แบบไดนามิกคือช่วยให้คุณสามารถแสดงสิ่งที่คำนวณได้ และประเภทของระบบไม่พิมพ์ - ระบบประเภทมักจะตัดสินใจได้และพวกเขา จำกัด ให้คุณเป็นส่วนย่อย ผู้ที่ชื่นชอบระบบแบบสแตติกพูดว่า“ ใช้ได้เลยมันดีพอ โปรแกรมที่น่าสนใจทั้งหมดที่คุณต้องการเขียนจะใช้งานได้ตามประเภท” แต่นั่นไร้สาระ - เมื่อคุณมีระบบพิมพ์คุณจะไม่รู้ด้วยซ้ำว่าโปรแกรมที่น่าสนใจนั้นมีอะไรบ้าง --- วิทยุวิศวกรรมซอฟต์แวร์ตอนที่ 140: Newspeak และประเภทที่เสียบได้ด้วย Gilad Bracha ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

30 design-patterns  python  type-systems  dynamic-typing 

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

30 java  type-systems  lambda  java8 

ฉันรู้ว่านี่เป็นคำถามที่กว้างขวางคลุมเครือและเป็นไปได้ทางปรัชญา ในขอบเขตที่คำหลักที่สำคัญที่สุดในคำถาม - "ความเชื่อ" ระบบการพิมพ์ - ตัวเองเป็นป่วยกำหนด ดังนั้นให้ฉันพยายามอธิบายสิ่งที่ฉันหมายถึง บริบทโดยรวมของคำถาม เราได้สร้างเว็บแอปขนาดใหญ่ขึ้นใน Ruby on Rails และโดยทั่วไปเรามีความสุขกับกองซ้อนของเรา เมื่อเราต้องการเราสามารถจัดส่งสิ่งต่าง ๆ ได้อย่างรวดเร็วจริง ๆ - สิ่งที่ใช้งานได้ 90% ของคดี "ธุรกิจ" โดยไม่ต้องกังวลเรื่องขอบคดีมากถึง 10% ในทางกลับกันด้วยความช่วยเหลือในการใช้โค้ดรีวิวและทดสอบครอบคลุมเราจะช้าและพิจารณาและตรวจสอบให้แน่ใจว่าเราครอบคลุมฐานทั้งหมด - อีกครั้งเฉพาะในสถานการณ์ที่สมควรได้รับการตรวจสอบข้อเท็จจริงและความปลอดภัยอย่างใกล้ชิด อย่างไรก็ตามเมื่อทีมเติบโตขึ้นฉันเริ่มรู้สึกไม่สบายใจกับการขาด "ตาข่ายนิรภัย" ที่ถูกอบเข้าไปในกองของเรา เราเพิ่งเริ่มทำการพัฒนา Android พื้นเมืองบน Java และฉันก็นึกถึงความปลอดภัยที่จัดเตรียมโดยภาษาที่รวบรวม / คงที่ / พิมพ์ดีดอย่างยิ่ง ตัวแปรที่สะกดผิดประเภทข้อมูลที่ไม่ถูกต้องการเรียกใช้ฟังก์ชันที่ไม่ถูกต้องและโฮสต์ของข้อผิดพลาดเล็กน้อยที่ IDE ของคุณติดอยู่เอง ทั้งหมดเป็นเพราะ IDE สามารถเชื่อมต่อกับคอมไพเลอร์และตรวจสอบบางแง่มุมของโปรแกรม "ความถูกต้อง" ต้องการเปลี่ยนลายเซ็นฟังก์ชั่นหรือไม่? ง่าย. คอมไพเลอร์ …

29 java  haskell  scala  type-systems  rust 

ดูเหมือนว่าภาษาการเขียนโปรแกรมใหม่ทั้งหมดหรืออย่างน้อยก็เป็นภาษาที่ได้รับความนิยมอย่างมาก แม้จาวาสคริปต์ก็มีประเภทและการอนุมานประเภทแม้ว่าการใช้งานที่หลากหลาย (Acscript, typescript ฯลฯ ) มันดูดีสำหรับฉัน แต่ฉันสงสัยว่ามีการแลกเปลี่ยนหรือทำไมสมมติว่า Java หรือภาษาดีเก่าไม่มีการอนุมานประเภท เมื่อประกาศตัวแปรในGoโดยไม่ระบุประเภทของมัน (ใช้ var โดยไม่มี type หรือ: = ไวยากรณ์) ชนิดของตัวแปรจะถูกอนุมานจากค่าทางด้านขวามือ Dอนุญาตให้เขียนแฟรกเมนต์โค้ดขนาดใหญ่โดยไม่ระบุชนิดซ้ำซ้อนเช่นเดียวกับภาษาไดนามิก ในทางกลับกันการอนุมานแบบคงที่จะอนุมานประเภทและคุณสมบัติของรหัสอื่น ๆ ที่ให้สิ่งที่ดีที่สุดทั้งในโลกที่คงที่และแบบไดนามิก เอ็นจิ้นการอนุมานประเภทในRustค่อนข้างฉลาด มันทำมากกว่าดูประเภทของค่า r ในระหว่างการเริ่มต้น นอกจากนี้ยังมีลักษณะการใช้ตัวแปรหลังจากนั้นอนุมานชนิดของมัน Swiftใช้การอนุมานประเภทเพื่อกำหนดประเภทที่เหมาะสม การอนุมานประเภทช่วยให้ผู้รวบรวมสามารถอนุมานประเภทของนิพจน์เฉพาะโดยอัตโนมัติเมื่อคอมไพล์โค้ดของคุณเพียงแค่ตรวจสอบค่าที่คุณให้ไว้

29 programming-languages  type-systems 

เป็นที่ยอมรับกันโดยทั่วไปว่า Java generics ล้มเหลวในบางวิธีที่สำคัญ การรวมกันของ wildcard และขอบเขตทำให้รหัสบางอย่างไม่สามารถอ่านได้อย่างจริงจัง อย่างไรก็ตามเมื่อฉันดูภาษาอื่น ๆ ฉันก็ดูเหมือนจะไม่พบระบบแบบทั่วไปที่โปรแกรมเมอร์มีความสุข ถ้าเราทำสิ่งต่อไปนี้เป็นเป้าหมายการออกแบบของระบบประเภท: สร้างการประกาศประเภทที่อ่านง่ายเสมอ ง่ายต่อการเรียนรู้ (ไม่จำเป็นต้องปัดเรื่องความแปรปรวนร่วมความแปรปรวน ฯลฯ ) เพิ่มจำนวนข้อผิดพลาดในการคอมไพล์ให้สูงสุด มีภาษาใดบ้างที่ทำให้ถูกต้อง? ถ้าฉัน google สิ่งเดียวที่ฉันเห็นคือการร้องเรียนเกี่ยวกับวิธีที่ระบบประเภทดูดในภาษา X. ความซับซ้อนแบบนี้มีอยู่ในการพิมพ์ทั่วไปหรือไม่? เราควรยอมแพ้ในการพยายามตรวจสอบความปลอดภัย 100% ณ เวลารวบรวมหรือไม่? คำถามหลักของฉันคือภาษาใดที่ "เข้าใจถูกต้อง" ที่สุดด้วยความเคารพต่อเป้าหมายทั้งสามนี้ ฉันรู้ว่ามันเป็นแบบอัตนัย แต่จนถึงตอนนี้ฉันไม่สามารถหาภาษาใดภาษาหนึ่งได้ที่โปรแกรมเมอร์ไม่ใช่ทุกคนยอมรับว่าระบบประเภททั่วไปนั้นเป็นระเบียบ ภาคผนวก: ดังที่กล่าวไว้การรวมกันของการพิมพ์ย่อย / การสืบทอดและข้อมูลทั่วไปเป็นสิ่งที่สร้างความซับซ้อนดังนั้นฉันจึงกำลังมองหาภาษาที่ผสมผสานทั้งสองอย่างและหลีกเลี่ยงการระเบิดของความซับซ้อน

29 type-systems  generics 

ในบทความของ Eric Lippert เกิดอะไรขึ้นกับสัญลักษณ์ของฮังการี? เขากล่าวว่าจุดประสงค์ของสัญกรณ์ฮังการี (ประเภทที่ดี) คือการ ขยายแนวคิดของ "ประเภท" เพื่อรวมข้อมูลเชิงความหมายนอกเหนือจากข้อมูลการเป็นตัวแทนจัดเก็บข้อมูล ตัวอย่างง่ายๆจะนำหน้าตัวแปรที่แสดงถึงพิกัด X ด้วย "x" และตัวแปรที่แทนพิกัด Y ด้วย "y" โดยไม่คำนึงว่าตัวแปรเหล่านั้นเป็นจำนวนเต็มหรือลอยหรืออะไรก็ตามดังนั้นเมื่อคุณเขียนโดยไม่ตั้งใจxFoo + yBarรหัสดูผิดอย่างชัดเจน แต่ฉันได้อ่านเกี่ยวกับระบบประเภทของ Haskell ด้วยและดูเหมือนว่าใน Haskell เราสามารถทำสิ่งเดียวกันให้สำเร็จได้ (เช่น "ขยายแนวคิดประเภทที่จะครอบคลุมข้อมูลความหมาย") โดยใช้ประเภทจริงที่คอมไพเลอร์จะตรวจสอบคุณ ดังนั้นในตัวอย่างข้างต้นxFoo + yBarใน Haskell จะล้มเหลวในการรวบรวมถ้าคุณออกแบบโปรแกรมของคุณอย่างถูกต้องเนื่องจากมันถูกประกาศว่าเป็นชนิดที่เข้ากันไม่ได้ ดูเหมือนว่าระบบประเภทของ Haskell สนับสนุนการตรวจสอบเวลาแบบคอมไพล์ได้อย่างมีประสิทธิภาพเทียบเท่ากับสัญลักษณ์ของฮังการี ดังนั้น Hungarian Notation เป็นเพียงตัวช่วยแบนด์สำหรับภาษาโปรแกรมที่ระบบประเภทไม่สามารถเข้ารหัสข้อมูลความหมายได้หรือไม่? สัญกรณ์ฮังการีหรือเสนอบางสิ่งบางอย่างนอกเหนือจากสิ่งที่ระบบชนิดคงที่เช่น Haskell สามารถนำเสนอ? (แน่นอนฉันกำลังใช้ Haskell เป็นตัวอย่างฉันแน่ใจว่ามีภาษาอื่นที่มีระบบการพิมพ์ที่มีความหมายคล้ายกัน (rich? strong?) แม้ว่าฉันจะไม่ได้เจอก็ตาม) …

28 naming  type-systems  static-typing  hungarian 

เมื่อมีการออกแบบและ implenting ภาษาโปรแกรมเชิงวัตถุในบางจุดหนึ่งต้องให้ทางเลือกเกี่ยวกับการใช้ประเภทพื้นฐาน (เช่นint, float, doubleหรือเทียบเท่า) เป็นชั้นเรียนหรือสิ่งอื่นใด เห็นได้ชัดว่าภาษาในตระกูล C มีแนวโน้มที่จะไม่กำหนดเป็นคลาส (Java มีชนิดดั้งเดิมแบบพิเศษ C # ใช้ภาษาเหล่านี้เป็น struct ที่ไม่เปลี่ยนรูป ฯลฯ ) ฉันสามารถนึกถึงข้อได้เปรียบที่สำคัญมากเมื่อมีการใช้ประเภทพื้นฐานเป็นคลาส (ในระบบชนิดที่มีลำดับชั้นแบบรวม): ชนิดเหล่านี้อาจเป็นชนิดย่อย Liskov ที่เหมาะสมของประเภทรูต ดังนั้นเราจึงหลีกเลี่ยงความสับสนของภาษาด้วย Boxing / unboxing (ชัดเจนหรือโดยปริยาย) ประเภทของ wrapper กฎความแปรปรวนพิเศษพฤติกรรมพิเศษ ฯลฯ แน่นอนฉันสามารถเข้าใจบางส่วนว่าทำไมนักออกแบบภาษาจึงตัดสินใจเลือกวิธีการ: อินสแตนซ์ของชั้นเรียนมักจะมีค่าใช้จ่ายเชิงพื้นที่ (เนื่องจากอินสแตนซ์อาจมี vtable หรือข้อมูลเมตาอื่น ๆ ในโครงร่างหน่วยความจำ) มี (ถ้าภาษาไม่อนุญาตให้สืบทอดกับสิ่งเหล่านั้น) ประสิทธิภาพเชิงพื้นที่ (และพื้นที่เชิงพื้นที่ที่ได้รับการปรับปรุงโดยเฉพาะในอาร์เรย์ขนาดใหญ่) เป็นเหตุผลเดียวที่ว่าทำไมประเภทพื้นฐานมักไม่ได้เรียน? โดยทั่วไปฉันคิดว่าคำตอบคือใช่ แต่คอมไพเลอร์มีอัลกอริธึมการวิเคราะห์แบบ Escape และพวกเขาสามารถอนุมานได้ว่าพวกเขาสามารถ (เลือก) …

27 object-oriented  language-design  compiler  type-systems 

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

24 type-systems 

หมายเหตุ:เมื่อฉันใช้ "ซับซ้อน" ในชื่อเรื่องฉันหมายถึงนิพจน์มีตัวดำเนินการและตัวถูกดำเนินการจำนวนมาก ไม่ใช่ว่าการแสดงออกของตัวเองนั้นซับซ้อน ฉันเพิ่งทำงานกับคอมไพเลอร์เรียบง่ายเพื่อประกอบ x86-64 ฉันได้เสร็จสิ้นการรวบรวมส่วนหน้าหลักของคอมไพเลอร์ - lexer และ parser - และตอนนี้ฉันสามารถสร้างการแสดงบทคัดย่อต้นไม้ไวยากรณ์ของโปรแกรมของฉัน และเนื่องจากภาษาของฉันจะถูกพิมพ์แบบสแตติกฉันกำลังทำขั้นตอนต่อไป: พิมพ์การตรวจสอบซอร์สโค้ด อย่างไรก็ตามฉันมีปัญหาและไม่สามารถแก้ไขด้วยตนเองได้อย่างสมเหตุสมผล ลองพิจารณาตัวอย่างต่อไปนี้: โปรแกรมแยกวิเคราะห์ของคอมไพเลอร์ของฉันได้อ่านบรรทัดของรหัสนี้: int a = 1 + 2 - 3 * 4 - 5 และแปลงเป็น AST ต่อไปนี้: = / \ a(int) \ - / \ - 5 / \ + * / \ / …

23 language-agnostic  compiler  type-systems  type 

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

22 haskell  type-systems  go 

มีเหตุผลทางทฤษฎีบ้างไหม (เช่นว่าการตรวจสอบชนิดหรือการอนุมานประเภทจะไม่สามารถตัดสินใจได้) หรือเหตุผลเชิงปฏิบัติ (ยากเกินกว่าที่จะใช้อย่างถูกต้อง) ปัจจุบันเราสามารถห่อสิ่งต่างๆให้เป็นnewtypeเช่นนั้นได้ newtype Pair a = Pair (a, a) แล้วมี Pair :: * -> * λ(a:*). (a,a)แต่เราไม่สามารถทำสิ่งที่ชอบ (มีบางภาษาที่มีพวกเขาตัวอย่างเช่นScala ทำ )

22 haskell  abstraction  type-systems  lambda 

เมื่ออธิบายผู้ประสานงาน Y ในบริบทของ Haskell มักจะกล่าวว่าการนำไปใช้งานแบบตรงไปตรงมาจะไม่ตรวจสอบประเภทใน Haskell เนื่องจากเป็นแบบเรียกซ้ำ ตัวอย่างเช่นจากRosettacode : The obvious definition of the Y combinator in Haskell canot be used because it contains an infinite recursive type (a = a -> b). Defining a data type (Mu) allows this recursion to be broken. newtype Mu a = Roll { …

21 haskell  type-systems  static-typing  ocaml