ตอนนี้พี่ บอย มีโปรเจ็คใหม่กับพี่นพ คือ อลบั้ม BoydNop

มีเพลงปล่อยมาให้ฟังแล้ว 3 เพลง มีเป็น MV แล้ว 2 เพลงคือ Away Far So  กับ ยาก

MV แบบว่ารวมญาติมากๆ มีคนที่เคยร่วมงานกับพี่บอย ทั้งสมัย Bakery และ Love Is มากมาย

เช่น Lipta, Stamp, โต๋ และได้ พลอย มาร่วมด้วย พร้อมเด็กน้อยลูกๆหลานๆ น่ารักมาก

ตอนนี้ก็รอเมื่อไหร่จะมีอลบั้มเต็มๆวางแผงหละครับ ไม่พลาดแน่นอน และก็รอคอนเสิร์ต ที่ต้องออกมาดีแน่ๆ

เวลาสร้างฟอร์มในหน้าเพจให้กรอกข้อมูลอะไรสักอย่าง เราจำเป็นต้องตรวจสอบความถูกต้องของข้อมูลว่าเป็นตามเงื่อนไข หรือ ได้รูปแบบของข้อมูลที่ถูกต้องหรือไม่ เช่นฟอร์มรับสมัคร ฟอร์มกรอกเนื้อหาบล็อก ปกติเราจะตรวจสอบข้อมูลตรงนี้หลักจากที่ซับมิทข้อมูลไปแล้ว ก็ไปใช้ภาษาฝั่งเซอเวอร์ตรวจสอบเช่น php ถ้าข้อมูลไม่ถูกต้องก็ให้ redirect กลับมาที่หน้าฟอร์มใหม่ แต่วิธีนี้ต้องมีการ request ข้อมูลไปก่อนแล้วต้องรอ response กลับมา ถ้ากรอกผิดหลายรอบก็ต้องมานั่งซับมิทใหม่หลายๆรอบ

เราเลยจะใช้ภาษาฝั่ง client อย่าง javascript มาช่วยตรวจสอบข้อมูลของฟอร์มก่อนที่จะซับมิทข้อมูลไป มี library หลายเจ้าที่ช่วยตรงนี้ ที่เอามาให้ดูคือ LiveValidation เป็น เป็น library เล็กๆ มี pattern วิธีใช้ง่ายๆ

ตัวอย่างเช่นจะตรวจสอบว่า text input ที่มี id ชื่อว่า username นี้ต้องมีข้อมูลถ้าไม่มีจะ ซับมิทไปไม่ได้ และขึ้นข้อความบอกว่าข้อมูลไม่ถูกต้องให้เขียน script แบบนี้

var username = new LiveValidation('username');
username.add( Validate.Presence );

จากโค้ด ให้สร้าง object ของ LiveValidation โดยใส่ชื่อ id ของ field ที่จะ validate เป็นพารามิเตอร์ จากนั้นเราจะเพิ่ม เงื่อนไขการตรวจสอบโดยเรียก method add แล้วกำหนดเงื่อนไขโดยใช้ค่าจาก object Validate เช่่น Validate.Presence ตรวจสอบว่าต้องมีข้อมูลกรอกที่ text input นี้

อีกตัวอย่างเป็นการตรวจสอบว่าต้องใส่ข้อมูลในรูปแบบของ email

var email = new LiveValidation('email');
email.add( Validate.Email );

เมื่อเรากรอกข้อมูลถูกต้อง หรือ ไม่ถูกต้อง ตัว LiveValidation จะเพิ่มข้อความบอกไว้หลัง input field โดยครอบอยู่ใน tag span โดยมี class ต่างๆบอกว่าสถานะว่าเป็น valid หรือ invalid เราสามารถจัด style sheet ให้กับข้อความในสถานะต่างๆได้ class ที่บอกสถานะต่างๆมีดังนี้

• LV_validation_message – the class that is added to all validation messages
• LV_valid – the class that is added to a valid message
• LV_invalid – the class that is added to an invalid message
• LV_valid_field – the class that is added to a valid field
• LV_invalid_filed – the class that is added to an invalid field

Reference : http://livevalidation.com/

