ทำไม“ การมีเพศสัมพันธ์อย่างแน่นหนาระหว่างฟังก์ชั่นและข้อมูล” ไม่ดี?

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

[A] ข้อเสียของการเขียนโปรแกรมเชิงวัตถุคือการมีเพศสัมพันธ์อย่างแน่นหนาระหว่างฟังก์ชั่นและข้อมูล

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

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

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

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

ดังนั้น Clojure มีเนมสเปซ การผสานฟังก์ชันกับคลาสใน OOP แตกต่างจากการผสานฟังก์ชันในเนมสเปซใน Clojure ได้อย่างไรและทำไมมันจึงไม่ดี โปรดจำไว้ว่าฟังก์ชั่นในชั้นเรียนไม่จำเป็นต้องทำงานกับสมาชิกของคลาสนั้นเสมอไป ดูที่ java.lang.StringBuilder - ทำงานกับประเภทการอ้างอิงใด ๆ หรือผ่าน auto-Boxing ทุกประเภท

อ้างอิง PS อ้างหนังสือเล่มนี้ที่ผมยังไม่ได้อ่าน: การเขียนโปรแกรม Multiparadigm ใน Leda: ทิโมธี Budd 1995

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

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

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

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

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

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

นั่นคือข้อเสียของ OO - มันส่งเสริมความชั่วร้ายชนิดนี้การมีเพศสัมพันธ์ของข้อมูลในการทำงานผ่านการสร้างมาตรฐานการปิด (ซึ่งเป็นทฤษฎีการเขียนโปรแกรมหน้าต่างแตก )

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

มันเกี่ยวกับการมีเพศสัมพันธ์ประเภท :

ฟังก์ชั่นที่อยู่ภายในวัตถุเพื่อทำงานกับวัตถุนั้นไม่สามารถใช้กับวัตถุประเภทอื่นได้

ใน Haskell คุณเขียนฟังก์ชั่นเพื่อทำงานกับคลาสประเภท- ดังนั้นจึงมีวัตถุหลายประเภทที่ฟังก์ชันที่กำหนดสามารถทำงานได้ตราบใดที่มันเป็นประเภทของคลาสที่กำหนดที่ใช้งานได้

ฟังก์ชั่นยืนฟรีอนุญาตให้ decoupling ที่คุณไม่ได้รับเมื่อคุณมุ่งเน้นการเขียนฟังก์ชั่นของคุณให้ทำงานภายในประเภท A เพราะคุณจะไม่สามารถใช้งานได้หากคุณไม่มีอินสแตนซ์ประเภท A แม้ว่าฟังก์ชันอาจ ไม่อย่างนั้นจะเป็นเรื่องทั่วไปพอที่จะใช้กับอินสแตนซ์ของประเภท B หรืออินสแตนซ์ของประเภท C

ใน Java และสาขาที่คล้ายกันของ OOP วิธีการอินสแตนซ์ (ซึ่งแตกต่างจากฟังก์ชั่นฟรีหรือวิธีการขยาย) ไม่สามารถเพิ่มจากโมดูลอื่น ๆ

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

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

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

สิ่งนี้หมายความว่าวัตถุหลายประเภทเดียวกันอาจมีข้อมูลที่แตกต่างกัน แม้แต่วัตถุเดียวกันก็อาจมีข้อมูลต่างกันในเวลาต่างกัน (ตัวอย่างเช่นใน Scala, Maps และSets สลับระหว่างอาร์เรย์และ hash trie ขึ้นอยู่กับจำนวนขององค์ประกอบเพราะสำหรับการค้นหาเชิงเส้นในจำนวนที่น้อยมากจะเร็วกว่าการค้นหาแบบลอการิทึมในโครงสร้างการค้นหาเนื่องจากปัจจัยคงที่ขนาดเล็กมาก .)

จากด้านนอกของวัตถุคุณไม่ควรคุณไม่สามารถรู้ถึงการแสดงข้อมูล นั่นคือสิ่งที่ตรงกันข้ามกับคลัปแน่น

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

คุณต้องการให้ข้อมูลที่แตกต่างกันไปยังฟังก์ชั่นไม่ต้องการการเปลี่ยนแปลงใด ๆ ในฟังก์ชั่นและในทำนองเดียวกันคุณต้องการที่จะสามารถเปลี่ยนแปลงฟังก์ชั่นได้โดยไม่จำเป็นต้องเปลี่ยนแปลงข้อมูลใด ๆ