มารู้จักกับ Functional Programming สิ่งที่คุณต้องรู้ในตอนนี้กันเถอะ

อธิบายง่ายๆ สำหรับคนที่จำเรื่อง Computer Architecture ไม่ค่อยได้...การสั่งงานให้คอมพิวเตอร์ทำงานจำเป็นต้อง "เป๊ะๆๆๆ" แต่ส่วนใหญ่เวลาคนคุยกันในโลกจริงมันไม่เป๊ะไง ส่วนใหญ่คำมักจะกำกวม เราจึงต้องเริ่มจาก machine แล้วกระดิ๊บขึ้นไประดับที่สูงขึ้น ไม่ก็เริ่มจากคณิตศาสตร์ (คอมก็มาจากเลขละนะ แบบชื่อ Function นี่ก็เลขอยู่แล้วใช่มั้ยล่ะ) แล้วค่อยๆ ตัดสิ่งที่คอมไม่เข้าใจออกไปเรื่อยๆแต่คอมพิวเตอร์ในสมัยนั้นมันไม่มีความสามารถในการประมวลผลมากพอที่จะประมวลผล
abstractions เยอะๆ ซึ่งเจ้า functional เนี่ยมันต้องใช้เยอะเลยล่ะดังนั้นปัญหาของ
Lisp มันทำตัวไฮโซเกินกว่ายุคสมัย คอมสมัยนั้นรันตามมันไม่ค่อยทัน (ทันแหละ แต่ช้า~) ยิ่งต่อมายุคของ Imperative Programming (เขียนโปรแกรมแบบบอกเป็นขั้นตอนว่าจำทำอะไรบ้าง เช่นภาษา C) ได้มาถึงและจัดการเทคโอเวอร์โลกโปรแกรมมิ่งไปเรียบร้อย โดยเฉพาะภาษา C ที่ฮิตติดลมมาก

var add = function(a){
    return function(b){
        return a + b;
    }
}

var add2 = add(2);
var ans = add2(3);

4. Closures

ตอนที่อธิบายไปเมื่อกี้ละนะกรณีมีฟังก์ชันซ้อนๆ กันเยอะๆ ฟังก์ชั่นตัวในสามารถเรียกตัวแปรข้างนอกมันมาใช้ได้ทั้งหมดเลย แต่ด้านนอกใช้ของข้างในไม่ได้นะ

5. Immutable State

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

let x = 5;
x = 6;
 
print_int x;

