โครงสร้างข้อมูลควรรวมเข้ากับภาษา (เช่นเดียวกับ Python) หรือมีอยู่ในไลบรารีมาตรฐาน (เช่นเดียวกับใน Java)?

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

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

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

มันขึ้นอยู่กับว่าภาษานั้นมีไว้เพื่ออะไร

ตัวอย่างบางส่วน (ค่อนข้างถูกขโมยจากคำตอบอื่น ๆ ):

• Perl มีไวยากรณ์พิเศษสำหรับ hashtables, อาร์เรย์, สตริง Perl มักจะใช้สำหรับการเขียนสคริปต์ซึ่งมีประโยชน์สำหรับการเขียนสคริปต์
• Matlab มีไวยากรณ์พิเศษสำหรับรายการการฝึกอบรมโครงสร้าง Matlab สำหรับทำเมทริกซ์และคณิตศาสตร์เวกเตอร์สำหรับงานวิศวกรรม
• Java / .NET รองรับสตริงและอาร์เรย์ เหล่านี้เป็นภาษาที่ใช้งานทั่วไปที่มักใช้อาเรย์และสตริง (น้อยลงด้วยการใช้คลาสคอลเลกชันใหม่)
• สนับสนุนอาร์เรย์ C / C ++ เหล่านี้เป็นภาษาที่ไม่ซ่อนฮาร์ดแวร์จากคุณ สนับสนุนสตริงบางส่วน (ไม่มีการต่อข้อมูลซ้อนใช้ strcpy เป็นต้น)

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

สำหรับฉันการรวบรวมขยะเป็นไปตามตรรกะเดียวกัน: ผู้ชมที่สนใจภาษาของคุณรู้เกี่ยวกับการจัดสรรหรือปลดปล่อยหน่วยความจำเมื่อใดและอย่างถี่ถ้วนหรือไม่? ถ้าใช่ malloc / ฟรี ถ้าไม่ใช่ให้รวบรวมขยะ

Perl มี hashmaps และ PL / SQL บันทึกการสนับสนุนและฉันมีความทรงจำที่มีหมอกหนามาก MATLAB มีไวยากรณ์ที่จะเวกเตอร์การสนับสนุนและการฝึกอบรมที่มีขนาดแตกต่างกันทั้งหมด ( แต่ผมอาจจะผิดเกี่ยวกับเรื่องนี้และมันอาจจะระบุว่าเหล่านี้เป็นข้อมูลประเภทไม่ได้ข้อมูลโครงสร้าง ) ... ฉันอยากจะบอกว่าการได้รับการสนับสนุนจากชาวพื้นเมืองสำหรับโครงสร้างที่เหมือนกันเป็นเรื่องที่ดี มักจะดูเหมือนว่าอาร์เรย์และ hashmaps / เชื่อมโยงอาเรย์เป็นโครงสร้างที่ได้รับการสนับสนุนที่พบบ่อยที่สุดและพวกเขาอาจจะใช้บ่อยที่สุดเช่นกัน

อย่าลืมว่าถ้าคุณเพิ่มการสนับสนุนไวยากรณ์ดั้งเดิมสำหรับโครงสร้างอื่น ๆ เช่น binary-trees โครงสร้างเหล่านั้นยังถูกนำไปใช้โดยเครื่องมือสนับสนุนของภาษา (คอมไพเลอร์ / รันไทม์ / etc) คุณต้องการสร้างการสนับสนุนกี่ strucutres

คุณจะต้องสร้างสัญกรณ์ใหม่สำหรับโครงสร้างที่สนับสนุนโดยทั่วไปน้อยกว่า ... Keep It Simple!

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

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

คุณไม่จำเป็นต้องมีไวยากรณ์เฉพาะสำหรับทุกประเภทข้อมูลระดับสูง ยกตัวอย่างเช่นมันเป็นที่ยอมรับที่จะมีset([1, 2, 3])(เป็นงูหลาม 2.x ได้) {1, 2, 3}แทน

สิ่งที่สำคัญคือการมีบางวิธีที่สะดวกในการสร้างโครงสร้างข้อมูลระดับสูง สิ่งที่คุณต้องการหลีกเลี่ยงคือรหัสเช่น:

s = set()
s.add(1)
s.add(2)
s.add(3)

ซึ่งทำให้ฉันรำคาญอย่างมากเมื่อผมใช้std::vector, std::setและstd::mapใน C ++ std::initializer_listโชคดีที่เป็นมาตรฐานใหม่จะมี

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

