Lambda 演算（针对程序员！） - พื้นฐานสู่ 函数式编程

Lambda 演算语法：หลักไวยากรณ์

函数式编程อยู่ แล้วมีส่วนพูดถึงแนวคิดทาง วิชาคณิตศาสตร์ที่เรียกว่า拉姆达演算ซึ่งเขียนไปเขียนมาก็ดูเหมือนมันจะยาวเกินไปจ ขอแยกออกมาเป็นอีกบทความหนึ่งเลยน่าจะดีกว่า

Lambda 演算 (ที่ไม่ใช่แคลคูลัส)

เชื่อว่าในครั้งแรกที่เราได้ยินชื่อคำว่า“แลมด้าแคลคูลัส”สิ่งแรกที่เราคิดน่าจะเป็น วิชาคณิตศาสตร์ที่เรียกว่าแคลคูลัส微分方程... เอาเป็นว่ามันคือคนละวิชากันละกัน เคยรู้อะไรเกี่ยวกับแคลคูลัสมาลืมๆ มันไปก่อน

Lambda 演算ี้เกิดขึ้นมาตั้งแต่เมื่อไหร่ แล้วเกิดขึ้นมาเพื่ออะไร เราต้องย้อนกลับไปในช่วงที่เครื่ องจักรสำหรับการคำนวณที่เรียกว่าคอมพิวเตอร์ 1945年~

คอมพิวเตอร์ถูกสร้างขึ้นโดยนั กวิทยาศาสตร์และนักคณิตศาสตร์ （โดยน่าจะเป็นนักคณิตศาสตร์เป็นหลัก） ซึ่งนักคณิตศาสตร์พวกนั้นก็กำลังสงสัยกัว่นก็กำลังสงสัยกัว่น“การคำนวณ”นั้นที่แท้จริงมันคืออะไร ทำไมมันถึงคำนวณได้ อะไรบ้างที่เอามาคำนวณได้ หรืออะไรบ้างที่คำนวณไม่ได้ ... ฟังดูอาจจะแปลกๆซะหน่อย抽象背景แบบนี้ การคำนวณก็คือการคิดเลข อะไรบางอย่างไม่ใช่เหรอ？

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

ดังนั้นเราเลยต้องเข้าใจให้ได้ซะก่อน是不是？ เราจะได้เอาแนวคิดนั้นมาส ร้างเครื่องคอมพิวเตอร์ได้

สุดท้ายแล้วก็มีตัวเลือกหนึ่งที่ ซึ่งเป็นแนวคิดที่ต่อมานำมาใ ช้สร้างคอมพิวเตอร์นั่นก็คือ图灵机หรือเครื่องจักรของทัวริง艾伦·图灵 (Alan Turing)

ต้องอธิบายเพิ่มนิดนึงว่าถึงแม้เราจะเรียกว่า图灵机图灵机เป็นแค่เครื่องจักรเสมือน เป็นหลักการคิดในอุดมคติเท่านั้น เวลาใช้ก็เขียนๆทดๆกันลงในกระดาษนี่แหละ

แต่ก็ดูเหมือนมีคนเอาเครื่องจักรใน ความคิดนี้มาสร้างเป็นเครื่องจริงๆ谷歌搜索引擎

存储过程คือมีเมมโมรี่เป็นหน่วย ความจำเอาไว้เก็บตัวแปร แล้วก็มีส่วนประมวลผลที่จะทำคำสั่งแล ้วเปลี่ยนแปลงค่าตัวแปรนั้นไปเรื่อยๆ จนกว่าจะได้คำตอบออกมา

是吗？

ถ้าคุณเรียนสายคอมพิวเตอร์มา คุณน่าจะคุ้นแนวคิดนี้ไม่มากก็น้อย（ละมั้ง？）约翰·冯·诺依曼ำมาสร้างเป็นเครื่องจั กรสำหรับคำนวณที่ต่อมาก ลายเป็นต้นแบบของคอมพิว เตอร์ที่ใช้งานได้จริงๆ เครื่องแรกของโลก แล้วก็เป็นโมเดลที่เราใช้กับค อมพิวเตอร์มาจนถึงปัจจุบันด้วย

ใช่แล้ว！ CPU 和内存（RAM）

