OOP object oriented programming in Haskell

OOP ใน Haskell

ใน Haskell เราทำงานกับโครงสร้างข้อมูล (Data Structure) ด้วยการสร้าง **Type** และ **Typeclass** ซึ่งสามารถทำให้เราสามารถสร้างลักษณะของ OOP ได้ เช่น การสร้าง **Encapsulation**, **Polymorphism**, และ **Inheritance** ในการเขียนโปรแกรม

Encapsulation

ใน OOP เราสามารถกำหนดข้อมูลและฟังก์ชันที่ทำงานกับข้อมูลนั้นรวมกันเป็นหน่วยเดียว ใน Haskell เราทำสิ่งนี้ได้โดยการสร้าง Type:

 data Circle = Circle { radius :: Double }

area :: Circle -> Double
area (Circle r) = pi * r * r

ในตัวอย่างนี้ เราสร้าง `Circle` เป็น Type ที่มี `radius` เป็นข้อมูลและ `area` เป็นฟังก์ชันที่คำนวณพื้นที่ของวงกลม

Polymorphism

Polymorphism หมายถึงความสามารถของฟังก์ชันที่สามารถทำงานกับข้อมูลหลายประเภทได้ ใน Haskell เราใช้ Typeclass เพื่อให้เราสามารถกำหนดฟังก์ชันเดียวกันสำหรับข้อมูลที่แตกต่างกัน:

 class Shape a where
    area :: a -> Double

instance Shape Circle where
    area (Circle r) = pi * r * r

instance Shape Rectangle where
    area (Rectangle w h) = w * h

data Rectangle = Rectangle { width :: Double, height :: Double }

ในตัวอย่างนี้ เรามี Typeclass ชื่อ `Shape` ที่มีฟังก์ชัน `area` ซึ่งสามารถใช้งานกับ `Circle` และ `Rectangle` ได้

Inheritance

การสืบทอด (Inheritance) ใน Haskell ไม่ได้ถูกออกแบบมาในลักษณะเดียวกับ OOP ที่เราเห็นในภาษาอื่น ๆ อย่างไรก็ตาม เราสามารถสร้างโครงสร้างเลียนแบบได้โดยการใช้ Typeclass:

 class Shape a where
    area :: a -> Double

class Shape a => ColoredShape a where
    color :: a -> String

instance ColoredShape Circle where
    color _ = "Blue"

instance ColoredShape Rectangle where
    color _ = "Red"

ในตัวอย่างนี้ `ColoredShape` จะสืบทอดจาก `Shape` ซึ่งทำให้เราสามารถเพิ่มฟังก์ชัน `color` ที่สามารถทำงานร่วมกับ Type ต่าง ๆ ได้

Use Case ในโลกจริง

การสร้างโปรแกรมในลักษณะ OOP มีประโยชน์มากในหลายๆ สถานการณ์ เช่น เมื่อต้องการสร้างเกม, การจัดการทรัพยากร, หรือแม้กระทั่งแอปพลิเคชันทางธุรกิจ ในตัวอย่างนี้ เราจะดูการใช้งานในโครงการพัฒนาแอปพลิเคชันในการจัดการรายจ่าย:

ตัวอย่าง Use Case: การจัดการรายจ่าย

เราสามารถสร้าง Type สำหรับรายการรายจ่ายต่าง ๆ ได้:

 data Expense = Expense { description :: String, amount :: Double }

totalExpense :: [Expense] -> Double
totalExpense expenses = sum (map amount expenses)

ฟังก์ชัน `totalExpense` จะใช้เพื่อคำนวณยอดรวมของรายจ่ายที่เราได้บันทึกไว้อย่างง่ายดาย

ตัวอย่างโค้ด

มาดูโค้ดรวมที่สร้างแอปพลิเคชันการจัดการรายจ่ายอย่างง่าย ๆ:

 data Expense = Expense { description :: String, amount :: Double }

addExpense :: [Expense] -> Expense -> [Expense]
addExpense expenses newExp = newExp : expenses

totalExpense :: [Expense] -> Double
totalExpense expenses = sum (map amount expenses)

main :: IO ()
main = do
    let expenses = []
    let expenses' = addExpense expenses (Expense "Coffee" 50)
    let expenses'' = addExpense expenses' (Expense "Lunch" 200)
    putStrLn ("Total Expense: " ++ show (totalExpense expenses''))

ในตัวอย่างข้างต้น เราสร้าง Type `Expense` เพื่อเก็บข้อมูลเกี่ยวกับรายจ่าย ต่อมาเราก็สร้างฟังก์ชัน `addExpense` เพื่อเพิ่มรายจ่ายเข้าไปในรายการ จากนั้นใช้ฟังก์ชัน `totalExpense` เพื่อคำนวณยอดรวมของรายจ่าย

สรุป

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

โปรแกรมมิ่งคือทักษะที่มีค่าในตลาดงานสมัยใหม่ แล้วคุณจะรออะไร? มาสร้างอนาคตด้วยการเขียนโปรแกรมที่ EPT กันเถอะ!

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