การทำงานของโปรแกรมโดยทั่วไปเวลาเรียก function นั้นจะมีการจำตำแหน่งที่เรียกเอาไว้แล้วกระโดดเข้าไปทำงานใน function เมื่อเจอคำสั่ง return ก็จะกระโดดกลับมา ดั้งนั้นถ้ามีการเขียนแบบ recursive ก็จะมีการสร้าง stack ของการ call function ซ้อนๆกันไว้ แล้วพอ return ก็จะย้อนกลับมาทีละ step นี่คือกรณีของ recursive แบบธรรมดาทั่วๆไป ซึ่งจะเห็นว่าจะต้องเสียเวลาในการกระโดดกลับมา

Tail Recusion นั้นจะช่วยลดการทำงานตรงนั้นได้โดยแทนที่จะรอให้ได้ผลลัพธ์เมื่อมีการย้อน กลับ ก็จะทำการเก็บผลลัพธ์ตั้งแต่การเรียก recursive function จนเมื่อถึง การ call ครั้งสุดท้ายก็จะเป็นการ return ผลลัพธ์ออกมาทันที ไม่ต้องย้อนกลับไปอีก

ตัวอย่าง ฟังก์ชัน หาความยาวของ list ถ้าเขียนแบบ recursive ธรรมดา ได้แบบนี้

mylength :: [a] -> Int

mylength [] = 0
mylength (y:ys) =  1+mylength (ys)

จะเห็นว่าแบบนี้ terminate function จะรับค่า empty list แล้ว return 0 ออกมา เมื่อมีการ recursive ก็จะเอา 1 ไปบวกไป แบบนี้จะเกิดการ call ไปจนสุด แล้วค่อยเอาค่า มาบวกกันทีหลังแบบนี้

mylength "abc" -> 1+mylength("bc")
                        -> 1+1+mylength("c")
                        -> 1+1+1+mylength("")
                        -> 1+1+1+0
                        -> 1+1+1
                        -> 1+2
                        -> 3

แต่ถ้าเขียนแบบ tail recursive เราจะเพิ่มตัว accumulator เข้ามา ตัว accumulator ก็คือ พารามิเตอร์ที่เก็บ ผลลัพธ์ในแต่ละ step ที่ทำการ recursive เมื่อ terminate ที่เป็นการ call ครั้งสุดท้ายเราจะ return ค่า accumulator ออกมาทันที

mylength :: [a] -> Int
mylength ys =  _mylength ys 0
_mylength [] n = n
_mylength (y:ys) n = _mylength ys (n+1)

ตัวอย่างนี้เราเขียน function _mylenth ขี้นมาเป็น tail recursion แล้วตัวfunction mylength ของเรา ก็ค่อย call _mylength โดยส่งค่า 0 เป็นค่าเริ่มต้นของ accumulator

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

1. เอาโค้ดนี้ ไปไว้ใน Application.cfc

   <cfscript>
       SetEncoding("form","utf-8");
       SetEncoding("url","utf-8");
   </cfscript>
   

   แบบนี้คือบอกว่าข้อมูลที่อยู่ใน scope form และ url ใช้ utf-8

2.         <cfcontent type="text/html; charset=utf-8">
   

   โค้ดนี้บอกว่า template ที่เปิดเป็นไฟล์แบบ text/html และ ใช้ charset เป็น utf8
   โดยโค้ดนี้ต้องอยู่ส่วนบนสุดของไฟล์

3.         <cfprocessingdirective pageEncoding="utf-8">
   

   อันนี้ก็เอาไปวางได้ทุกๆ template ที่มีการติดต่อ db หรือว่ามี i/o กับ browser
   ถ้าใช้กับ coldbox ก็สามารถ เอาไปว่างไว้ที่ Layout ที่เดียวได้เลย

ตอนนี้กำลัง ค่อยๆ ไล่อ่าน หนังสือ Real World Haskell ที่ร่วมกันเขียนโดย  Bryan O’Sullivan, Don Stewart, and John Goerzen
หนังสือตีพิมพ์เป็นเล่มขายแล้ว อยากซื้อเก็บเหมือนกัน แต่ก็ไม่เคยซื้อผ่าน amazon ไม่มีพวกบัตรเครติด อะไรเลย ก็เลยยังไม่ซื้อ

หนังสือเล่มนี้ มีให้อ่านออนไลน์ผ่านเว็บ http://book.realworldhaskell.org/ ที่จริง หนังสือเล่มนี้ก่อนตีพิมพ์ ผู้แต่งเขาก็เอาขึ้นเว็บ
ให้อ่าน และก็ให้ comment ในแต่ละ paragraph ได้ในระหว่างแต่ง เพราะฉนั้นถ้าเข้าไปอ่านจะเห็นว่าในแต่ละ paragraph จะมีลิ้ง
ให้ comment ได้

