Transcript PRESENTATION NAME

Functional Programming
Tasanawan Soonklang
Programming paradigms
•
•
•
•
Imperative
Object-oriented
Functional
Logic
Procedural programming
Non-procedural programming
or Declarative programming
Procedural programming
• วิธีการสัง่ งานได้ รับอิทธิพลโดยตรงจากสถาปั ตยกรรมของ
คอมพิวเตอร์
• Von Neumann machine ประกอบดว้ ย
– หน่วยประมวลผลกลาง ควบคุมและประมวลผลคาสัง่
– หน่วยความจา เก็บชุดคาสัง่ ของโปรแกรมและข้ อมูลที่จะใช้
• ใช้ แนวคิดในการเปลี่ยนสถานะ (ค่าในหน่วยความจา) ของเครื่ องไป
ตามลาดับ จนได้ ผลลัพธ์ที่ต้องการ
• มักใช้ คาสัง่ กาหนดค่า (assignment statement) เป็ นหลัก
ในการควบคุมการทางาน
• มีคาสัง่ ประเภทอื่นๆ ประกอบในการกาหนดลาดับการทางาน เช่น
คาสัง่ วนซ ้า คาสัง่ แบบมีเงื่อนไข
Program Modulo
1) Read M1
2)
3)
4)
5)
6)
7)
Read M2
M1 = M1 - M2
If M1 >= 0 then goto (3)
M1 = M1 + M2
Write M1
halt
Non-procedural programming
• ออกแบบเพื่อลดอิทธิพลของลักษณะการทางานของเครื่ อง
• การเขียนโปรแกรมเป็ นอิสระจากฮาร์ ดแวร์
• ภาษาเชิงหน้ าที่
– ใช้ ฟังก์ชนั่ ที่คล้ ายกับฟั งก์ชนั่ ทางคณิตศาสตร์
– ระบุการเชื่อมโยงค่าจากข้ อมูลเข้ าไปยังผลลัพท์
– ไม่ต้องระบุขนตอนการเปลี
ั้
่ยนแปลงสถานะภายในเครื่ อง
• ภาษาเชิงตรรกะ
– ใช้ ความสัมพันธ์เป็ นส่วนประกอบหลักในการเขียนโปรแกรม
– เป็ นการพิสจู น์ความจริ งของความสัมพันธ์ทงหลายที
ั้
่ระบุไว้
– ไม่ต้องระบุลาดับการทางานให้ กบั โปรแกรม
FunctionalTitle
Programming
ส่•วนประกอบที
่สาคัญ dolor sit amet, consectetuer
Lorem ipsum
adipiscing
• โครงสร้
างข้ อมูลพืelit.
้นฐาน Vivamus
คือ ลิสต์ (list)et magna. Fusce sed
• sem
ฟั งก์ชนั่ พืsed
้นฐานmagna suscipit egestas.
• Lorem
โครงสร้ างทีipsum
่ใช้ สร้ างฟั งก์dolor
ชนั่ จากฟัsit
งก์ชamet,
นั่ ที่มีอยู่ consectetuer
adipiscing elit. Vivamus et magna. Fusce sed
โปรแกรมประกอบด้
วยฟั งก์ชนั่ suscipit
นิยามจากนิพegestas.
จน์ (expression)
sem sed magna
•• ค่Lorem
าเดี่ยว ipsum dolor sit amet, consectetuer
• นิadipiscing
พจน์ยอ่ ย
elit. Vivamus et magna. Fusce sed
suscipit egestas.
• sem
นิพจน์แsed
บบมีเงืmagna
่อนไข
Imperative vs. Functional
int fact(int n)
{
int i = 1;
for (int j = n; j>1; --j)
i = i * j;
return I;
}
fun fact(0) = 1
| fact (n) = n * fact(n-1);
• ไม่มีคาสัง่ (statement)
• ประกอบด้ วยนิพจน์
• สัง่ ให้ ทาซ ้าโดยใช้ recursive
function
• เรี ยกใช้ ฟังก์ชนั่ ให้ ทางาน แทน
การระบุในรูปคาสัง่ เช่น
fact(3)
การประมวลผล
กลไกพื ้นฐาน 2 ประการ
• การเชื่อมโยงระหว่างชื่อกับค่า (binding)
• การเรี ยกใช้ ฟังก์ชนั่ (application)
fact(3)
• เชื่อมโยง 3 กับชื่อ n ในโปรแกรม
• เรี ยกใช้ ฟังก์ชนั่ ที่ n มีคา่ เป็ น 3
ฟังก์ชนั่ (function)
• การเชื่อมโยงข้ อมูลจากเซตของโดเมน ไปยัง ข้ อมูลใน
เซตของเรนจ์ (โคโดเมน)
X1
f(X1)
X2
X3
f(X2) = f(X3)
X4
f(X4)
การเชื่อมโยงข้อมูล (mapping)
• Total function การเชื่อมโยงข้ อมูลทุกตัวในเซต
ของโดเมน
• Partial function การเชื่อมโยงข้ อมูลบางตัวใน
เซตของโดเมน
• ข้ อมูลหนึง่ ตัวจากเซตของโดเมนจะเชื่อมโยงไปยัง
ข้ อมูลเพียงตัวเดียวในเซตของเรนจ์
• การนิยามฟั งก์ชนั่ ไม่กากวม
การอธิบายการเชื่อมโยง
รูปแบบการอธิบายการเชื่อมโยง
• การแจกแจงทุกการเชื่อมโยง
• แผนภาพ
• กฎหรื อสมการ
...
...
sign(-2) = minus
sign(-1) = minus
sign(0) = zero
sign(1) = plus
sign(1) = plus
…
…
.
.
-2
-1
0
1
2
.
.
minus
zero
plus
minus if x <0
sign(x) = zero if x = 0
plus if x > 0
การเชื่อมโยงข้อมูล (mapping)
• Total function การเชื่อมโยงข้ อมูลทุกตัวในเซต
ของโดเมน
• Partial function การเชื่อมโยงข้ อมูลบางตัวใน
เซตของโดเมน
• ข้ อมูลหนึง่ ตัวจากเซตของโดเมนจะเชื่อมโยงไปยัง
ข้ อมูลเพียงตัวเดียวในเซตของเรนจ์
• การนิยามฟั งก์ชนั่ ไม่กากวม
แคลคูลสั แลมป์ ดา
•
•
•
•
•
แคลคูลสั อย่างง่าย
ใช้ เป็ นโมเดลอธิบายการทางานของฟั งก์ชนั่
เป็ นพื ้นฐานในการออกแบบภาษาเชิงหน้ าที่
ใช้ เครื่ องหมาย l (lambda) แทนฟั งก์ชนั่
ตัวอย่างการนิยามฟั งก์ชนั่
lx.x*x
การเรี ยกใช้
((lx.x*x )2)
ตัวอย่าง
• กาหนด square  lx.x*x
• จงหา to-the-fourth  square o square
 l(square,square).lx.square(square(x))
 lx.(lx.x*x(lx.x*x(x)))
 lx.(lx.x*x(.x*x))
 lx.((.x*x)(x*x))
 (2*2) * (2*2)
 4*4