图灵机ลองหาข้อมูลเพิ่มเติมอ่านดูได้นะ แต่ในบทความนี้จะพูดแค่นี้ก่อน ถ้ามีโอกาสจะกลับมาเขีย เกี่ยวกับมันเพิ่มอีกที

图灵机แล้วก็ยังมีแนคิดหนึ่งซึ่งพัฒนาโด ยนักคณิตศาสตร์ชาวอเมริกันชื่อว่า阿朗佐教堂（เข้าคนนี้เป็นอาจารย์ที ่ปรึกษาระดับปริญญาเอกของ阿兰·图灵 (Alan Turing) 学习 Lambda 微积分！ （กว่าจะเข้าเรื่องฮา）

เนื่องจากแนวคิดนี้มันเป็นหลักการของการคำนวณ 《微积分》 รายละเอียดลึกๆ เหมือนจะพิสูจน์ย้อนกลับไปถึง พื้นฐานของวิชาเลขที่เราเรียนๆ กันตอนประถมได้เลย计算机科学กันเท่านั้นพอ

Lambda 演算ได้อย่างดีนั่นคือ

Everything that can be Computed, can be computed by Lambda Calculus.

อะไรก็ตามที่สามารถคำนวณได้, มันจะถูกคำนวณได้ด้วยแลมด้าแคลคูลัส ... เท่จริงๆ
(แปลว่าถ้าแลมด้าแคลคูลัสประมวลผลไม่ได้ คอมพิวเตอร์ก็ประมวลผลข้อมูลแบบนั้นไม่ได้เช่นกัน)

图灵机图灵机ข้อแตกต่างคือในขณะที่ทัวริงใช้หลักการของ基于状态的计算， อาจารย์ของเขากลับแก้ปัญ หาเดียวกันด้วยหลักการของ函数符号计算 -- เมื่อเป็นแบบนี้图灵机Lambda 演算ั้นสามารถแปลงไปเป็นอีกตัวนึงได้ในทุกกรณี

符号处理器

เวลาเราเขียนโปรแกรม สิ่งที่เราทำคือเขียนโค้ดลงไป ซึ่งโค้ดพวกนั้นก็อยู่ในรูปของตัวอักษาบ้าง ตัวเลขบ้าง机器码 机器码แต่ถ้ามองพวกนี้รวมๆ和服จะมองเป็น“สัญลักษณ์”หรือ符号ก็ได้

ดังนั้นเราเลยสามารถสรุปได้อีกแบบหนึ่งว่า คอมพิวเตอร์นั้นก็คือ ตัวประมวลผลสัญลักษณ์符号处理器（Symbol Processor）

แต่สิ่งที่น่าสนใจคือ ... การเอาสัญลักษณ์พวกนี้ม เรียงกันแล้วมันประมวลผ ล/คำนวณ/หรือทำงานเพื่อใ ห้ได้คำตอบมาได้อย่างไร？

Lambda 演算语法：หลักไวยากรณ์

3 月 3 日

1. 抽象化 -λx.M
2. 应用 -(M1 M2)
3. 价值 -V

โดยที่ตัวแทนMมาจาก“Lambda Term”หรือก็คือพวก表达式-สมการ ั่นเอง
ส่วนสัญลักษณ์λคือตัวแลมด้าเล็ก เป็นอักษรกรีก ซึ่งถ้าเป็นแลมด้าตัวใหญ่จะใช้สัญลักษณ์Λ

第 3 章ตามทฤษฎีบอกว่าสามารถเขียน ได้ทุกโปรแกรมในโลกนี้แล้ว！

มาดูตัวแรกกันก่อน

抽象的：λx.M

เทียบได้กับการประกาศฟังก์ชันขึ้นมา（函数声明）黑匣子输入法：输入法输出 ออกมา แล้วให้ 输出เขียนแทนด้วยสัญลักษณ์แบบนี้

f(x) = x * 10

อันนี้หมายความว่าเราสร้างฟังก์ชันชื่อfขึ้นมา ซึ่งรับ 输入xเข้าไป แล้วเอาไปคำนวณด้วยการ* 10

ถ้าเราจะเอาฟังก์ชันมาใช้งาน เราก็เรียกใช้ได้แบบนี้