มาว่ากันตามหัวข้อ คือ เขียนโครงสร้างข้อมูลแบบ Tree ด้วย Haskell ซึ่งมันเป็นแบบฝึกหัดอยู่ที่บทที่ 3 ว่าให้สร้าง data type Tree
โดยให้มี variable constructor ตัวเดียว โดยใช้ data type Maybe a เข้าช่วย นั่งทำอยู่นาน กว่าจะทำได้ แล้วก็ได้ออกมาแบบนี้

data Tree  a = Node a (Maybe (Tree a)) (Maybe (Tree a))
                deriving (Show)

ถ้าแบบไม่ใช้ Maybe ตามตัวอย่างในหนังสือจะเป็นแบบนี้ ซึ่งจะมี variable constructor 2 ตัวโดย มี Empty อีกตัว

data Tree  a = Node a (Tree a) (Tree a)
                      | Empty
                deriving (Show)

data type Tree ที่สร้างมาเป็น type แบบ Recursive types จะเห็นว่า pattern ของ variable constructor จะมี
data type Tree อยู่ด้วย ตัวอย่างการเอาไปใช้งานแบบ ไม่ใช้ Maybe จะเป็นแบบนี้

myTree = Node 10 Empty Empty
myTree2 = Node 10 (Node 20 Empty Empty) Empty

ส่วนแบบ Maybe เราไม่จำเป็นต้อง สร้าง Empty ขึ้นมาเพราะเราจะใช้ Nothing ซึ่งเป็น ข้อมูลแบบ Maybe ในการกำหนดค่า
childNode ของ Tree ได้ เช่น

myTree = Node 10 Nothing Nothing

และ ใช้ Just ในการกำหนด childNode ที่ไม่เป็น Nothing

myTree2 = Node 10 (Just (Node 20 Nothing Nothing)) Nothing

จบแค่นี้ครับ ไม่ได้อัพบล็อคตัวเองซะนาน เพราะหัวข้ออื่นๆก็เอาไปอัพที่ *66.com ซะหมดแล้ว

ตอนแรกตั้งใจอ่านไฟล์ โดยใช้ cffile ปกติ แล้วค่อยมาวนลูปค่าในไฟล์ที่ละบรรทัด
แล้วค้นไปเจอว่า CF8 มันสามารถใช้ cfloop กับ file ได้เลยลองใช้ดู ง่ายดีจริงๆ
ตัวอย่างเช่น

<cfloop file="#Expandpath('nqi/cfcservice/')#data.txt" index="line">
    <cfscript>
        data = listtoarray(line,"|");
    </cfscript>
    <cfquery datasource="AisNQG">
        insert into nqi_presentation values
        (<cfqueryparam cfsqltype="cf_sql_date" value="#data[1]#">,
         <cfqueryparam cfsqltype="cf_sql_varchar" value="#data[2]#">,
         <cfqueryparam cfsqltype="cf_sql_varchar" value="#data[3]#">,
         <cfqueryparam cfsqltype="cf_sql_varchar" value="#data[4]#">,
         <cfqueryparam cfsqltype="cf_sql_varchar" value="#data[5]#">,
         <cfqueryparam cfsqltype="cf_sql_varchar" value="#data[6]#">,
         <cfqueryparam cfsqltype="cf_sql_numeric" value="#data[7]#">,
         <cfqueryparam cfsqltype="cf_sql_numeric" value="#data[8]#">
         )
    </cfquery>
</cfloop>

แค่ใส่ attribute file เป็นพาธของไฟล์ ที่จะอ่าน แล้ว ใส่ตัวแปรให้กับ attribute index 
โดย เช่น line โดยตัวแปรนี้จะเก็บข้อมูลของแต่ละบรรทัดในไฟล์ที่กำลังอ่าน ]]> http://iporsut.wordpress.com/2008/08/25/coldfusion-cfloop-readline-from-file/feed/ 0 iporsut http://iporsut.wordpress.com/2008/08/22/simple-list-functions/ http://iporsut.wordpress.com/2008/08/22/simple-list-functions/#comments Sat, 23 Aug 2008 02:42:58 +0000 iporsut http://iporsut.wordpress.com/?p=54 ]]>

ส่วนใหญ่แล้วการคำนวณต่างๆใน haskell programs คือการประมวลผล list ซึ่งมี 3 ฟังก์ชันหลักที่ทำหน้าที่ประมวลผลเกี่ยวกับ list คือ map, filter, foldr(รวมทั้ง foldl ด้วย)