• มันราคาถูกที่จะเพิ่มเป็นภาษา ไม่เสียค่าใช้จ่ายกับงบประมาณความซับซ้อนอันมีค่าของคุณ:
  • ไวยากรณ์นั้นเป็นพื้นsomeBracket {expr ','} someBracketหรือsomeBracket {expr ':' expr ','} someBracketมีสิ่งพิเศษอย่างง่ายบางอย่างที่ตายแล้วหากคุณต้องการสิ่งต่าง ๆ เช่นคอมม่าตามท้าย ตัวอักษรลอยสามารถจะได้อยู่ในไวยากรณ์
  • ในหลายภาษาไม่มีตัวอักษรตัวใดตัวหนึ่งที่ได้รับความนิยมพร้อมกับไวยากรณ์ที่มีอยู่ (ข้อยกเว้นที่ฉันนึกได้คือภาษาที่มีบล็อกที่เหมือนวงเล็บปีกกาเป็นนิพจน์ตัวดำเนินการคอมม่าและไม่มีเครื่องหมายอัฒภาคเหมือนใน{1, 2})
  • ความหมายสามารถกำหนดได้ในประโยคน้อยกว่าห้าประโยครุ่นไม่เป็นทางการคือ "สร้างอินสแตนซ์ของคอลเลคชั่น $ ใหม่จากนั้นโทร.add/ .append/ .setItemหนึ่งครั้งต่อนิพจน์ที่กำหนดด้วยนิพจน์ (เหล่านั้น) เป็นอาร์กิวเมนต์"
• เนื่องจากจุดที่สามก่อนหน้านี้มันง่ายมากที่จะใช้งาน
• มันมีประโยชน์อย่างเหลือเชื่อเมื่อคุณต้องการและไม่จำเป็นต้องส่งผลกระทบต่อไวยากรณ์ขององค์ประกอบอื่น ๆ นั่นคือคุณไม่ต้อง "จ่าย" เมื่อคุณไม่ได้ใช้งาน

Clojure เป็นเสียงกระเพื่อม แต่สนับสนุน

Lists: (x1 x2)
Vectors: [x1 x2]
Maps: {k1 v1 k2 v2}
Sets: #{x1 x2}

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

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

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

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

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

ฉันใช้เป็นเกณฑ์มาตรฐานของการแสดงออกทางภาษาว่าสามารถเขียนโครงสร้างข้อมูลของตัวเองเป็นห้องสมุดได้ดีเพียงใดและการใช้งานนั้นสะดวกเพียงใด

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

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

APL (และตัวแปรสมัยใหม่ที่เกี่ยวข้อง, A +, J และ K) มีสเกลาร์, เวกเตอร์และเมทริกซ์เป็นโครงสร้างข้อมูลชั้นหนึ่ง

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

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

รายการและตัวอักษรแผนที่และไวยากรณ์การปิดอำนวยความสะดวกเป็นคุณสมบัติที่สำคัญของภาษาระดับสูง

ความแตกต่างระหว่างรหัส Java นี้:

Thing t = new Thing();
t.setFoo(3);
t.setBar(6.3);
t.setBaz(true);

และรหัส Groovy นี้:

t = new Thing(foo: 3, bar: 6.3, baz: true)

มีขนาดใหญ่มาก มันคือความแตกต่างระหว่างโปรแกรม 40,000 เส้นและโปรแกรม 10,000 เส้น ไวยากรณ์มีความสำคัญ

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

• ลำดับที่สั่งซื้อ (1 มิติ): อาร์เรย์คิวสแต็ครายการ ...
• สั่งโครงสร้างหลายมิติ : ตารางเวกเตอร์ matrice ..
• maps : hashmap, dictionary, set, multimap ... (1 มิติ)
• แผนที่หลายมิติ : ฟังก์ชั่นแผนที่แผนที่ ...
• ประเภทกราฟ : ต้นไม้, กราฟกำกับ ...

คุณสามารถเลียนแบบโครงสร้างใด ๆด้วยโครงสร้างอื่น ๆ - ขึ้นอยู่กับความง่ายและชัดเจนของภาษาการเขียนโปรแกรมที่อนุญาต ตัวอย่างเช่น

• คิวและสแต็กนั้นง่ายต่อการเลียนแบบด้วยอาร์เรย์หรือรายการจากส่วนหลังให้การดำเนินการเช่น push, pop, shift เป็นต้น
• ลำดับที่สั่งไว้สามารถถูกจำลองด้วยแผนที่ที่มีปุ่มตัวเลข
• ชุดสามารถถูกเลียนแบบโดยแผนที่ที่แม็พค่ากับบูลีน
• กราฟส่วนใหญ่สามารถจำลองได้โดยลำดับการซ้อนหรือแผนที่
• สามารถใช้ฟังก์ชันเลียนแบบแผนที่ได้หากคุณสามารถแก้ไขคำจำกัดความของแผนที่ได้อย่างง่ายดาย

ภาษาส่วนใหญ่มีอย่างน้อยหนึ่งประเภทสำหรับลำดับที่สั่งซื้อหนึ่งรายการสำหรับแผนที่ 1 มิติและอีกหนึ่งรายการสำหรับแผนที่หลายมิติ จำกัด เฉพาะฟังก์ชัน โดยส่วนตัวแล้วฉันมักจะพลาดชุดและสั่งโครงสร้างหลายมิติในภาษาเช่น Perl, PHP, JavaScript, Lua ... เพราะการลอกเลียนแบบมันไม่สะดวกพอ

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

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

• อาร์เรย์ที่มีความยาวคงที่
• ชุด
• Hashmaps
• ลำดับ / รายการ
• บันทึก / structs / คลาส

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

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

• ไม่แน่นอนหรือไม่เปลี่ยนรูป?
• อนุญาตโมฆะหรือไม่
• ทำข้อมูลให้ตรงกันหรือไม่?
• สนับสนุนโดยที่เก็บข้อมูลถาวรหรือไม่?