f(5) //ซึ่งจะได้ผลออกมาคือ 5 * 10 เท่ากับ --> 50

ลองมาดูตัวอย่างในชีวิตจริงกันบ้างเช่น

มีฟังก์ชันสำหรับคำนวณค่าจอดรถ
อาจจะรับ Input เป็นตำนวนชั่วโมงที่จอดรถไป
แล้วคืน Output ออกมาเป็นราคาที่ต้องจ่าย

** ส่วนจะคำนวณค่ายังไง ถือว่าไม่ต้องสนใจ (ในมุมมองคนที่เรียกใช้งาน ไม่ต้องสนใจ / แต่คนที่สร้างฟังก์ชันก็ต้องสนอยู่ดีนะ)

โดนจากตัวอย่างข้างบน 10 月 10 日ถ้าเราเอาไปเขียนในรูปของฟังก์ชัน เราจะเขียนได้ว่า

parking_fee(hour) = hour * 10

⹃น Lambda 微积分， หลักการสร้างฟังก์ชันก็ เหมือนเดิมแบบนี้นี่แหละ แต่เปลี่ยนสัญลักษณ์แทนเป็นแบบนี้

λx . x * 10

输入法λ输入（หรือเรียกว่า参数）เข้ามาจำนวนหนึ่ง （ในตัวอย่างตั้งชื่อว่าx）ตามด้วยตัว.身体ของฟังก์ชันของเรา

เพิ่มเติมนิดนึง คือตามนิยามของฟังก์ชันที่เราเคยเรียน มันกำหนดว่า输入สามารถมีได้หลายตัว(แต่输出จะต้องมีแค่1ตัวเท่านั้น) เราสามารถประกาศฟังก์ชันได้แบบนี้

// รับ x และ y เข้ามา แล้วคำนวณหาผลบวกของ x กับ y
λx . λy . x + y

// รับค่า u, t, a เข้ามาแล้วคำนวณหาค่า S (อันนี้เป็นสูตรการเคลื่อนที่แนวเส้นตรง ข้ามๆ ไปก็ได้)
λu . λt . λa . ut + (1/2)at^2

计算：Lambda Calculus参数/主体 อย่างชัดเจน คือใช้.เป็นตัวเชื่อม ส่วนอันไหนเป็นส่วนของ输入参数ก็จะมีสัญลักษณ์λนำหน้า เพราะจริงๆ แล้วนิยามของฟังก์ชันในเรื่องนี ้ต่างกับฟังก์ชันที่เรารู้จักกัน นั่นคือฟังก์ชันมี输入ได้แค่参数เดียว！参数 มากกว่า 1 ตัว 《咖喱》函数式编程

应用：(M1 M2)

หลังจากสร้างฟังก์ชันขึ้นมาแล้ว เราก็ต้องมีการเรียกใช้งานฟังก์ชัน（呼叫功能）申请表หรืออาจจะแปลว่ามันคือการ "应用表达式M1ด้วย 表达式M2 " ก็ได้

5 月 5 日ชั่วโมงเมื่อกี้มาใช้กับฟัง ก์ชันที่เราประกาศไปเมื่อกี้ ก็จะเขียนได้ว่า

(λx.x*10 5)

หากมองเป็นภาษาโปรแกรมที่เราคุ้นชินกัน มันก็คือการสร้าง“匿名函数” （หรือที่บางภาษาก็เรียกตรงๆเลยว่า“Lambda”）输入法输入法เข้าไปด้วยแบบนี้

//declare function f
function f(x){ 
    return x * 10; 
}
//call f
f(5);

//หรือสร้างฟังก์ชันแล้วสั่งให้มันทำงานทันทีเลย แบบนี้
(function(x){ 
    return x * 10; 
})(5);

ดังนั้นการเรียกใช้

(λx.x*10 5)

ก็จะมีความหมายว่าเอา5เข้าไปแทนที่xซะ จะได้ว่ามันก็คือ

(5*10)

หรือสมมุติว่าเราส่งค่าอื่นเข้าไปเช่น

(λx.x*10 a^b+100)
// ก็จะได้เป็น 
( (a^b+100) * 10)