map ฟังก์ชัน จะรับอาร์กิวเม้นคือ list และ ฟังก์ชันที่จะกระทำกับข้อมูลแต่ละตัวในลิสต์ที่รับเข้ามา เช่น ฟังก์ชัน Char.toUpper ที่รับค่า Char หนึ่งตัวแล้วเปลี่ยนให้เป็น Char ตัวใหญ่ทั้งหมด ดังนั้นถ้าเราต้องการเปลี่ยน character ทั้งหมดในสตริงให้เป็น ตัวใหญ่ ซึ่ง string ก็คือลิสต์ที่มีสมาชิกเป็น character เราสามารถ map ฟังก์ชัน toUpper ให้ทำงานกับทุกๆสมาชิกของ string ได้โดยใช้ฟังก์ชัน map ตัวอย่างการใช้งานเช่น

Prelude> map Char.toUpper “Hello World”
“HELLO WORLD”

ใน การ ลบ ข้อมูลออกจากลิสต์ สามารถใช้ฟังก์ชัน filter ช่วยได้ ฟังก์ชันนี้ช่วยให้สามารถลบข้อมูลออกจากลิสต์โดยกำหนดเงื่อนไขที่ขึ้นอยู่ กับค่าของข้อมูลได้ ตัวอย่างเช่น ฟังก์ชัน Char.isLower จะบอกว่าข้อมูลเป็น character ตัวเล็กหรือไม่ เราสามารถใช้ filter ในการลบcharacterที่ไม่ได้เป็นอักษรตัวเล็กออกจากlistได้โดยทำดังนี้

Prelude> filter Char.isLower “Hello World”
“elloorld”

ฟังก์ชัน foldr รับค่าอาร์กิวเม้น 3 ค่า คือรับ ฟังก์ชัน,ค่าเริ่มต้น และ ลิสต์ จะเข้าใจ foldr ได้ง่ายๆคือมองลิสต์ที่รับเข้ามาในรูปของ cons operater เมื่อfoldr ทำงานจะเอา ฟังก์ชัน ไปแทนที่ : และเอาค่าเริ่มต้นไปแทน [] ดังนั้นถ้าเรามีลิสต์แบบนี้
3:8:12:5:[]
แล้วเราใช้foldr ดังนี้
foldr (+) 0 [3,8,12,5] มันจะแปลงให้อยู่ในรูปแบบดังนี้
3 + 8 + 12 + 5 + 0
นั่นก็คือการเอาค่าใน list มาบวกกันลองใช้งานดูแบบนี้

Prelude> foldr (+) 0 [3,8,12,5]
28

ลองเปลี่ยนจาก (+) เป็น (*) และเปลี่ยนค่าเริ่มต้นเป็น 1 จะกลายเป็นการหาค่าผลคูณของทุกค่าในลิสต์

Prelude> foldr (*) 1 [4,8,5]
160

เมื่อ กี้บอกไปว่า foldr ทำงานโดยการแทนที่ : ด้วย function และ แทนที่ [] ด้วยค่าเริ่มต้น ที่นี้เกิดคำถามว่าแล้วกรณีที่ ฟังก์ชันที่รับเข้าไป ไม่เป็นแบบ associative ละ( associative คือ a*(b*c) = (a*b)*c ) เมื่อเราเขียน 4*8*5*1 เราหมายถึงเราเขียนวงเล็บแบบไหน แบบ ((4*8)*5)*1 หรือ 4*(8*(5*1)) foldr มองว่า functionที่รับเข้ามาเป็นแบบ right-associative ดังนั้นถ้าเราใช้ foldr กับ (-) จะได้ผลดังนี้

Prelude> foldr (-) 1 [4,8,5]
0

ขั้นตอนการทำงานของ foldr (-) 1 [4,8,5]
foldr (-) 1 [4,8,5]
==>         4 – (foldr (-) 1 [8,5])
==>         4 – (8 – foldr (-) 1 [5])
==>         4 – (8 – (5 – foldr (-) 1 []))
==>         4 – (8 – (5 – 1))
==>         4 – (8 – 4)
==>         4 – 4
==>         0

ฟังก์ชัน foldl ทำงานเหมือน foldr ต่างกันตรงการวิธีการที่มันจะใส่วงเล็บ จากเมื่อกี้จะเห็นว่า foldr จะเป็น right-associative ส่วน foldl ก็คือ left-associative ตัวอย่างเช่น

