สำรวจการเขียนโปรแกรมเชิงฟังก์ชันด้วย Julia

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

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

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

Julia เป็นภาษาที่ดีในการเขียนโปรแกรมในลักษณะการทำงานหรือไม่? ฉันเชื่อว่ามันเป็น เหตุใด Julia จึงเก่งเรื่อง Functional Programming ด้วยเหตุผลหลายประการ รวมถึง metaprogramming, ออบเจกต์ชั้นหนึ่ง, ระบบประเภทที่ทรงพลัง, การแจกจ่ายหลายรายการ และเหตุผลอื่นๆ อีกมากมาย

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

มาดำดิ่งและเริ่มสร้างแนวคิดบางอย่างกัน

การเขียนโปรแกรมการทำงานในการดำเนินการ

สมมติว่าฉันสนใจที่จะค้นหาลูกบาศก์ของตัวเลขสองสามตัว ฉันเขียนได้:

3 * 3 * 3

2 * 2 * 2

cube(x) = *(x,x,x)

cube(x) = x * x * x

ตอนนี้ผมสนใจคำนวณอยู่สองสามชุด เราจะเริ่มต้นด้วยการออกแบบฟังก์ชันเพื่อคำนวณผลรวมของจำนวนเต็มตั้งแต่ a ถึง b:

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

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

ด้วยคำจำกัดความของฟังก์ชันข้างต้น เราสร้างประเภทของฟังก์ชันให้รวมอย่างชัดเจนในอาร์กิวเมนต์ ฉันได้ใส่คำอธิบายประกอบพารามิเตอร์ "f" เพื่อให้ชัดเจนว่านี่คือฟังก์ชัน ไม่ใช่ค่าอื่น

ตอนนี้ ถ้าฉันต้องการผลรวมของลูกบาศก์ตั้งแต่ 1 ถึง 10 ฉันสามารถเรียกได้ดังนี้:

หรือถ้าฉันต้องการผลรวมของจำนวนเต็มตั้งแต่ 1 ถึง 10 ฉันสามารถเขียน:

สำรวจฟังก์ชั่น Julia

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

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

ตัวอย่างด้านบนแสดงวิธีที่เทียบเท่ากันในการรวมและเขียนฟังก์ชันเข้าด้วยกัน

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

julia> average_damp(square)
#7 (generic function with 1 method)

ในการรับค่าความชื้นเฉลี่ยของฟังก์ชันกำลังสอง ที่ x=10เราเรียกใช้ด้วย:

julia> average_damp(square)(10)
55.0

julia> dx = 0.00001;

julia> deriv(cube)(5)
75.00014999664018

ต่อไปนี้เป็นตัวอย่างของฟังก์ชันดังกล่าว:

julia> withdraw(20)
80

julia> 

julia> withdraw(20)
60

julia> withdraw(20)
40

julia> withdraw(20)
20

julia> withdraw(20)
0.0

julia>

อย่างไรก็ตามในครั้งต่อไป…

เอกสารอ้างอิง: “โครงสร้างและการตีความโปรแกรมคอมพิวเตอร์”, Abelson และ Sussman