หากเราสามารถใช้งานฟังก์ชั่นการเขียนโปรแกรมด้วย Python เราจำเป็นต้องใช้ภาษาโปรแกรมฟังก์ชั่นเฉพาะหรือไม่ [ปิด]

การใช้เครื่องกำเนิดไฟฟ้าและแลมบ์ดาเราสามารถทำการเขียนโปรแกรมใช้งานได้กับ Python คุณสามารถบรรลุสิ่งเดียวกันกับทับทิม

ดังนั้นคำถามคือทำไมเราต้องใช้ภาษาการเขียนโปรแกรมฟังก์ชั่นเฉพาะเช่น Erlang, Haskell และ Scheme? มีอะไรแตกต่างไปจากภาษาการเขียนโปรแกรมฟังก์ชั่นเฉพาะเหล่านี้หรือไม่? ทำไมเราไม่ใช้ Python ในการเขียนโปรแกรมเพื่อการทำงาน?

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

ความบริสุทธิ์

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

ประสิทธิภาพ

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

การเพิ่มประสิทธิภาพการโทรหาง

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

วากยสัมพันธ์

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

• ไวยากรณ์สำหรับฟังก์ชั่นแลมบ์ดาค่อนข้างชัดเจนและ จำกัด ในสิ่งที่พวกเขาสามารถมี
• ไม่มีน้ำตาล syntactic สำหรับองค์ประกอบของฟังก์ชั่นเช่นf = g . hกับf = lambda *arg: g(h(*arg))
• ไม่มีน้ำตาลประโยคสำหรับการใช้งานบางส่วนเช่นf = map gกับf = functools.partial(map, g)
• ไม่มีน้ำตาลประโยคที่ใช้ประกอบการมัดในฟังก์ชั่นการสั่งซื้อที่สูงขึ้นเช่นsum = reduce (+) lstเมื่อเทียบกับsum = reduce(operator.add, lst)
• ไม่มีการจับคู่รูปแบบหรือตัวป้องกันสำหรับอาร์กิวเมนต์ของฟังก์ชันซึ่งทำให้ง่ายต่อการแสดงเงื่อนไขการสิ้นสุดการเรียกซ้ำและเส้นขอบบางกรณีที่มีไวยากรณ์ที่อ่านง่ายมาก
• วงเล็บไม่เคยเป็นตัวเลือกสำหรับการเรียกใช้ฟังก์ชั่นและไม่มีน้ำตาล syntactic สำหรับการโทรซ้อน ฉันเดาว่านี่เป็นเรื่องของรสนิยม แต่โดยเฉพาะอย่างยิ่งในโค้ดการทำงานฉันพบว่ามันเป็นเรื่องปกติในการเรียกใช้ฟังก์ชันลูกโซ่และฉันy = func1 $ func2 $ func3 xอ่านง่ายกว่าy = func1(func2(func3(x)))เมื่อคุณคุ้นเคยกับสัญลักษณ์นั้น

นี่คือความแตกต่างที่สำคัญที่สุด:

Haskell

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

Haskell และ Erlang

• การจับคู่รูปแบบ

Erlang

• รูปแบบนักแสดงของกระบวนการที่เกิดขึ้นพร้อมกันน้ำหนักเบา

โครงการ

• แมโคร

ทุกภาษา

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

นอกจากนี้คุณควรดูภาษาจากตระกูล ML เช่น SML, Ocaml และ F # และ Scala ซึ่งหลอมรวม OO และการเขียนโปรแกรมการทำงานในรูปแบบใหม่ ภาษาทั้งหมดเหล่านี้มีคุณสมบัติที่น่าสนใจไม่เหมือนใคร

