อะไรคือข้อดีและข้อเสียในแนวทางของ C #, Java และ Scala to Closures / Lambdas / …?

ฉันสงสัยว่าสิ่งที่แตกต่างระหว่างดำเนินการทางเทคนิค C # และสกาล่าและวิธีการแก้ปัญหาทั้งเปรียบเทียบกับความคิดของการดำเนินงานและความกังวลเปล่งออกมาในอีเมลPeek อดีตแลมบ์ดาโดยไบรอันเก๊ส่งไปยังรายการทางไปรษณีย์ของโครงการแลมบ์ดา (JSR 335) ?

จากอีเมล:

เราสำรวจถนนของ "บางที lambdas ควรจะเป็นอินสแตนซ์ของคลาสภายในซึ่งจะง่ายมาก" แต่ในที่สุดก็มาถึงตำแหน่งของ "ฟังก์ชั่นเป็นทิศทางที่ดีกว่าสำหรับอนาคตของภาษา"

และต่อไป:

มุมมอง lambdas-are-objects ของโลกขัดแย้งกับอนาคตที่เป็นไปได้นี้ มุมมอง lambdas-are-function ของโลกไม่ได้และการรักษาความยืดหยุ่นนี้เป็นหนึ่งในจุดที่สนับสนุน lambdas ที่ไม่ทำให้เกิดภาระด้วยแม้แต่ลักษณะที่ปรากฏของวัตถุ

สรุป:

Lambdas-are-function เปิดประตู Lambdas-are-objects ปิดพวกเขา
เราต้องการเห็นประตูที่เปิดทิ้งไว้

และความคิดเห็นบางส่วนจากบุคคลในเธรด Redditพูดว่า:

จริง ๆ แล้วฉันส่งอีเมลถึง Neal Gafter เกี่ยวกับเรื่องนี้และความเข้าใจที่ จำกัด ของฉันเกี่ยวกับการอธิบายของเขา C # และการออกแบบ Java ในปัจจุบันค่อนข้างคล้ายกับที่ผู้ได้รับมอบหมายเป็นวัตถุจริงและไม่ใช่ประเภทการทำงาน ดูเหมือนว่าเขาเชื่อว่า Java ควรเรียนรู้จากข้อเสียของแกะแกะ C # และหลีกเลี่ยงพวกเขา (เช่น C # เรียนรู้จากข้อเสียของ Java และหลีกเลี่ยงพวกเขาในตอนแรก)

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

เมื่อเห็นว่าสิ่งต่าง ๆ ใน Scala "แค่งาน" ฉันคิดอยู่เสมอว่าฉันพลาดอะไรบางอย่างเกี่ยวกับวิธีการที่นำเสนอ / ใน C # / Java (8) บางทีมันอาจเกี่ยวข้องกับข้อกังวลเกี่ยวกับความเข้ากันได้แบบย้อนหลัง?

ฉันคิดว่าการอภิปรายเกี่ยวกับวัตถุกับฟังก์ชั่นเป็นปลาเฮอริ่งแดง หากคำถามคือ "แลมบ์ดาเป็นฟังก์ชั่นหรือวัตถุ?" คำตอบที่ควรจะใช่

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

สกาล่าทำสิ่งนี้ได้สำเร็จโดยการใช้อ็อบเจกต์ wrapper ที่มีเมธอดที่เรียกได้applyซึ่งสามารถเรียกใช้ด้วย just ()ทำให้ดูเหมือนกับการเรียกเมธอด มันใช้งานได้อย่างยอดเยี่ยม เวลาส่วนใหญ่คุณไม่จำเป็นต้องสนใจว่าคุณมีวิธีการหรือกำลังเรียกใช้การใช้งานฟังก์ชั่นวัตถุ

จากสิ่งที่ฉันเข้าใจมันเป็นเรื่องเกี่ยวกับการพิจารณาของ lambdas ในระดับภาษาหลัก อย่างที่อีเมลบอก

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

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

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

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

ฉันไม่ชอบประเภทฟังก์ชั่น - ฉันรักประเภทฟังก์ชั่น - แต่ฟังก์ชั่นประเภทนั้นต่อสู้อย่างรุนแรงกับแง่มุมที่มีอยู่ของระบบประเภทจาวาลบออก ประเภทฟังก์ชั่นที่ลบจะเลวร้ายที่สุดของทั้งสองโลก

พิจารณาวิธีการเหล่านี้ใน Scala's Regex:

def replaceAllIn (target: CharSequence, replacer: (Match) ⇒ String): String
def replaceSomeIn (target: CharSequence, replacer: (Match) ⇒ Option[String]): String

มันจะง่ายกว่านี้ถ้าเป็นแบบนี้:

def replace (target: CharSequence, replacer: (Match) ⇒ String): String
def replace (target: CharSequence, replacer: (Match) ⇒ Option[String]): String

น่าเสียดายที่เป็นไปไม่ได้เพราะทั้งสองฟังก์ชั่นนั้นเหมือนกันภายใต้การลบ แต่ก็ดีฟังก์ชั่นเหล่านี้ทำสิ่งที่แตกต่างกันบ้างดังนั้นชื่อที่แตกต่างกันอาจจะยุติธรรมพอ

อย่างไรก็ตาม a Matchเป็นสิ่งที่มีประโยชน์มาก แต่โดยส่วนใหญ่คุณต้องการให้ตรงกับStringหรือรายการของกลุ่มย่อย เราอยากได้สิ่งนี้:

def replaceAllIn (target: CharSequence, replacer: (String) ⇒ String): String
def replaceAllIn (target: CharSequence, replacer: (Seq[String]) ⇒ String): String
def replaceAllIn (target: CharSequence, replacer: (Match) ⇒ String): String

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

และจากนั้นให้พิจารณาว่าการจับคู่รูปแบบของ Scala และ Java instanceofนั้นไร้ประโยชน์อย่างมีประสิทธิภาพเนื่องจากการลบออก

ฉันคิดว่ามันยุติธรรมพอที่จะหน่วงชนิดของฟังก์ชันจนกว่าปัญหานี้จะได้รับการจัดการ ท้ายที่สุดมีภาษามากมายที่มีอยู่ใน JVM และไม่เหมือน Java เป็นภาษาที่พัฒนาอย่างรวดเร็ว