เอาล่ะจบกันไปแล้ว，เดี๋ยว！？ อะไรนะ แค่นี้เหรอ ... ใช่แล้ว คอนเซ็ปคร่าวๆ ของ Lambda微积分 微积分คนน่าจะงงกันเลยว่าไม่เห็นมีอะไรเลย ตกลงมันดีจริงเหรอหรือเอาไปใช้งานยังไง ต่อไปเราจะมาดูตัวอย่างกันใช้งานกันนะ

例 1：对、错与否

ตัวอย่างแรกจะเป็นการสร้างTRUEและFALSEขึ้นมา操作NOT说明

เริ่มด้วยการ声明 ว​​่าอะไรคือ TRUE, FALSE โดยขอกำหนดว่า

TRUE  = λx . λy . x
FALSE = λx . λy . y

หรือจะมองง่ายๆแบบนี้ก็ได้ （เปลี่ยนชื่อตัวแปรซะหน่อย）

TRUE  = λfirst . λsecond . first
FALSE = λfirst . λsecond . second

答案: 正确的是 TRUE 2 ค่า --> แล้วตอบค่าตัวแรกกลับไป
ส่วนฟังก์ชัน FALSE คือการที่เรารับค่าเข้าไป2 ค่าเหมือนกันเลย --> แต่จะตอบค่าตัวที่สองกลับไป

正确、错误是吗？ ทนอ่านต่ออีกนิดนึงนะ

ต่อมาเราจะสร้างฟังก์ชัน不是สำหรับกลับค่าtrue-> falseและfalse-> trueซึ่งกำหนดแบบนี้

NOT  = λx . x FALSE TRUE

และเมื่อเดิม ขอเปลี่ยนชื่อเพื่อให้เ ข้าใจง่ายขึ้นอีกนิดนึง เป็น

NOT  = λbool . bool FALSE TRUE

อธิบาย: ฟังก์ชัน NOT นั้นจะรับ boolean เข้าไป (อาจจะเป็นtrueหรือfalseก็ได้) แล้วเอาฟังก์ชันนั้น (อย่าลืมว่า)true/false价值แต่เป็น功能）ไป应用หรือก็คือเอาไปรันกับค่าFALSE TRUEที่วางเตรียมไว้
อาจจะยังไม่เห็นภาพ มายกตัวอย่างกัน

案例一： NOT TRUE

NOT TRUE

-- แทนที่ NOT ด้วย Abstraction ที่เขียนไว้ข้างบน
(λbool . bool FALSE TRUE) TRUE

-- เอาค่า TRUE ใส่แทนพารามิเตอร์ bool ลงไป
-- จาก bool FALSE TRUE ก็จะได้เป็น
TRUE FALSE TRUE

-- เวลาอ่าน ให้อ่านจาก ซ้าย->ขวา
-- เราจะเจอ TRUE ก่อน, ก็ให้ไปดูว่าฟังก์ชัน TRUE มี Abstraction เป็นอะไร -> เอามาแทนที่ซะ
(λfirst . λsecond . first) FALSE TRUE

-- ฟังก์ชันนี้รับค่าเป็นพารามิเตอร์ 2 ตัว (คือ first, second) ก็ให้เอาค่า FALSE TRUE ใส่แทนที่ลงไป
-- ซึ่งฟังก์ชันของเราบอกว่ารับค่า first, second เข้าไป 2 ตัว
(λFALSE . λTRUE . FALSE)

-- แต่ให้ return first กลับไปตัวเดียว เลยได้ว่า
FALSE 

ก็เลยสรุปได้ว่าNOT TRUEนั้นได้คำตอบเป็FALSEนั่นเอง

** สำหรับคนที่เป็นโปรแกรมเมอร์สาย命令式มา ถ้าอ่านอันนี้แล้วงง强制命令ให้ดู

// สร้างตัวแปร TRUE, FALSE ให้เป็นฟังก์ชันที่รับ first, second ไปแล้วตอบกลับเป็น first, second ตามลำดับ
const TRUE  = (first, second) => first
const FALSE = (first, second) => second

// จากนั้นสร้างฟังก์ชัน NOT ที่รับ bool ไป, แล้วเอาไปรันโดยส่งพารามิเตอร์เป็น FALSE, TRUE ลงไป
function NOT(bool){
    return bool(FALSE, TRUE)
}

