Functional programming part II

Lambda calculus Pure lambda calculus นิพจน์มีเพียง 3 ประเภทคือ ตัวแปรเดี่ยว, คำนิยามฟังก์ชัน และการเรียกใช้ฟังก์ชัน ไม่ได้รวม ค่าคงที่ และ ฟังก์ชันการคำนวณคณิตศาสตร์ ยิ่งไปกว่านั้น ในแคลคูลัสแลมป์ดาแท้ไม่มีการใช้จำนวนเลข แต่จะกำหนดทุกอย่างให้อยู่ในรูปของตัวแปร และฟังก์ชัน เช่น กำหนดให้ x แทนค่าศูนย์ และ f(x) เป็นฟังก์ชันที่เพิ่มค่า x ขึ้นหนึ่งค่า เราสามารถเขียน ค่าคงที่เป็นจำนวนเลขในรูปแบบของแคลคูลัสแลมป์ดาแท้ ได้ดังนี้ 0  f. x. x 1  f. x. f(x) 2  f. x. f(f(x)) 3  f. x. f(f(f(x))) . n  f. x. fn(x)

Lambda calculus (cont) Applied lambda calculus อนุญาตให้นิพจน์เป็นค่าคงที่ และฟังก์ชันพื้นฐานต่างๆ ได้ (เพื่อใช้โอเปอเรเตอร์ เช่น +, *) ดังนั้น กฏการคำนวณค่าของนิพจน์แลมป์ดา จึงต้องมีการกำหนดเพิ่มเติม เพื่อให้สามารถคำนวณค่าคงที่และฟังก์ชัน พื้นฐานต่างๆ ได้ กฏข้อที่ 3 การกำจัดฟังก์ชันซ้ำซ้อน หรือเรียกว่า การแปลงแบบเอทต้า (-conversion) (x. E x)  => E , x is not free in E

Lambda calculus (cont) กฏข้อที่ 4 การลดรูปนิพจน์ที่มีค่าคงที่ หรือเรียกว่า การลดรูปแบบเดลต้า (-reduction) เช่น ถ้า if, true, false เป็นค่าคงที่กฏการลดรูปค่าคงที่เหล่านี้ คือ if true M N  => M if false M N  => M โดยค่าคงที่ true และ false นิยามได้ตามลำดับดังนี้ x. y. x x. y. Y

สรุป lambda calculus Lambda calculus เป็นรูปแบบอย่างเป็นทางการที่ถูกสร้างขึ้นมา เพื่ออธิบายขั้นตอนการ ทำงานของฟังก์ชัน โดยการแปลงรูปของสัญลักษณ์ไปสู่รูปแบบปกติ ซึ่งจะเป็นผลลัพธ์สุดท้ายของ ฟังก์ชัน ฟังก์ชัน ถือเป็นค่าที่มีความสำคัญสูงสุด (first-class value) นิพจน์ พารามิเตอร์ในฟังก์ชันอื่น ข้อมูล เหมือนกับข้อมูลพื้นฐานอื่นๆ ไม่มีผลข้างเคียง (no side-effect) เป็นต้นแบบของภาษา LISP, Scheme, ML, Miranda, Haskell

ภาษาลิสป์และสคีม ภาษา LISP (List and Symbol Processing Language) ถูกสร้างขึ้นโดย John Macarthy ในปีค.ศ. 1958 ที่ MIT เป็นภาษาระดับสูงที่มีอายุเก่าแก่เป็นอันดับสองรองจากภาษาฟอร์แทรน ถูกสร้างขึ้นมาเพื่อประมวลผลกับข้อความประเภทสัญลักษณ์ต่างๆ เหมาะกับ AI ถ้าเป็นการประมวลผลกับตัวเลขจะช้ากว่าฟอร์แทรนมาก

LISP (cont) การทำงานทุกอย่าง กระทำผ่านฟังก์ชัน ไม่มีการใช้ตัวแปรส่วนกลาง และไม่มีการใช้คำสั่งกำหนดค่าให้ตัวแปร ค่าของตัวแปรจะเกิดจาก การส่งผ่านระหว่างฟังก์ชันเท่านั้น ยกเว้น ภาษา LISP ในรุ่นหลัง เช่น Common LISP อนุญาตให้ใช้คำสั่งกำหนดค่า จึงทำให้ไม่เป็นภาษาเชิงหน้าที่ อย่างแท้จริง เป็นภาษาแรกที่ริเริ่มให้มีการใช้ฟังก์ชันเรียกตัวเองซ้ำ (recursion) ใช้ฟังก์ชันเป็น first-class value นั่นคือ ฟังก์ชันปรากฏในนิพจน์ได้, ถูกส่งเป็นพารามิเตอร์ ได้ และใช้เป็นข้อมูลได้ เป็นภาษาแรกที่กำหนดวิธีการเรียกคืนหน่วยความจำที่ไม่ได้ถูกใช้งานแล้ว (garbage collection)

LISP (cont) เขียนอยู่ภายในวงเล็บด้วยรูปแบบนิพจน์พรีฟิกซ์ ฟังก์ชันการบวกในแคลคูลัสแลมป์ดา โปรแกรมในภาษา LISP การเรียกใช้ฟังก์ชันด้วยการส่งค่า 2 และ 3 จะกระทำเช่นเดียวกับแคลคูลัสแลมป์ดา (x. y. x + y) (LAMBDA (x y) (PLUS x y)) ((LAMBDA (x y) (PLUS x y)) 2 3)

