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

เมื่อเร็ว ๆ นี้ฉันมีปัญหากับการอ่านรหัสของฉัน ฉันมีฟังก์ชั่นที่ทำการดำเนินการและส่งคืนสตริงที่แสดง ID ของการดำเนินการนี้สำหรับการอ้างอิงในอนาคต (บิตเช่น OpenFile ใน Windows ที่ส่งคืนหมายเลขอ้างอิง) ผู้ใช้จะใช้ ID นี้ในภายหลังเพื่อเริ่มการทำงานและเพื่อตรวจสอบความสมบูรณ์ ID ต้องเป็นสตริงแบบสุ่มเนื่องจากความกังวลเกี่ยวกับการทำงานร่วมกัน สิ่งนี้สร้างวิธีที่มีลายเซ็นที่ไม่ชัดเจนเช่น: public string CreateNewThing() สิ่งนี้ทำให้เจตนาของประเภทผลตอบแทนไม่ชัดเจน ฉันคิดว่าการพันสตริงนี้ในรูปแบบอื่นที่ทำให้ความหมายของมันชัดเจนขึ้นเช่น: public OperationIdentifier CreateNewThing() ประเภทจะมีเฉพาะสตริงและใช้เมื่อใดก็ตามที่มีการใช้สตริงนี้ เห็นได้ชัดว่าข้อดีของวิธีการใช้งานแบบนี้คือความปลอดภัยและความตั้งใจที่ชัดเจนยิ่งขึ้น แต่มันก็สร้างรหัสและรหัสจำนวนมากขึ้น ในมือข้างหนึ่งฉันชอบความปลอดภัยที่เพิ่มขึ้น แต่ก็สร้างความยุ่งเหยิงมากมาย คุณคิดว่าเป็นวิธีปฏิบัติที่ดีในการห่อประเภทที่เรียบง่ายในชั้นเรียนด้วยเหตุผลด้านความปลอดภัยหรือไม่?

141 type-systems 

มีการศึกษาเกี่ยวกับประสิทธิภาพของภาษาที่พิมพ์แบบคงที่และแบบไดนามิกหรือไม่? โดยเฉพาะอย่างยิ่ง: การวัดผลผลิตโปรแกรมเมอร์ อัตราข้อบกพร่อง รวมถึงผลกระทบของการทดสอบหน่วยหรือไม่ ฉันเคยเห็นการถกเถียงกันถึงข้อดีของทั้งสองด้านแล้ว แต่ฉันก็สงสัยว่าใครมีการศึกษาบ้างไหม

69 productivity  comparison  type-systems  dynamic-typing  static-typing 

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

66 java  haskell  type-systems  static-typing 

พิจารณาคำถามนี้เป็น "วิชาการ" ฉันสงสัยเกี่ยวกับการหลีกเลี่ยง NULL เป็นครั้งคราวและนี่เป็นตัวอย่างที่ฉันไม่สามารถหาวิธีแก้ปัญหาที่น่าพอใจได้ สมมติว่าฉันเก็บค่าการวัดซึ่งบางครั้งการวัดนั้นเป็นไปไม่ได้ (หรือหายไป) ฉันต้องการเก็บค่า "ว่างเปล่า" ในตัวแปรในขณะที่หลีกเลี่ยงค่า NULL บางครั้งค่าอาจไม่เป็นที่รู้จัก ดังนั้นการมีการวัดสำหรับกรอบเวลาที่แน่นอนเคียวรีเกี่ยวกับการวัดภายในช่วงเวลานั้นอาจส่งคืนการตอบสนอง 3 ชนิด: การวัดจริงในเวลานั้น (เช่นค่าตัวเลขใด ๆ รวมถึง0) A "หายไป" / "ว่างเปล่า" ค่า (กล่าวคือเป็นวัดที่ได้กระทำและความคุ้มค่าเป็นที่รู้จักกันว่าเป็นที่ว่างเปล่าที่จุดนั้น) ค่าที่ไม่รู้จัก (เช่นไม่มีการวัดที่จุดนั้นอาจว่างเปล่า แต่อาจเป็นค่าอื่นก็ได้) ชี้แจงที่สำคัญ: สมมติว่าคุณมีฟังก์ชันที่get_measurement()ส่งคืนหนึ่งใน "ว่างเปล่า", "ไม่ทราบ" และค่าประเภท "จำนวนเต็ม" การมีค่าตัวเลขแสดงถึงการดำเนินการบางอย่างที่สามารถทำได้ในค่าส่งคืน (การคูณการหาร ... ) แต่การใช้การดำเนินการดังกล่าวกับ NULLs จะทำให้แอปพลิเคชันเสียหายหากไม่ถูกจับ ฉันต้องการที่จะสามารถเขียนรหัสหลีกเลี่ยงการตรวจสอบ NULL เช่น (pseudocode): >>> value = get_measurement() # …