// ดังนั้น ถ้าเราต้องการหาค่า NOT TRUE เราก็ต้องสั่งว่า
NOT(TRUE)

// ซึ่ง TRUE จะถูกเอาไปแทนที่ตัวแปร bool 
return bool(FALSE, TRUE)
// เลยจะกลายเป็น
return TRUE(FALSE, TRUE)

// ซึ่ง TRUE นั้นจริงๆ เป็นฟังก์ชันที่ return ค่าตัวแรกกลับไปเสมอ
// พารามิเตอร์ตัวแรกที่เราใส่ลงไปือค่า FALSE
// ดังนั้นสุดท้ายเราก็จะตอบกลับเป็นค่า FALSE
return FALSE

ซึ่งถ้าเราลองเอาNOT FALSEมาลองคิดด้วยหลักการเดียวกัน เราก็จะพบว่ามันออกมาเป็นTRUEซึ่งถูกต้องแล้ว

例2：AND และ OR

2 月 2 日 ... คราวนี้เราลองมาคิดกับฟั งก์ชันที่ซับซ้อนขึ้นกว่าNOTั่นคือANDกับORกันบ้าง ทั้งและนั้นรับ boolean เข้าไป 2 ตัวแล้วให้ค่า boolean กลับมา

ANDOR

• โดยANDนั้นจะ返回trueถ้า输入ทั้งสองค่าเป็นtrue，นอกนั้นจะตอบfalse
• ส่วนORจะ返回trueถ้า输入แม้แต่ตัวเดียวเป็นtrue,ซึ่งถ้าเป็นfalseทั้งคู่ถึงจะตอบfalse

Lambda Calculus Lambda Calculus เราจะทำยังไง？

和

คำตอบที่ได้คือแบบนี้

AND = λx . λy . x y FALSE

答案: 答案:x答案y2 เคสแบบนี้

1. x มีค่าเป็นtrue--> ก็ยังตอบไม่ได้ ต้องไปดูว่าค่า y เป็นtrueหรือfalse(แปลว่าถ้า x เป็นtrueคำตอบจะขึ้นอยู่กับตัวแปรy)
2. แต่ถ้า x เป็นfalse--> ก็จบเลยไง！ ไม่ต้องคิดตอบแล้ว

-- เริ่มด้วยการหาค่า x AND y
AND x y

-- ลองแทน x ด้วย TRUE (y ช่างมันก่อน ทิ้งมันเป็นตัวแปรไว้ตรงนั้นแหละ)
AND TRUE y

-- เอาฟังก์ชัน AND ที่ประกาศไว้ข้างบนมาแทนลงไป
(λx . λy . x y FALSE) TRUE y

-- แทนส่วนของ x ด้วย TRUE (y ก็คามันไว้เหมือนเดิมนะ)
TRUE y FALSE

-- ฟังก์ชัน TRUE บอกว่าให้ return first ดันนั้นให้ return y
y

... ทีนี้ลองมาวิเคราะห์ตัว和ดูบ้างก็จะได้แบบนี้

-- ถ้า y เป็น TRUE
AND TRUE TRUE
-- ก็จะจบด้วยค่า TRUE (ค่าตัวที่สองหรือ second นั่นเอง)
TRUE

-- ถ้า y เป็น FALSE
AND TRUE FALSE
-- ก็จะจบด้วยค่า FALSE (ก็เป็นค่าตัวที่สองเหมือนเดิมนั่นแหละ แค่ครั้งนี้ค่ามันเป็น FALSE)
FALSE

是吗？

มาลองดูเคสที่ x เป็นfalseกันบ้าง

-- ครั้งนี้, ลองแทน x ด้วย FALSE (y ช่างมันก่อนเหมือนเดิมนะ)
AND FALSE y

-- เอาฟังก์ชัน AND ที่ประกาศไว้ข้างบนมาแทนลงไป
(λx . λy . x y FALSE) FALSE y

-- แทนส่วนของ x ด้วย FALSE
FALSE y FALSE

-- ฟังก์ชัน FALSE บอกว่าให้ return second ดันนั้นให้ return FALSE (กลายเป็น y ไม่สนใจเลยนะ! ข้ามไปเลย)
FALSE