องค์ประกอบของภาษา (Components)
•
•
•
•
ใช้ การเรี ยกฟั งก์ชนั มาทางาน แทนการระบุในรูปคาสัง่
นิยามขึ ้นจากนิพจน์ตา่ งๆ
เป็ นลักษณะการทางานตามหน้ าที่ (Functional)
มีสว่ นประกอบดังนี ้
 โครงสร้ างข้ อมูลพื ้นฐาน คือ list ใช้ เก็บข้ อมูล
 ฟั งก์ชนั พื ้นฐาน เพื่อทางานกับ list
 โครงสร้ างที่ช่วยสร้ างฟั งก์ชนั ใหม่จากฟั งก์ชนั ที่มีอยู่
ภาษา
LISP
Title
LISP
- Listipsum
and Symbol
Processing
Language
• Lorem
dolor sit
amet, consectetuer
et magna.แทรน
Fusce sed
• adipiscing
ภาษาระดับสูงเก่elit.
าแก่อนั Vivamus
ดับสองรองจากภาษาฟอร์
sed่อนประมวลผลกั
magna suscipit
egestas.
• sem
สร้ างขึ ้นเพื
บข้ อความสั
ญลักษณ์ตา่ งๆ
•• Lorem
ipsum
sitษฐ์amet, consectetuer
เหมาะกับงานด้
านปั ญdolor
ญาประดิ
adipiscing elit. Vivamus et magna. Fusce sed
• เป็
น
ภาษาเชิ
ง
หน้
า
ที
่
อ
ย่
า
งแท้
จ
ริ
ง
sem sed magna suscipit egestas.
•• การท
างานผ่
า
นฟั
ง
ก์
ช
น
่
ั
Lorem ipsum dolor sit amet, consectetuer
• ไม่
มีการใช้ ตวั แปรelit.
global
หรื อคาสัet
ง่ กาหนดค่
าให้ ตFusce
วั แปร sed
adipiscing
Vivamus
magna.
magna
suscipit
egestas.
• sem
ค่าของตัsed
วแปรเกิ
ดจากการส่
งผ่านค่าระหว่
างฟั งก์ชนั่
LISP (List Processor)
• นิพจน์ Lambda
– (lx.ly. x+y)
• โปรแกรมในภาษา LISP
(LAMBDA(X Y) (PLUS X Y))
• การเรี ยกใช้ ฟังก์ชนั่
((LAMBDA(X Y) (PLUS X Y)) 2 3)
• การตังชื
้ ่อฟั งก์ชนั่
– DEFINE(ADD(LAMBDA(X Y) (PLUS X Y)))
– (ADD 2 3)
LISP (List Processor)
• Primitive function
–
–
–
–
Identity function
Selection Operations
Structuring Operations
Predicate Functions
QUOTE
CAR, CDR
CONS
ATOM, NULL, EQ, COND
• DEFINE(ADD(LAMBDA(X Y) (PLUS X Y)))
• Functional forms
(LAMBDA(x) (SQUARE(SQUARE x))5)
• Objects
ATOM, LIST
ภาษา Title
Scheme
•
•
•
•
•
•
••
•
Lorem
ipsum dolor
มีรากฐานจากภาษา
LISP sit amet, consectetuer
adipiscing
elit. Vivamus
et magna. Fusce sed
โครงสร้ างภาษาขนาดเล็
ก
sem sed magna suscipit egestas.
syntax และ semantic ง่ายไม่ซบั ซ้ อน
Lorem ipsum dolor sit amet, consectetuer
เขี
ยนอยูใ่ นรูปแบบโครงสร้
างของ listetหรืmagna.
อนิพจน์ตา่ งๆ
adipiscing
elit. Vivamus
Fusce sed
sem
sed ้าใช้
magna
suscipit
egestas.
การทางานซ
วิธีการของ
recursive
function
Lorem
ipsum
dolor sit
amet, consectetuer
ตัวแปรภาษาเป็
นลักษณะของ
interpreter
adipiscing elit. Vivamus et magna. Fusce sed
เป็
นภาษาที
มใช้ ในการเรี
ยนการสอน
sem
sed่นิยmagna
suscipit
egestas.
Scheme
• Syntax : โปรแกรมประกอบด้ วยนิพจน์ เขียนอยูใ่ น
วงเล็บในรูป prefix (ในรูปโครงสร้ างของ list)
˃
˃
˃
˃
(+ 2 3)
(- 4 2 1)
(* 5 (+ 4 3))
(max 2 3 17)
; evaluates to 5
; evaluates to 1
• Semantic : สัญลักษณ์ตวั แรกในนิพจน์ คือ
operator/function ตัวที่ตามมาเป็ น
operand/argument
Scheme
• กาหนดค่าหรื อตัวแปร
˃ (define f 120)
˃f
; evaluates to 120
˃ (+ f 5)
• กาหนดเป็ นรูปแบบของข้ อมูล
˃ (2 3 4)
; error: 2 is not a function
˃ (quote (2 3 4))
˃ ‘(2 3 4)
ประเภทของนิพจน์
• นิพจน์คณิตศาสตร์ ให้ คา่ เป็ นตัวเลข
> (+ f 5)
• นิพจน์ตรรกะ ให้ คา่ เป็ นจริงและเท็จ
> (< 1 5)
> (not (> 5 10)
• นิพจน์แบบมีเงื่อนไข ให้ เลือกทางานตามเงื่อนไขที่ระบุ
> (if (> 5 4) 40 50)
> (cond ((> 3 2) “greater”) ((<3 2) “less”)))
• นิพจน์แลมป์ดา ใช้ นิยามฟั งก์ชนั
> (lambda (x) (+ x 1))
> ((lambda (x) (+ x 1)) 3)
ฟังก์ชนั ประมวลผลข้อมูล
• (null? x)
ตรวจสอบว่า x เป็ น list ว่างหรื อไม่
• (cons a x)
เพิ่ม a เข้ าไปที่ต้น list
• (append x y) นา list y ไปต่อท้ าย list x
• (car x)
ส่งค่าสมาชิกตาแหน่งแรกใน list x
• (cdr x)
ส่งค่าสมาชิกใน list x ทุกตัว ยกเว้ นตัวแรก
• (length x)
ส่งค่าจานวนสมาชิกใน list x
• (reverse x)
ส่งค่าเป็ นสมาชิกใน list x ในลาดับย้ อนกลับ
• (equal? x y) ตรวจสอบว่า list x เหมือนกับ list y หรื อไม่
ฟังก์ชนั ประมวลผลข้อมูล
> (define mylist (list 1 2 3 4))
> mylist
> (length mylist)
> (reverse mylist)
> (cons a mylist)
> (append ‘(a b) mylist)
> (null? mylist)
> (car mylist)
> (cdr mylist)
> (car (cdr mylist))
> (cdr (cdr mylist))
> (car (cdr (cdr mylist)))
; mylist
; (1 2 3 4)
;4
; (4 3 2 1)
; (a 1 2 3 4)
; (a b 1 2 3 4)
; #f
;1
; (2 3 4)
ฟังก์ชนั เวียนบังเกิด
1 if n=0
(define (factorial n)
f(n) 
n*f(n-1)
(if (< n 1)
1
(* n (factorial (- n 1) ) ) ) )
if n>0
(factorial 3) = (* 3 (factorial 2))
= (* 3 (* 2 (factorial 1)))
= (* 3 (* 2 (* 1 (factorial 0))))
= (* 3 (* 2 (* 1 1)))
= (* 3 (* 2 1))
= (* 3 2)
=6
Imperative VS Functional
• แนวคิดพื ้นฐานของการสร้ างโปรแกรม
– ฟั งก์ชนั ทางคณิตศาสตร์ เชื่อมโยงค่าจากข้ อมูลไปยังผลลัพธ์
– กาหนดค่าข้ อมูลในรูปตัวแปร ทาการเปลี่ยนแปลงค่าโดย
คาสัง่ ต่างๆ ไปสูผ่ ลลัพธ์
• ความเป็ นอิสระจากฮาร์ ดแวร์
– ไม่เกี่ยวข้ องกับโครงสร้ างภายในหน่วยความจาหรื อการ
เปลี่ยนสถานะของหน่วยความจา
• การเขียนโปรแกรม
– syntax และ semantic ที่เรี ยบง่ายประกอบด้ วย
นิพจน์ตา่ งๆ