จากการใช้งานคอมพิวเตอร์ให้คิดหรือประมวลผลให้เราบนคอมเครื่องเดียว ตอนนี้โลกเทคโนโลยีเดินทางมาถึงยุคที่ไม่ว่าจะทำอะไรก็ต้องผ่าน Internet แบบงานออนไลน์รายได้ดี (ไม่ใช่ //ผิดๆ)ทุกอย่างกำลังจะขึ้นไปล่องลอยอยู่บนก้อนเมฆด้วยระบบคอมแบบ Parallel Distribute System หรือ Cloud (หัวข้อ Cloud ยังไม่เคยเอามาเขียนลงบล๊อก แต่เรื่อง Parallel Computing เคยเขียนไปนิดหน่อย ถ้าอยากอ่านก็ไป ที่นี่ได้เลย!)ในคอนเซ็ปคือกระจายคอมถิวเตอร์ออกไป ให้พวกมันช่วยกันคิดๆ ไม่ว่าอยู่ที่ไหนก็ทำได้ แต่ด้วยคอนเซ็ปนี้แหละที่นำความยุ่งยากมาสู่ชีวิตโปรแกรมเมอร์อย่างเราๆ ท่านๆ

 

 

แล้วพอเป็น Cloud ทำไมถึงสร้างปัญหาให้กับ OOPเหตุผลคือ...

ไม่ต้องถึงระดับ OOP แต่แค่ Imperative Programming ต่างก็มีรู้แบบการทำงานที่ค่อนข้างละเอียด ต้องมีการเปลี่ยนสถานะที่เกี่ยวข้องกับ self ไม่ก็ this (คอนเซ็ป OOP เลยล่ะ คือมองโปรแกรมมิ่งให้เป็นของชิ้นๆ แบบในโลกจริงไงล่ะ)

แต่เพราะมันดีเกินไป คือโครงสร้างหนักมาแต่ไกล (แต่ถือว่าใช้งานได้ดีมากนะ)  มันเยอะเกินไปสำหรับกรณีที่ความต้องการคือ ขออะไรง่ายๆ ไม่ซับซ้อนและเชื่อถือได้เพราะ Distribute System และ Cloud มันมีคอมหลายเครื่องในระบบของมัน แต่ละเครื่องไม่น่าจะทำงานพร้อมๆ กันหรือแม้แต่เป็นเครื่องรุ่นเดียวกัน ถ้าเอา OOP ไปใช้มันจะเป็นอะไรที่คุมยากมากเลยใช่ไหม --- วิธีการของ Functional Programming ที่เน้นไปที่ฟังก์ชั่น ใส่ input เข้าไปแล้วก็จะได้ output ออกมา แค่นั้นแหละ! จบ! พอแล้ว...เวลาเอาไปใช้บนเครื่องในระบบที่แตกต่างกันเราก็มั่นใจได้ว่าถ้าสั่งแต่ละเครื่องทำงานไปสัก 1,000 ครั้งมันก็ยังจะให้ค่าคำตอบกลับมาเหมือนเดิมโดยไม่ต้องไปสั่งสร้าง object อะไรให้วุ่นวาย

แต่ก็ใช่ว่าภาษาพวก OOP จะตายแล้วนะ มันยังอยู่ แต่ส่วนใหญ่ก็เพิ่มคุณสมบัติของ Functional เข้าไปให้ใช้ด้วยแล้วในรูปของ Lambda Function ยังไงล่ะ เช่นพวก Java, C++11, Ruby, Python หรือแม้แต่ภาษาน้องใหม่แต่ไม่ด้อยความสามารถจากค่าย Apple อย่าง Swift 

งั้นฉันจะเริ่มยังไงดี?

ตอนแรกที่จำทำความเข้าใจ Functional Programming อาจจะตะกุกตะกักซะหน่อย มันก็เหมือนกับตอนที่เพิ่งเปลี่ยนจาก เขียนโปรแกรมธรรมดามาใช้ OOP นั่นแหละ

ตอนเริ่มแรกอยากจะให้คุณลืมคอนเซ็ปการเขียนโปรแกรมแบบเดิมๆ ไปก่อนแล้วจะเริ่มใหม่ได้ง่ายกว่า หลายๆ อย่างใน Functional
Programming อาจจะไม่ค่อยเป็นภาษาคน อ่านค่อนข้างยาก เห็นแล้วเดาไม่ออกว่าบรรทัดนี้เอาไว้ทำอะไร

ยิ่งถ้าคุณเริ่มเขียนโปรแกรมด้วยภาษาแนว Imperative เช่น C มาด้วยนะ Functional อาจจะกลายเป็นตัวประหลาดไปเลย

แต่เกริ่นมานี่่อย่าเพิ่งไปกลัวมัน คุณแค่ยังไม่ชินกับแนวทางการเขียนของมันเท่านั้น

เอาล่ะ มาดูตัวอย่างกันเถอะ

guess :: Int -> [Char]

guess 7 = "This is a Se7en"

guess x = "Oops, no~"

อ่านไม่รู้เรื่องละสิ ไม่เป็นไร เราก็อ่านไม่รู้เรื่องเหมือนกัน (ฮา) อันนี้เป็นภาษา Haskell งั้นเราลองมาดูโค้ดนี้ในภาษา JavaScript ที่เราน่าจะพอคุ้นๆ กันบ้างดีกว่า

function guess(x){
    if(x == 7){
        return "This is a Se7en";
    }
    else{
        return "Oops, no~";
    }
}

หวังว่าคงรู้เรื่องกันนะว่าตกลงมันแปลว่าอะไร (55)

เอ้า อธิบายซะหน่อย ... ตอนแรกบอกว่า guess เป็นฟังก์ชันที่จะรับ Int เข้ามาแล้วตอบกลับเป็น String ( [Char] หรือ Array of Char ไงละ)

จากนั้นบอกต่ออีกว่าถ้า Int ที่ว่าเป็น 7 ให้ตอบ "This is a Se7en" นะ แต่นอกจากกรณีนั้นให้ตอบว่า "Oops, no~"

ไม่ชินละสิ มาดูอีกตัวอย่างๆ

plus1 :: [Int] -> [Int]

plus1 [] = []

plus1 (x:xs) = x + 1 : plus1 xs

ตัวอย่างนี้เราจะสร้าง plus1 ซึ่งเป็นฟังก์ชั่นที่เอาไว้ "บวก1" ให้เลขทุกตัวใน Array เช่นถ้ารับ [1, 10, 54] ไปก็จะตอบกลับเป็น [2, 11, 55] มาให้

เริ่มจากการบอกว่าฟังก์ชันนี้รับ Array of Int มาแล้วจะตอบ Array of Int กลับไปให้นะๆ

จากนั้นบอกว่าถ้า Array ที่รับมามันว่าง ไม่มีเลขไรเลยอ่ะ ก็ตอบ Array ว่างแบบนั้นกลับเลย (ไม่มีประโยชน์ที่จะทำไง)

หลังจากนั้น (งงนิดหน่อยนะ) คือเราจะเรียกเลขตัวแรกว่า x ส่วนที่เหลือจะเรียกว่า xs ... ให้เอา x ไปบวก 1 จากนั้นตัวที่เหลือที่เป็น xs น่ะ ให้เอาไปทำงานแบบ plus1 ต่อ (คอนเซ็ปคล้ายๆ เวลาเราเขียน Recursive Function ใน C)

แต่ถ้ายังงงอยู่เรามีของแถมที่บทความต้นฉบับไม่มีให้

function plus1(arr){
    if(arr.length == 0){
        return [];
    }
   
    for(var i = 0; i < arr.length; i++){
        arr[i]++;
    }
    
    return arr;
}

var arr = [1, 10, 54]; 
 
arr.map(function(x){
    return x + 1;
});

So, let's get started

สำหรับ Functional Programming คุณไม่ควรพลาดแหล่งข้อมูลดีๆ ตามนี้เลย

1. Principles of Functional Programming in Scala
2. Introduction of Functional Programming (Contents)
3. Paradigms of Computer Programming --- Fundamentals

หรือสำหรับคนช่วยสัมผัสกระดาษจริง (หมายถึงหนังสือพวก Textbook น่ะนะ) ก็ไปหาเล่มพวกนี้

1. Structure and Interpretation of Computer Programs
2. How to Design Programs
3. Concepts, Techniques and Models of Computer Programming