LISP (cont) ฟังก์ชันในภาษา LISP สามารถถูกตั้งชื่อได้ด้วยคำสั่ง (หรือฟังก์ชัน) DEFINE ดังนี้ ซึ่งจะช่วยให้เราสามารถเรียกใช้ฟังก์ชันได้สะดวกขึ้น ดังนี้ (DEFINE (ADD (LAMBDA (x y) (PLUS x y)))) (ADD 2 3)

Scheme เป็นภาษาที่มีรากฐานมาจากภาษา LISP แต่ปรับปรุงภาษาให้มีขนาดเล็กลง ตัวแปลภาษาจะมีลักษณะของอินเตอร์พรีตเตอร์ โดยการสั่งงานจะเป็นลักษณะโต้ตอบ เช่น เมื่อจะเลิกใช้งาน ให้ใช้คำสั่ง หรือ หรือกด ctrl + D > (+ 4 5) 9 > (quit) > (exit)

โปรแกรม และนิพจน์ (program and expression) โปรแกรมในภาษาลิสป์ และสคีม จะประกอบขึ้นจากนิพจน์ซึ่งเขียนอยู่ภายในวงเล็บ ด้วย รูปแบบพรีฟิกซ์ Operator and operand การใช้รูปแบบพรีฟิกซ์จะช่วยให้การเขียนมีความยืดหยุ่น (+ 2 3) (- 3 2) (* 5 (+ 4 6)) (max 2 3 17) (+) ; evaluates to 0 (+ 5) ; evaluates to 5 (+ 5 4 3 2 1) ; (*) ; (* 5) ; (* 1 2 3 4 5) ;

Program and expression (cont) ฟังก์ชัน define เป็นการกำหนดชื่อตัวแปร f ให้เชื่อมโยงค่า 120 และชื่อ f สามารถถูกเรียกใช้ได้ในนิพจน์อื่นๆ ดังนี้ นิพจน์ในภาษาสคีมจำแนกได้เป็น 4 ประเภทคือ นิพจน์คณิตศาสตร์, นิพจน์ตรรกะ, นิพจน์แบบมี เงื่อนไข และนิพจน์แลมป์ดา (define f 120) f ; evaluates to 120 (+ f 5) ;

นิพจน์ในภาษาสคีม นิพจน์คณิตศาสตร์ (arithmetic expressions) เป็นนิพจน์ที่ให้ค่าเป็นตัวเลข นิพจน์ตรรกะ (Boolean expressions) เป็นนิพจน์ที่ให้ค่าเป็นจริง (#t) และเท็จ (#f) 7 ; has the value 7 (7 is called an atom) (+ f 3) ; has the value 123 (< 1 2) ; has the value #t (>= 3 4) ; (= 4 4) ; (not (> 5 6)) ; (and (< 3 4) (= 2 3)) ; (or (< 3 4) (= 2 3)) ;

นิพจน์ในภาษาสคีม (ต่อ) นิพจน์แบบมีเงื่อนไข (conditional expressions) เป็นนิพจน์เลือกทำงานโดยการเลือก ซึ่งจะขึ้นอยู่กับเงื่อนไขที่ระบุ if cond (if <test> <test-expression> <false-expression>) (cond (<tes-exp1> <expression1>) (<tes-exp2> <expression2>) … (else <else-exp>))

นิพจน์ในภาษาสคีม (ต่อ) (if (> 5 4) 42 99) ; has the value 42 (if (< 5 4) 42 99) ; (if (> 5 0) 33) ; (if (< 5 0) 33) ; ตัวอย่าง (cond ((> 3 2) “greater”) ((< 3 2) “less”)) ; (cond ((> 3 3) “greater”) ((< 3 3) “less”) (else “equal”)) ; (define n -5) (cond ((< n 0) “negative”) ((> n 0) “positive”) (else “zero”)) ;

นิพจน์ในภาษาสคีม (ต่อ) นิพจน์แลมป์ดา (lambda expressions) เป็นนิพจน์ที่ใช้นิยามฟังก์ชัน การตั้งชื่อให้กับฟังก์ชัน ทำได้ดังนี้ หรือใช้รูปย่อที่ไม่ต้องมีคำว่า lambda และการเรียกใช้ฟังก์ชันที่ได้รับการตั้งชื่อทำได้ดังนี้ (lambda (x) (+ x 1)) ((lambda (x) (+ x 1)) 3) ; has the value 4 (define add (lambda (x) (+ x 1))) (define (add x) (+ x 1)) (add 3) ; has the value 4

Built-in functions in scheme

Program and expression (cont) โปรแกรมและข้อมูลในภาษาสคีม และภาษาลิสป์ จะใช้โครงสร้างของลิสต์ ซึ่งเขียนอยู่ในรูปแบบ ตัวแปรภาษาสคีมจะประมวลผลโปรแกรมด้วยการตีค่า a ว่าคือฟังก์ชัน และ b, c, d คือ อาร์กิวเมนต์ของฟังก์ชัน เครื่องหมาย + คือ ฟังก์ชันการบวก อาร์กิวเมนต์คือ 2, 3, 4 จะใช้การเรียกตัวเองซ้ำ (a b c d) (+ 2 3 4)