เป็นการยากที่จะกำหนดว่า "ภาษาที่ใช้งานได้" นั้นเป็นภาษาใด - ออกจากรายการที่คุณระบุมีเพียง Haskell เท่านั้นที่ทำงานได้อย่างหมดจด มีคุณสมบัติทางภาษาบางอย่างที่มีประโยชน์มากสำหรับการเขียนโปรแกรมใช้งานได้และ Ruby และ Python ไม่เพียงพอที่จะเป็นสภาพแวดล้อมที่ดีสำหรับ FP นี่คือรายการตรวจสอบส่วนบุคคลของฉันตามลำดับความสำคัญ:

1. ฟังก์ชั่นชั้นหนึ่งและการปิด (Ruby, Python และอื่น ๆ ทั้งหมดที่คุณมีอยู่ในรายการ)
2. รับประกันการเพิ่มประสิทธิภาพการโทรหาง (Erlang, Haskell, Scala และ Scheme มีสิ่งนี้ แต่ไม่ใช่ Python, Ruby หรือ Clojure (ยัง))
3. รองรับการเปลี่ยนแปลงไม่ได้ในภาษาและไลบรารีมาตรฐาน (นี่เป็นสิ่งใหญ่ที่ "ภาษาที่ใช้งานได้" ทั้งหมดที่คุณระบุไว้มี (ยกเว้น Scheme) แต่ไม่มี Ruby และ Python
4. การสนับสนุนระดับภาษาสำหรับฟังก์ชั่น (หรือบริสุทธิ์) อ้างอิงโปร่งใส (เท่าที่ฉันรู้เพียง Haskell มีสิ่งนี้ในปัจจุบัน)

ความต้องการ (1) ควรชัดเจน - ฟังก์ชั่นการเรียงลำดับที่สูงขึ้นนั้นยากมากหากไม่มีฟังก์ชั่นชั้นหนึ่ง เมื่อผู้คนพูดถึง Ruby และ Python เป็นภาษาที่ดีสำหรับ FP พวกเขามักพูดถึงเรื่องนี้ อย่างไรก็ตามคุณสมบัตินี้จำเป็น แต่ไม่เพียงพอที่จะสร้างภาษาที่ดีสำหรับ FP

(2) เป็นสิ่งจำเป็นดั้งเดิมสำหรับ FP นับตั้งแต่มีการคิดค้นโครงการ หากไม่มี TCO จะเป็นไปไม่ได้ที่จะตั้งโปรแกรมด้วยการเรียกซ้ำแบบลึกซึ่งเป็นหนึ่งในเสาหลักของ FP เพราะคุณจะได้รับสแต็กล้น ภาษา "ใช้งานได้" เท่านั้น (ตามคำจำกัดความนิยม) ที่ไม่มีนี่คือ Clojure (เนื่องจากข้อ จำกัด ของ JVM) แต่ Clojure มีแฮ็คที่หลากหลายเพื่อจำลอง TCO (FYI, Ruby TCO เป็นการนำไปใช้โดยเฉพาะแต่ Python ไม่สนับสนุนมันโดยเฉพาะ) เหตุผลที่ TCO ต้องมีการรับประกันก็คือถ้ามันเป็นฟังก์ชั่นเฉพาะการนำไปใช้งานฟังก์ชั่นวนซ้ำแบบลึกจะทำลายด้วยการใช้งานบางอย่าง ใช้พวกเขาเลย

(3) เป็นอีกเรื่องใหญ่ที่ภาษาการใช้งานสมัยใหม่ (โดยเฉพาะ Haskell, Erlang, Clojure และ Scala) มี Ruby และ Python อยู่ โดยไม่ต้องลงรายละเอียดมากเกินไปความไม่สามารถเปลี่ยนแปลงได้รับประกันว่าจะกำจัดข้อบกพร่องทั้งหมดในชั้นเรียนโดยเฉพาะอย่างยิ่งในสถานการณ์ที่เกิดขึ้นพร้อมกันโครงสร้างข้อมูลแบบถาวร เป็นการยากมากที่จะใช้ประโยชน์จากสิทธิประโยชน์เหล่านี้หากไม่มีการสนับสนุนระดับภาษา

(4) สำหรับฉันสิ่งที่น่าสนใจที่สุดเกี่ยวกับภาษาที่ใช้งานได้อย่างหมดจด (เมื่อเทียบกับภาษาผสม) ลองพิจารณาฟังก์ชั่น Ruby ที่ง่ายมาก ๆ ดังต่อไปนี้:

def add(a, b)
  a + b
end

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

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

ทั้งหมดที่กล่าวมาเป็นไปได้ที่จะใช้เทคนิค FP ในเกือบทุกภาษา (แม้แต่ Java) ตัวอย่างเช่นMapReduceของ Google ได้รับแรงบันดาลใจจากแนวคิดการทำงาน แต่เท่าที่ฉันรู้ว่าพวกเขาไม่ได้ใช้ภาษา "การทำงาน" สำหรับโครงการขนาดใหญ่ของพวกเขา (ฉันคิดว่าพวกเขาส่วนใหญ่ใช้ C ++, Java และ Python)

ภาษาที่คุณพูดถึงนั้นแตกต่างกันมาก

ในขณะที่ Python และ Ruby เป็นภาษาที่พิมพ์แบบไดนามิก Haskell จะถูกพิมพ์แบบคงที่ Erlang เป็นภาษาที่เกิดขึ้นพร้อมกันและใช้โมเดล Actor และแตกต่างจากภาษาอื่น ๆ ทั้งหมดที่คุณพูดถึง

Python และ Ruby มีโครงสร้างที่จำเป็นมากมายในขณะที่ในภาษาที่มีฟังก์ชั่นที่บริสุทธิ์กว่าเช่น Haskell ทุกอย่างจะส่งคืนบางสิ่งหรือในคำอื่น ๆ ทุกอย่างก็คือฟังก์ชัน

ไปงานเลี้ยงช้าเหมือนปกติ แต่จะพูดอะไรต่อไป

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

อะไรที่ทำให้ภาษาเขียนโปรแกรมการทำงานเป็นสิ่งที่ไม่อนุญาตให้คุณไปยังโปรแกรมเหมือนมันเป็นสิ่งที่จะช่วยให้คุณเช่นโปรแกรมได้อย่างง่ายดาย นั่นคือกุญแจสำคัญ

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

เหตุใดเราจึงมีภาษาโปรแกรมที่ใช้งานได้เมื่อ Python (หรือ Ruby (หรือแทรกภาษาที่คุณเลือก)) สามารถ "ทำการเขียนโปรแกรมทำงานได้"? เนื่องจาก Python และ al ไม่สามารถทำการโปรแกรมที่เหมาะสมได้ นั่นเป็นเหตุผล

คุณสามารถเขียนโปรแกรมใช้งานได้ใน Java (ดูเช่นhttp://functionaljava.org/ ) นอกจากนี้คุณยังสามารถทำเขียนโปรแกรมเชิงวัตถุใน C มันไม่ใช่สำนวนที่ว่า

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

คำถามนี้สามารถใช้ได้กับหลายภาษาและกระบวนทัศน์

• เนื่องจากทุกคนใช้ภาษา C ++ ทำไมเราถึงต้องการภาษาอื่น ๆ
• เนื่องจาก java เป็นภาษา OO ที่ยอดเยี่ยมทำไมภาษา OO อื่น ๆ จึงมีอยู่
• เนื่องจาก Perl เป็นภาษาสคริปต์ที่ยอดเยี่ยมทำไมเราถึงต้องการงูใหญ่?
• Yatta, Yatta, Yatta

ส่วนใหญ่หากไม่ใช่ทุกภาษามีอยู่ด้วยเหตุผลเฉพาะ พวกเขามีอยู่เพราะมีบางคนต้องการที่จะไม่เติมภาษาปัจจุบันหรือเติมเต็มไม่ดี (แน่นอนว่านี้ใช้ไม่ได้กับทุกภาษา แต่ฉันรู้สึกว่ามันใช้กับภาษาส่วนใหญ่ที่รู้จักกันดี) ตัวอย่างเช่น python ได้รับการพัฒนาเพื่อเชื่อมต่อกับ Amoeba OS [ 1 , 2 ] และ Erlang ถูกสร้างขึ้นเพื่อช่วย ในการพัฒนาแอปพลิเคชั่นโทรศัพท์ [ 3 ] ดังนั้นหนึ่งคำตอบสำหรับคำถาม "ทำไมเราต้องมีภาษาการทำงานอื่น? อาจเป็นเพราะ [การแทรกชื่อของใครบางคนใครรู้วิธีการออกแบบภาษา] ไม่ชอบวิธีที่หลามทำมัน

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

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

ดู: การโปรแกรมเชิงฟังก์ชันไม่ได้เป็นเพียงแค่เกี่ยวกับ lambdas หรือmapหรือฟังก์ชันที่มีลำดับสูงกว่า มันเป็นเรื่องของการออกแบบ โปรแกรมที่เขียนด้วยภาษาโปรแกรมที่ใช้งานได้จริง "แก้ปัญหาผ่านองค์ประกอบของฟังก์ชั่น ในขณะที่โปรแกรมที่เขียนใน Ruby หรือ Python อาจใช้คุณสมบัติคล้าย FP แต่โดยทั่วไปแล้วโปรแกรมจะไม่อ่านเหมือนชุดฟังก์ชั่นที่ประกอบขึ้น

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

ทุกแนวคิดที่มีใน lambda-แคลคูลัส, LISP และ Scheme มีให้ใน Python ดังนั้นใช่คุณสามารถทำการเขียนโปรแกรมการทำงานได้ หากสะดวกหรือไม่เป็นเรื่องของบริบทและรสนิยม

คุณสามารถเขียนล่าม LISP (หรือภาษาที่ใช้งานได้อื่น ๆ ) ใน Python (Ruby, Scala) ได้อย่างง่ายดาย (จำนวนนั้นคืออะไร?) คุณสามารถเขียนล่ามให้กับ Python โดยใช้ฟังก์ชั่นล้วนๆ แต่จะต้องใช้เวลามาก แม้กระทั่งภาษา"ที่ใช้งานได้"ก็ยังมีกระบวนทัศน์หลากหลาย

หนังสือเก่าและสวยงามเล่มนี้มีคำตอบส่วนใหญ่ (แต่ไม่ใช่ทั้งหมด) เกี่ยวกับสาระสำคัญของการเขียนโปรแกรมการทำงาน

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

“ โปรแกรมเมอร์ที่ใช้งานได้ฟังดูเหมือนนักบวชยุคกลางซึ่งปฏิเสธความพึงพอใจของชีวิตด้วยความหวังว่ามันจะทำให้เขาบริสุทธิ์ สำหรับผู้ที่สนใจผลประโยชน์ทางวัตถุมากกว่า "ข้อดี" เหล่านี้ไม่น่าเชื่อมากนัก โปรแกรมเมอร์ฟังก์ชั่นยืนยันว่ามีประโยชน์ทางวัตถุที่ยอดเยี่ยม… [แต่] มันไร้สาระอย่างชัดเจน หากไม่ได้ระบุงานที่มอบหมายจะก่อให้เกิดประโยชน์มากมายเช่นนั้นโปรแกรมเมอร์ของ FORTRAN จะทำเช่นนี้มายี่สิบปีแล้ว มันเป็นไปไม่ได้ในเชิงตรรกะที่จะทำให้ภาษามีประสิทธิภาพมากขึ้นโดยการไม่ใช้ฟีเจอร์ไม่ว่าพวกเขาจะแย่แค่ไหนก็ตาม”

- John Hughes, ทำไมการเขียนโปรแกรมที่ใช้งานได้มีความสำคัญ