Prelude> foldl (+) 0 [3,8,12,5]
28

Prelude> foldl (-) 1 [4,8,5]
-16
จะเห็นว่าได้ผลต่างกับ foldr เพราะว่าวางวงเล็บคนละแบบ
ขั้นตอนการทำงานของ foldl (-) 1 [4,8,5]
foldl (-) 1 [4,8,5]
==>         foldl (-) (1 – 4) [8,5]
==>         foldl (-) ((1 – 4) – [5]
==>         foldl (-) (((1 – 4) – – 5) []
==>         ((1 – 4) – – 5
==>         ((-3) – – 5
==>         (-11) – 5
==>         -16

ข้อมูลอ้างอิง

Yet Another Haskell Tutorial http://darcs.haskell.org/yaht/yaht.pdf

String ใน haskell ก็คือ list ของข้อมูลแบบ Chars นั่นเอง ดังนั้นเราจึงสามารถสร้าง string อย่างเช่น “hello” ได้แบบนี้

Prelude> ‘H’:'e’:'l’:'l’:'o’:[]
“Hello”

List สามารถเชื่อมต่อกันได้ด้วย ++ string ก็ได้เช่นเดียวกันเพราะว่า string ก็คือ list ตัวอย่างเช่น

Prelude> “Hello ” ++ “World”
“Hello World”

สำหรับ ค่าข้อมูลที่ไม่ได้เป็นแบบ string สามารถถูกแปลงให้เป็น string ได้โดยใช้ ฟังก์ชัน show ส่วน string สามารถแปลงเป็นข้อมูลแบบอื่นได้ด้วยฟังก์ชัน read ถ้าเกิดค่าที่แปลงไม่ได้อยู่ในรูปแบบที่แปลงได้ก็จะเกิด error ขึ้น ตัวอย่างการใช้งานเช่น

Prelude> “Five squared is ” ++ show (5*5)
“Five squared is 25″
Prelude> read “5″ + 3
8
Prelude> read “Hello” + 3
Program error: Prelude.read: no parse

ข้อมูลอ้างอิง
Yet Another Haskell Tutorial http://darcs.haskell.org/yaht/yaht.pdf

ข้อจำกัดของ tuple ก็คือ จำนวนสมาชิกของข้อมูลที่เก็บจะมีจำนวนจำกัด ส่วนโครงสร้างแบบ list นั้นจะสามารถเพิ่มหรือลดจำนวนสมาชิกของข้อมูลได้ สร้าง list ใน haskell ได้ด้วยวิธีการคล้ายๆ tuple แต่เปลี่ยนจากวงเล็บแบบ () เป็น [] ตัวอย่างเช่น

Prelude> [1,2]
[1,2]
Prelude> [1,2,3]
[1,2,3]

list ยังอาจจะเป็นลิสต์ว่างก็ได้คือ [] คือไม่จำเป็นต้องมีสมาชิก เรียกว่า ลิสต์ว่าง หรือ empty list

ไม่ เหมือน tuple list สามารถเพิ่ม ข้อมูลเข้าไปที่ข้างหน้าได้โดยใช้ โคลอน(:) เรียกว่า cons โอเปอเรเตอร์ ที่มาของคำว่า cons ก็คือ “constructing a new list from an element and an old list” ก็คือการสร้างลิสต์ใหม่จาก สมาชิก และ ลิสต์เดิม ที่มีอยู่ ตัวอย่างการใช้ : ในการเพิ่มสมาชิกเข้าไปข้างหน้าลิสต์ เช่น

Prelude> 0:[1,2]
[0,1,2]
Prelude> 5:[1,2,3,4]
[5,1,2,3,4]

เราอาจจะสามารถสร้างลิสต์จากได้ [] และ : ได้ เช่น
Prelude> 5:1:2:3:4:[]
[5,1,2,3,4]

จริงๆ แล้วการสร้างลิสต์แบบ [5,1,2,3,4] เป็นรูปแบบไวยกรณ์ที่ง่ายๆ เพราะจริงๆแล้วเมื่อ compiler แปลงโปรแกรมจะทำการ แปลง ให้อยู่ในรูปของการใช้ : และ [] ในการเชื่อมข้อมูลแต่ละตัวในลิสต์

อีก ข้อแตกต่างนึงระหว่าง list และ tuple ก็คือ ข้อมูลที่มาเก็บใน list ต้องเป็นชนิดเดียวกันเท่านั้น ไม่สามารถเป็นคนละชนิดได้แบบ tuple

ลิสต์ สามารถเก็บสมาชิกได้หลายๆชนิดข้อมูล เช่นอาจจะเป็น ลิสต์ของจำนวนเต็ม ลิสต์ของสตริง ลิสต์ของลิสต์เอง หรือ ลิสต์ของtuple ก็ได้ ตัวอย่างเช่น

Prelude> [(1,1), (2,4), (3,9), (4,16)]
[(1,1), (2,4), (3,9), (4,16)]
Prelude> ([1,2,3,4], [5,6,7])
([1,2,3,4], [5,6,7])

2 ฟังก์ชัน พื้นฐานที่ทำงานกับลิสต์คือ head และ tail ฟังก์ชัน head จะให้ผลลัพธ์เป็นสมาชิกตัวแรกของลิสต์ สำหรับอินพุตที่ไม่เป็นลิสต์ว่าง ส่วน tail จะให้ผลลัพธ์เป็นลิสต์ที่เหลือยกเว้นสมาชิกตัวแรก สำหรับอินพุตที่ไม่เป็นลิสต์ว่าง ตัวอย่างการใช้งานเช่น
Prelude> length [1,2,3,4,10]
5
Prelude> head [1,2,3,4,10]
1
Prelude> tail [1,2,3,4,10]
[2,3,4,10]
Prelude> length (tail [1,2,3,4,10])
4

ข้อมูลอ้างอิงจาก

Yet Another Haskell Tutorial http://darcs.haskell.org/yaht/yaht.pdf

รูปแบบข้อมูลใน haskell นอกจากจะมาเป็นแบบค่าเดี่ยวๆแล้ว ยังมีข้อมูลแบบ pair ซึ่งก็คือข้อมูลแบบเป็นคู่ๆ เช่นข้อมูล pair ของจำนวนเต็ม สามารถสร้างได้โดยนำค่าใส่ใน วงเล็บ โดยมีคอมม่าคั่นข้อมูลคู่นั้น ลองใช้ pair ดูผ่าน ghci
Prelude> (4,9)
(4,9) นี่คือ pair ของเลข 4 และ 9 ใน haskell ค่าที่นำมาเป็นคู่ข้อมูล ไม่จำเป็นต้องเป็นชนิดข้อมูลแบบเดียวกัน เราสามารถสร้าง pair ของเลขจำนวนเต็ม คู่กับ string ได้ ซึ่งจะต่างกับ list ที่จำเป็นต้องมีข้อมูลชนิดเดียวกันทั้งหมด
มี ฟังก์ชัน 2 ฟังก์ชันที่ใช้สำหรับดึงค่า ข้อมูลตัวแรกของ pair และ ข้อมูลตัวที่สองของ pair นั่นคือ fst และ snd ตัวอย่างการใช้งานดังนี้

Prelude> fst (5, “hello”)
5
Prelude> snd (5, “hello”)
“hello”
นอกจากข้อมูลแบบเป็นคู่ pairs แล้วยังสามารถสร้างข้อมูลแบบ triples กลุ่มข้อมูล 3 ค่า และ quadruples กลุ่มข้อมูล 4 ค่า ตัวอย่าง triple และ quadruple เช่น
Prelude> (1,2,3)
(1,2,3)
Prelude> (1,2,3,4)
(1,2,3,4)
โดยทั่วไปแล้วเราสามารถรวมกลุ่มข้อมูลกี่ค่าก็ได้อยู่ในวงเล็บแล้วคั่นด้วยคอมม่า ซึ่งเรียกรวมๆว่า tuples
หมายเหตุ:: ฟังก์ชัน fst กับ snd สามารถใช้ได้แค่กับคู่ข้อมูล pair ได้เท่านั้น ไม่สามารถใช้กับ tuple ที่มีตั้งแต่ 3 ค่าได้
exercise 3.2 จงใช้ ฟังก์ชัน fst และ snd เพื่อดึงข้อมูลในแต่ละค่าที่เก็บอยู่ใน tuple นี้ ((1,’a'),”foo”)

– ดึงค่า 1
Prelude> fst ( fst ((1,’a'),”foo”) )
1

– ดึงค่า ‘a’
Prelude> snd ( fst ((1,’a'),”foo”) )
‘a’

– ดึงค่า “foo”
Prelude> snd ( snd ((1,’a'),”foo”) )
“foo”

ข้อมูลอ้างอิงจาก

Yet Another Haskell Tutorial http://darcs.haskell.org/yaht/yaht.pdf