57 data-structures  type-systems  data-types 

ทำไมตกลงนี้และคาดว่าส่วนใหญ่: abstract type Shape { abstract number Area(); } concrete type Triangle : Shape { concrete number Area() { //... } } ... ขณะนี้ไม่เป็นไรและไม่มีใครบ่น: concrete type Name : string { } concrete type Index : int { } concrete type Quantity : int { } แรงจูงใจของฉันคือการเพิ่มการใช้ระบบประเภทเพื่อการตรวจสอบความถูกต้องเวลารวบรวม PS: ใช่ฉันได้อ่านเรื่องนี้แล้วการห่อเป็นงานที่ยุ่งเหยิง

53 type-systems  static-typing  strong-typing 

การสมมติภาษาที่มีความปลอดภัยบางประเภท (เช่นไม่ใช่จาวาสคริปต์): ด้วยวิธีการที่ยอมรับได้SuperTypeเรารู้ว่าในกรณีส่วนใหญ่นั้นเราอาจถูกล่อลวงให้ทำการทดสอบประเภทเพื่อเลือกการกระทำ: public void DoSomethingTo(SuperType o) { if (o isa SubTypeA) { o.doSomethingA() } else { o.doSomethingB(); } } โดยปกติเราควรสร้างวิธีการ overridable เดียวSuperTypeและไม่ควรทำเช่นนี้เสมอ: public void DoSomethingTo(SuperType o) { o.doSomething(); } ... นั้นแต่ละประเภทย่อยจะได้รับการdoSomething()ดำเนินการของตัวเอง ส่วนที่เหลือของโปรแกรมของเรานั้นจะสามารถเหมาะสมไม่รู้ว่าใดก็ตามSuperTypeเป็นจริงหรือSubTypeASubTypeB ยอดเยี่ยม แต่เรายังคงได้รับis aการปฏิบัติเหมือนในภาษาส่วนใหญ่ถ้าไม่ใช่ทั้งหมด และนั่นแสดงให้เห็นถึงความต้องการที่อาจเกิดขึ้นสำหรับการทดสอบประเภทที่ชัดเจน ดังนั้นในสถานการณ์ใดบ้างถ้ามีควรเราหรือต้องเราดำเนินการทดสอบประเภทอย่างชัดเจน? ให้อภัยการขาดสติหรือขาดความคิดสร้างสรรค์ ฉันรู้ว่าฉันเคยทำมาก่อน แต่เมื่อนานมาแล้วฉันจำไม่ได้ว่าสิ่งที่ฉันทำดีหรือไม่! และในความทรงจำเมื่อเร็ว ๆ นี้ฉันไม่คิดว่าฉันจะต้องทดสอบประเภทนอกจาวาสคริปต์ของฉัน

53 type-systems 

เอริค Lippert ทำให้เป็นจุดที่น่าสนใจมากในการอภิปรายของเขาว่าทำไม C # ใช้nullมากกว่าMaybe<T>ประเภท : ความสอดคล้องของระบบพิมพ์เป็นสิ่งสำคัญ เราจะรู้ได้หรือไม่ว่าการอ้างอิงที่ไม่เป็นโมฆะนั้นไม่เคยภายใต้สถานการณ์ใด ๆ สิ่งที่เกี่ยวกับในตัวสร้างของวัตถุที่มีเขตข้อมูลที่ไม่เป็นโมฆะประเภทการอ้างอิง? สิ่งที่เกี่ยวกับใน finalizer ของวัตถุดังกล่าวที่วัตถุจะเสร็จสมบูรณ์เพราะรหัสที่ควรจะกรอกในการอ้างอิงโยนข้อยกเว้น? ระบบการพิมพ์ที่อยู่กับคุณเกี่ยวกับการรับประกันเป็นสิ่งที่อันตราย นั่นเป็นสิ่งที่เปิดตา แนวคิดเกี่ยวข้องกับฉันและฉันได้เล่นกับคอมไพเลอร์และระบบพิมพ์ แต่ฉันไม่เคยคิดถึงเรื่องนั้น ภาษาที่มีประเภทอาจจะเป็นอย่างไรแทนที่จะเป็นกรณีที่จับขอบโมฆะเช่นการเริ่มต้นและการกู้คืนข้อผิดพลาดซึ่งในความเป็นจริงการอ้างอิงที่ไม่ใช่โมฆะรับประกันไม่จริงในสถานะที่ถูกต้อง?

53 type-systems  null 

พื้นหลัง ฉันกำลังออกแบบภาษาเป็นโปรเจคต์ด้านข้าง ฉันมีแอสเซมเบลอร์ทำงานตัววิเคราะห์แบบคงที่และเครื่องเสมือนสำหรับมัน เนื่องจากฉันสามารถรวบรวมและเรียกใช้โปรแกรมที่ไม่น่าสนใจโดยใช้โครงสร้างพื้นฐานที่ฉันได้สร้างขึ้นฉันจึงคิดที่จะนำเสนอที่มหาวิทยาลัยของฉัน ในระหว่างการพูดคุยของฉันฉันบอกว่า VM ให้ระบบประเภทถูกถามว่า " ระบบประเภทของคุณคืออะไร " หลังจากตอบฉันได้รับเสียงหัวเราะจากผู้ที่ถามคำถาม ดังนั้นแม้ว่าฉันเกือบจะเสียชื่อเสียงในการถามคำถามนี้ แต่ฉันกลับไปที่โปรแกรมเมอร์ ความเข้าใจของฉัน ตามที่ฉันเข้าใจแล้วระบบประเภทถูกใช้เพื่อให้ข้อมูลเพิ่มเติมเกี่ยวกับเอนทิตีในโปรแกรมเพื่อให้รันไทม์หรือคอมไพเลอร์หรือเครื่องจักรอื่น ๆ รู้ว่าต้องทำอย่างไรกับสตริงของบิตที่ทำงาน พวกเขายังช่วยรักษาสัญญา - คอมไพเลอร์ (หรือตัววิเคราะห์โค้ดหรือรันไทม์หรือโปรแกรมอื่น ๆ ) สามารถตรวจสอบว่า ณ จุดใดก็ตามที่โปรแกรมทำงานกับค่าโปรแกรมเมอร์ที่คาดหวังว่ามันจะทำงาน ประเภทยังสามารถใช้เพื่อให้ข้อมูลกับโปรแกรมเมอร์มนุษย์เหล่านั้น ตัวอย่างเช่นฉันพบประกาศนี้: function sqrt(double n) -> double; มีประโยชน์มากกว่านี้ sqrt(n) ก่อนหน้านี้ให้ข้อมูลมากมาย: sqrtตัวระบุเป็นฟังก์ชั่นรับdoubleอินพุตหนึ่งตัวและสร้างอีกdoubleอันเป็นเอาต์พุต หลังบอกคุณว่ามันอาจเป็นฟังก์ชั่นการใช้พารามิเตอร์เดียว คำตอบของฉัน ดังนั้นหลังจากถูกถามว่า "ระบบประเภทของคุณคืออะไร" ฉันตอบดังนี้: ระบบประเภทเป็นแบบไดนามิก (ประเภทถูกกำหนดให้กับค่าไม่ใช่ตัวแปรที่เก็บไว้) แต่มีความแข็งแกร่งโดยไม่มีกฎบังคับที่น่าแปลกใจ (คุณไม่สามารถเพิ่มสตริงลงในจำนวนเต็มเนื่องจากมันเป็นประเภทที่เข้ากันไม่ได้ แต่คุณสามารถเพิ่มจำนวนเต็มเป็นจำนวนจุดลอยตัว) . ระบบชนิดถูกใช้โดย VM …

50 programming-languages  language-design  inheritance  type-systems  virtual-machine 

ประเภทด้านล่างเป็นโครงสร้างที่ปรากฏในทฤษฎีประเภทคณิตศาสตร์เป็นหลัก มันจะเรียกว่าประเภทที่ว่างเปล่า มันเป็นประเภทที่ไม่มีค่า แต่เป็นประเภทย่อยของทุกประเภท หากประเภทส่งคืนของฟังก์ชันเป็นประเภทด้านล่างแสดงว่าไม่ส่งคืน ระยะเวลา บางทีมันอาจจะวนซ้ำไปตลอดกาลหรืออาจจะเป็นข้อยกเว้น อะไรคือสิ่งที่มีประเภทแปลก ๆ นี้ในภาษาการเขียนโปรแกรม? มันไม่ใช่เรื่องธรรมดา แต่มีอยู่ในบางอย่างเช่น Scala และ Lisp

49 programming-languages  type-systems 

ในJavaScript: ส่วนที่ดีโดย Douglas Crockford เขากล่าวถึงในบทที่สืบทอดของเขา ประโยชน์อื่น ๆ ของการสืบทอดแบบคลาสสิกคือมันมีคุณสมบัติของประเภทของระบบ สิ่งนี้ส่วนใหญ่ทำให้โปรแกรมเมอร์ไม่ต้องเขียนการดำเนินการร่ายที่ชัดเจนซึ่งเป็นสิ่งที่ดีมากเพราะเมื่อทำการร่ายประโยชน์ด้านความปลอดภัยของระบบประเภทจะหายไป ก่อนอื่นเลยความปลอดภัยคืออะไร? การป้องกันข้อมูลเสียหายหรือแฮกเกอร์หรือระบบทำงานผิดปกติ ฯลฯ ? ประโยชน์ด้านความปลอดภัยของระบบประเภทใด อะไรทำให้ระบบการพิมพ์แตกต่างกันซึ่งอนุญาตให้มีประโยชน์ด้านความปลอดภัยเหล่านี้

47 type-systems  type-safety 

PHP เป็นส่วนใหญ่ของเราทราบว่ามีการพิมพ์ที่อ่อนแอ สำหรับคนที่ไม่ทำ PHP.net พูดว่า: PHP ไม่ต้องการคำนิยามประเภทที่ชัดเจน (หรือสนับสนุน) ในการประกาศตัวแปร ชนิดของตัวแปรถูกกำหนดโดยบริบทที่ใช้ตัวแปรนั้น ไม่ว่าจะชอบหรือเกลียด PHP ก็สร้างตัวแปรใหม่ขึ้นมาทันที ดังนั้นรหัสต่อไปนี้ถูกต้อง: $var = "10"; $value = 10 + $var; var_dump($value); // int(20) PHP ยังอนุญาตให้คุณสร้างตัวแปรอย่างชัดเจนเช่น: $var = "10"; $value = 10 + $var; $value = (string)$value; var_dump($value); // string(2) "20" ทั้งหมดนี้ยอดเยี่ยม ... แต่สำหรับชีวิตของฉันฉันไม่สามารถเข้าใจถึงเหตุผลที่ปฏิบัติได้สำหรับการทำเช่นนี้ ฉันไม่มีปัญหากับการพิมพ์ที่แข็งแกร่งในภาษาที่รองรับเช่น Java ไม่เป็นไรและฉันเข้าใจอย่างถ่องแท้ นอกจากนี้ฉันรู้และเข้าใจถึงประโยชน์ของการบอกกล่าวชนิดในพารามิเตอร์ฟังก์ชัน ปัญหาที่ฉันมีกับการคัดเลือกนักแสดงอธิบายโดยข้อความข้างต้น …

45 php  type-systems  weak-typing  type-casting 

ฉันสงสัยอยู่เสมอว่าทำไม Java ไม่พิมพ์ข้อสรุปเนื่องจากภาษาเป็นสิ่งที่มันเป็นและ VM เป็นผู้ใหญ่มาก Google's Go เป็นตัวอย่างของภาษาที่มีการอนุมานประเภทที่ยอดเยี่ยมและลดจำนวนการพิมพ์ที่ต้องทำ มีเหตุผลพิเศษเบื้องหลังคุณสมบัตินี้หรือไม่ที่ไม่ได้เป็นส่วนหนึ่งของ Java?

44 java  programming-languages  type-systems  data-types 

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

43 functional-programming  haskell  type-systems 

สิ่งนี้เกิดขึ้นในการพูดคุยกับเพื่อนและฉันพบว่าตัวเองถูกกดขี่เพื่อคิดข้อโต้แย้งที่ดี การพิมพ์ที่ได้รับประโยชน์มีประโยชน์อะไรบ้าง

40 type-systems  type-safety  weak-typing 

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

37 programming-languages  type-systems