ดังนั้นแปลว่าถ้า x เป็นfalseก็คือไม่ต้องดู y แล้ว ยังไงคำตอบก็ได้FALSE...โอ้วถูกต้องตามหลักการของ和ในการเขียนโปรแกรมเลย！

或者

ยังไหวกันอยู่มั้ย (ฮา) มาต่อกันอีกตัวด้วย 或者， ถ้าใครเริ่มเก็ต 不是 กับ AND แล้วจะลองคิด 或者เองก็ได้นะ ว่าจะสร้างฟังก์ชัน还是ยังไงดี？

เอาล่ะมาดูคำตอบกัน

OR = λx . λy . x TRUE y

或《2》

1. x มีค่าเป็นtrue--> อันนี้จะสลับกับ AND เพราะสามารถตอบได้เลยว่าtrue
2. แต่ถ้า x เป็นfalse--> คราวนี้ต้องไปดูค่า y แทนแล้วว่า y布尔值和布尔值

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

ทิ้งท้าย

Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus Lambda Calculus ด้วยการกำหนดสัญลักษณ์ แล้วมีการยุบ/ขยายรวมเทอมต่างๆ ตามกฎที่ตั้งเอาไว้จนได้คำตอบออกมา ในหมดเป็นหลักการทำในกระดาษนี่แหละ แต่ก็แสดงหลักการว่าเราคำนวณค่าต่างๆ ได้อย่างไรออกมาได้ดีมาก

函数式编程

มีคนบอกว่าภาษาโปรแกรมทุกภาษา Lambda 演算ออกมา (คือเอาพวก语法if-elseหรือพวกforอะไรพวกนั้นออกไปน่ะนะ) Lambda 演算图灵机จะบอกแบบนั้นมันก็ถูกแหละ (ฮา)

แต่แนวคิดก็จะไม่เหมือนกัน图灵机 国家基地การเรียนรู้ก็จะเข้าใจได้ง่ายตรงไปตรงมา算法ที่ส่วนใหญ่ก็จะเป็นการเซ็ตค่าไปๆมาๆ บนหน่วยความจำ （算法） จะพูดถึงแต่การกำหนดและเ ซ็ตค่าตัวแปรเป็นหลักเลย)

แต่เนื่องจากคอมพิวเตอร์ไ ม่มีเซ้นซ์ความคิดอะไรเลย算法 算法 算法หรืออาจจะลืมกำหนดอะไรบางเคส แน่นอนว่าโปรแกรมก็จะทำงานผิดไปเลย （ที่เราเรียกว่า“บั๊ก”ยังไงล่ะ！） ตัวอย่างคลาสสิกๆที่ทุกคนน่าจะเคยเจอ循环播放 循环播放 循环播放更新i++更新， หรือถ้าทำงานกับ int ก็อาจจะลืมกรณีที่ int สามารถติดลบได้บลาๆๆ

函数式编程แล้วโอกาสที่เราจะลืมอะไรพวกนั้นจะน้อยลงมากๆ （《函数式编程》《函数式编程》无错误！ เลยนะ ... ซึ่งเราคิดว่าไม่ยังไม่ถึงขนาดนั้น มันแค่จะทำให้โปรแกรมบั๊กน้อยลงมากๆๆ แต่ยังไม่ถึงกับไม่มีบั๊กเลยนะ) เพราะในการเขียนเราจะได้โฟก ัสไปยังหลักวิธีแก้ปัญหาแท้ๆ โดยไม่ต้องไปกังวลกับการจัดการ เมมโมรี่หรือเรื่องยิบย่อยอื่นๆ เลย

Lambda 演算ั้นยังมีเนื้อหาให้ศึกษาต่ออีกมากมาย เช่นถ้าเราจะเขียน 循环（สปอยล์：函数式编程ไม่มี循环ล่ะ！！）ถ้าใครสนใจก็ลองศึกษาต่อเอานะ ... แต่ในบล็อกนี้ก็คงจบหัวข้อนี้แค่นี้แหละ函数式编程 函数式编程 函数式编程（คนเขียนเป็นเด็กcomไม่ใช่เด็กmathนะฮา）