F # - รายการ

ใน F # รายการคือชุดขององค์ประกอบประเภทเดียวกันที่เรียงลำดับและไม่เปลี่ยนรูป มีขอบเขตเทียบเท่ากับโครงสร้างข้อมูลรายการที่เชื่อมโยง

โมดูล F # Microsoft.FSharp.Collections.List,มีการดำเนินการทั่วไปในรายการ อย่างไรก็ตาม F # จะนำเข้าโมดูลนี้โดยอัตโนมัติและทำให้ทุกแอปพลิเคชัน F # สามารถเข้าถึงได้

การสร้างและเริ่มต้นรายการ

ต่อไปนี้เป็นวิธีต่างๆในการสร้างรายการ -

• การใช้รายการ literals.

• การใช้ cons (: :) ตัวดำเนินการ

• ใช้ List.init วิธีการของโมดูลรายการ

• ใช้ syntactic constructs เรียกว่า List Comprehensions.

แสดงรายการตัวอักษร

ในวิธีนี้คุณเพียงระบุลำดับค่าที่คั่นด้วยอัฒภาคในวงเล็บเหลี่ยม ตัวอย่างเช่น -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

ข้อเสีย (: :) Operator

ด้วยวิธีนี้คุณสามารถเพิ่มค่าบางอย่างได้โดยการเติมเงินล่วงหน้าหรือ cons-ingไปยังรายการที่มีอยู่โดยใช้ตัวดำเนินการ :: ตัวอย่างเช่น -

let list2 = 1::2::3::4::5::6::7::8::9::10::[];;

[] หมายถึงรายการว่าง

วิธีเริ่มรายการ

เมธอด List.init ของโมดูลรายการมักใช้ในการสร้างรายการ วิธีนี้มีประเภท -

val init : int -> (int -> 'T) -> 'T list

อาร์กิวเมนต์แรกคือความยาวที่ต้องการของรายการใหม่และอาร์กิวเมนต์ที่สองคือฟังก์ชัน initializer ซึ่งสร้างรายการในรายการ

ตัวอย่างเช่น,

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

ที่นี่ฟังก์ชันดัชนีจะสร้างรายการ

แสดงรายการความเข้าใจ

ความเข้าใจในรายการเป็นโครงสร้างทางวากยสัมพันธ์พิเศษที่ใช้ในการสร้างรายการ

ไวยากรณ์ความเข้าใจของรายการ F # มีสองรูปแบบ - ช่วงและตัวสร้าง

ช่วงมีโครงสร้าง - [start .. end] และ [start .. step .. end]

ตัวอย่างเช่น,

let list3 = [1 .. 10]

เครื่องกำเนิดไฟฟ้ามีโครงสร้าง - [สำหรับ x ในคอลเลกชันทำ ... อัตราผลตอบแทน]

ตัวอย่างเช่น,

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

ในฐานะที่เป็น yield คำหลักผลักค่าเดียวลงในรายการคำหลัก yield!, ผลักดันคอลเลกชันของค่าลงในรายการ

ฟังก์ชันต่อไปนี้แสดงให้เห็นถึงวิธีการข้างต้น -

ตัวอย่าง

(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1

(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2

(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3

(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4

(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5

(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6

(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7

(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]

คุณสมบัติของประเภทข้อมูลรายการ

ตารางต่อไปนี้แสดงคุณสมบัติต่างๆของชนิดข้อมูลรายการ -

ทรัพย์สิน	ประเภท	คำอธิบาย
ศีรษะ	'ท	องค์ประกอบแรก
ว่างเปล่า	รายการ 'T	คุณสมบัติคงที่ที่ส่งคืนรายการว่างของชนิดที่เหมาะสม
มันว่างเปล่า	บูล	true หากรายการไม่มีองค์ประกอบ
สิ่งของ	'ท	องค์ประกอบที่ดัชนีที่ระบุ (อิงศูนย์)
ความยาว	int	จำนวนองค์ประกอบ
หาง	รายการ 'T	รายการที่ไม่มีองค์ประกอบแรก

ตัวอย่างต่อไปนี้แสดงการใช้คุณสมบัติเหล่านี้ -

ตัวอย่าง

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]

// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4

ตัวดำเนินการพื้นฐานในรายการ

ตารางต่อไปนี้แสดงการดำเนินการพื้นฐานเกี่ยวกับชนิดข้อมูลรายการ -

มูลค่า	คำอธิบาย
ผนวก: 'T list →' T list → 'T list	ส่งคืนรายการใหม่ที่มีองค์ประกอบของรายการแรกตามด้วยองค์ประกอบของรายการที่สอง
ค่าเฉลี่ย: รายการ T → ^ T	ส่งคืนค่าเฉลี่ยขององค์ประกอบในรายการ
averageBy: ('T → ^ U) →' T list → ^ U	ส่งกลับค่าเฉลี่ยขององค์ประกอบที่สร้างขึ้นโดยใช้ฟังก์ชันกับแต่ละองค์ประกอบของรายการ
เลือก: ('T →' ตัวเลือก U) → 'T list →' รายการ U	ใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของรายการ ส่งคืนรายการที่ประกอบด้วยผลลัพธ์สำหรับแต่ละองค์ประกอบที่ฟังก์ชันส่งคืนSome.
รวบรวม: ('T →' รายการ U) → 'T รายการ→' รายการ U	สำหรับแต่ละองค์ประกอบของรายการให้ใช้ฟังก์ชันที่กำหนด เชื่อมต่อผลลัพธ์ทั้งหมดและส่งคืนรายการที่รวมกัน
concat: seq <'T list> →' T list	ส่งคืนรายการใหม่ที่มีองค์ประกอบของแต่ละรายการตามลำดับ
ว่างเปล่า: รายการ T	ส่งคืนรายการว่างของประเภทที่กำหนด
มีอยู่: ('T → bool) →' T list → bool	ทดสอบว่าองค์ประกอบใดของรายการตรงตามเพรดิเคตที่กำหนดหรือไม่
มีอยู่ 2: ('T1 →' T2 →บูล) → 'รายการ T1 →' รายการ T2 →บูล	ทดสอบว่าคู่ขององค์ประกอบที่เกี่ยวข้องของรายการตรงตามเพรดิเคตที่กำหนดหรือไม่
ฟิลเตอร์: ('T → bool) →' T list → 'T list	ส่งคืนคอลเล็กชันใหม่ที่มีเฉพาะองค์ประกอบของคอลเล็กชันที่เพรดิเคตที่ระบุส่งคืน true.
ค้นหา: ('T → bool) →' T list → 'T	ส่งคืนองค์ประกอบแรกที่ฟังก์ชันที่กำหนดส่งคืน true.
findIndex: ('T → bool) →' T list → int	ส่งคืนดัชนีขององค์ประกอบแรกในรายการที่ตรงตามเพรดิเคตที่กำหนด
พับ: ('State →' T → 'State) →' State → 'T list →' State	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ฟังก์ชันนี้รับอาร์กิวเมนต์ที่สองและใช้ฟังก์ชันกับมันและองค์ประกอบแรกของรายการ จากนั้นจะส่งผ่านผลลัพธ์นี้ไปยังฟังก์ชันพร้อมกับองค์ประกอบที่สองและอื่น ๆ สุดท้ายก็ส่งกลับผลลัพธ์สุดท้าย หากฟังก์ชันอินพุตคือ f และองค์ประกอบคือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f (... (fs i0) i1 ... ) iN
fold2: ('State →' T1 → 'T2 →' State) → 'State →' T1 list → 'T2 list →' State	ใช้ฟังก์ชันกับองค์ประกอบที่สอดคล้องกันของสองคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ คอลเล็กชันต้องมีขนาดเท่ากัน หากฟังก์ชันอินพุตเป็น f และองค์ประกอบคือ i0 ... iN และ j0 ... jN ฟังก์ชันนี้จะคำนวณ f (... (fs i0 j0) ... ) iN jN
foldBack: ('T →' State → 'State) →' T list → 'State →' State	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ถ้าฟังก์ชันอินพุต isf และอิลิเมนต์คือ i0 ... iN ให้คำนวณ f i0 (... (f iN s))
foldBack2: ('T1 →' T2 → 'รัฐ→' ​​รัฐ) → 'รายการ T1 →' รายการ T2 → 'รัฐ→' ​​รัฐ	ใช้ฟังก์ชันกับองค์ประกอบที่สอดคล้องกันของสองคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ คอลเล็กชันต้องมีขนาดเท่ากัน หากฟังก์ชันอินพุตคือ f และองค์ประกอบคือ i0 ... iN และ j0 ... jN ฟังก์ชันนี้จะคำนวณ f i0 j0 (... (f iN jN s))
forall: ('T → bool) →' T list → bool	ทดสอบว่าองค์ประกอบทั้งหมดของคอลเล็กชันตรงตามเพรดิเคตที่กำหนดหรือไม่
forall2: ('T1 →' T2 → bool) → 'รายการ T1 →' รายการ T2 →บูล	ทดสอบว่าองค์ประกอบที่เกี่ยวข้องทั้งหมดของคอลเลกชันตรงตามเพรดิเคตที่กำหนดหรือไม่
หัว: 'T list →' T	ส่งคืนองค์ประกอบแรกของรายการ
init: int → (int → 'T) →' รายการ T	สร้างรายการโดยเรียกตัวสร้างที่กำหนดในแต่ละดัชนี
isEmpty: 'T list → bool	ผลตอบแทน true หากรายการไม่มีองค์ประกอบ false มิฉะนั้น.
iter: ('T →หน่วย) →' T รายการ→หน่วย	ใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของคอลเล็กชัน
iter2: ('T1 →' T2 →หน่วย) → 'รายการ T1 →' รายการ T2 →หน่วย	ใช้ฟังก์ชันที่กำหนดกับสองคอลเลกชันพร้อมกัน คอลเลกชันต้องมีขนาดเท่ากัน
iteri: (int → 'T →หน่วย) →' T รายการ→หน่วย	ใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของคอลเล็กชัน จำนวนเต็มที่ส่งผ่านไปยังฟังก์ชันบ่งชี้ดัชนีขององค์ประกอบ
iteri2: (int → 'T1 →' T2 → unit) → 'T1 list →' T2 list → unit	ใช้ฟังก์ชันที่กำหนดกับสองคอลเลกชันพร้อมกัน คอลเลกชันต้องมีขนาดเท่ากัน จำนวนเต็มที่ส่งผ่านไปยังฟังก์ชันบ่งชี้ดัชนีขององค์ประกอบ
ความยาว: 'T list → int	ส่งกลับความยาวของรายการ
แผนที่: ('T →' U) → 'T list →' รายการ U	สร้างคอลเล็กชันใหม่ที่มีองค์ประกอบซึ่งเป็นผลลัพธ์ของการใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของคอลเล็กชัน
map2: ('T1 →' T2 → 'U) →' รายการ T1 → 'รายการ T2 →' รายการ U	สร้างคอลเล็กชันใหม่ที่มีองค์ประกอบเป็นผลลัพธ์ของการใช้ฟังก์ชันที่กำหนดกับองค์ประกอบที่เกี่ยวข้องของทั้งสองคอลเลคชันแบบคู่กัน
map3: ('T1 →' T2 → 'T3 →' U) → 'รายการ T1 →' รายการ T2 → 'รายการ T3 →' รายการ U	สร้างคอลเลกชันใหม่ที่มีองค์ประกอบเป็นผลมาจากการใช้ฟังก์ชันที่กำหนดกับองค์ประกอบที่เกี่ยวข้องของทั้งสามคอลเลกชันพร้อมกัน
mapi: (int → 'T →' U) → 'T list →' รายการ U	สร้างคอลเล็กชันใหม่ที่มีองค์ประกอบซึ่งเป็นผลลัพธ์ของการใช้ฟังก์ชันที่กำหนดกับแต่ละองค์ประกอบของคอลเล็กชัน ดัชนีจำนวนเต็มที่ส่งผ่านไปยังฟังก์ชันบ่งชี้ดัชนี (จาก 0) ขององค์ประกอบที่ถูกเปลี่ยน
mapi2: (int → 'T1 →' T2 → 'U) →' รายการ T1 → 'รายการ T2 →' รายการ U	เช่นเดียวกับ List.mapi แต่การแมปองค์ประกอบที่เกี่ยวข้องจากสองรายการที่มีความยาวเท่ากัน
สูงสุด: 'T list →' T	ส่งคืนองค์ประกอบที่ยิ่งใหญ่ที่สุดของรายการทั้งหมดโดยเปรียบเทียบโดยใช้ Operators.max
maxBy: ('T →' U) → 'T list →' T	ส่งคืนองค์ประกอบที่ยิ่งใหญ่ที่สุดของรายการทั้งหมดโดยเปรียบเทียบโดยใช้ Operators.max กับผลลัพธ์ของฟังก์ชัน
นาที: 'T list →' T	ส่งคืนค่าต่ำสุดขององค์ประกอบทั้งหมดของรายการเปรียบเทียบโดยใช้ Operators.min
minBy: ('T →' U) → 'T list →' T	ส่งคืนค่าต่ำสุดขององค์ประกอบทั้งหมดของรายการเปรียบเทียบโดยใช้ Operators.min กับผลลัพธ์ของฟังก์ชัน
ที่ n: 'T list → int →' T	ดัชนีลงในรายการ องค์ประกอบแรกมีดัชนี 0
ofArray: รายการ 'T [] →' T	สร้างรายการจากอาร์เรย์ที่กำหนด
ofSeq: seq <'T> →' T รายการ	สร้างรายการใหม่จากวัตถุที่ระบุได้
พาร์ติชัน: ('T → bool) →รายการ' T * 'T	แยกคอลเลกชันออกเป็นสองคอลเลกชันโดยมีองค์ประกอบที่เพรดิเคตส่งกลับ true และ false ตามลำดับ
อนุญาต: (int → int) → 'T list →' T list	ส่งคืนรายการที่มีองค์ประกอบทั้งหมดที่ปรับเปลี่ยนตามการเรียงสับเปลี่ยนที่ระบุ
เลือก: ('T →' ตัวเลือก U) → 'T list →' U	ใช้ฟังก์ชันที่กำหนดกับองค์ประกอบที่ต่อเนื่องส่งคืนผลลัพธ์แรกที่ฟังก์ชันส่งคืน Some เพื่อคุณค่าบางอย่าง
ลด: ('T →' T → 'T) →' T list → 'T	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ฟังก์ชันนี้ใช้ฟังก์ชันที่ระบุกับสององค์ประกอบแรกของรายการ จากนั้นจะส่งผลลัพธ์นี้ไปยังฟังก์ชันพร้อมกับองค์ประกอบที่สามและอื่น ๆ สุดท้ายก็ส่งกลับผลลัพธ์สุดท้าย หากฟังก์ชันอินพุตคือ f และองค์ประกอบคือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f (... (f i0 i1) i2 ... ) iN
ลดกลับ: ('T →' T → 'T) →' T list → 'T	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ หากฟังก์ชันอินพุต isf และองค์ประกอบคือ i0 ... iN ฟังก์ชันนี้จะคำนวณ f i0 (... (f iN-1 iN))
ทำซ้ำ: (int → 'T →' T รายการ)	สร้างรายการโดยเรียกตัวสร้างที่กำหนดในแต่ละดัชนี
rev: รายการ 'T →' T	ส่งคืนรายการใหม่ที่มีองค์ประกอบในลำดับย้อนกลับ
สแกน: ('State →' T → 'State) →' State → 'T list →' รายการสถานะ	ใช้ฟังก์ชันกับแต่ละองค์ประกอบของคอลเลกชันโดยทำเธรดอาร์กิวเมนต์ตัวสะสมผ่านการคำนวณ ฟังก์ชันนี้รับอาร์กิวเมนต์ที่สองและใช้ฟังก์ชันที่ระบุและองค์ประกอบแรกของรายการ จากนั้นจะส่งผลลัพธ์นี้ไปยังฟังก์ชันพร้อมกับองค์ประกอบที่สองและอื่น ๆ สุดท้ายจะส่งคืนรายการผลลัพธ์ระดับกลางและผลลัพธ์สุดท้าย
scanBack: ('T →' State → 'State) →' T list → 'State →' รายการสถานะ	เช่นเดียวกับ foldBack แต่ส่งกลับทั้งผลลัพธ์ขั้นกลางและผลลัพธ์สุดท้าย
เรียงลำดับ: รายการ 'T →' รายการ T	จัดเรียงรายการที่กำหนดโดยใช้ Operators.compare
sortBy: ('T →' Key) → 'T list →' T list	จัดเรียงรายการที่กำหนดโดยใช้คีย์ที่กำหนดโดยการฉายภาพที่กำหนด คีย์ถูกเปรียบเทียบโดยใช้ Operators.compare
sortWith: ('T →' T → int) → 'T list →' รายการ T	จัดเรียงรายการที่กำหนดโดยใช้ฟังก์ชันการเปรียบเทียบที่กำหนด
ผลรวม: ^ T รายการ→ ^ T	ส่งคืนผลรวมขององค์ประกอบในรายการ
sumBy: ('T → ^ U) →' T list → ^ U	ส่งกลับผลรวมของผลลัพธ์ที่สร้างขึ้นโดยใช้ฟังก์ชันกับแต่ละองค์ประกอบของรายการ
หาง: รายการ T →รายการ T	ส่งคืนรายการอินพุตที่ไม่มีองค์ประกอบแรก
toArray: 'T รายการ→' T []	สร้างอาร์เรย์จากรายการที่กำหนด
toSeq: 'T list → seq <' T>	ดูรายการที่กำหนดเป็นลำดับ
tryFind: ('T → bool) →' T list → 'ตัวเลือก T	ส่งคืนองค์ประกอบแรกที่ฟังก์ชันที่กำหนดส่งคืน true. กลับNone หากไม่มีองค์ประกอบดังกล่าว
tryFindIndex: ('T → bool) →' T list →ตัวเลือก int	ส่งคืนดัชนีขององค์ประกอบแรกในรายการที่ตรงตามเพรดิเคตที่กำหนด กลับNone หากไม่มีองค์ประกอบดังกล่าว
tryPick: (ตัวเลือก 'T →' U) → 'T list →' ตัวเลือก U	ใช้ฟังก์ชันที่กำหนดกับองค์ประกอบที่ต่อเนื่องส่งคืนผลลัพธ์แรกที่ฟังก์ชันส่งคืน Someเพื่อคุณค่าบางอย่าง หากไม่มีองค์ประกอบดังกล่าวให้ส่งคืนNone.
เปิดเครื่องรูด: ('T1 *' T2) รายการ→ 'รายการ T1 *' รายการ T2	แบ่งรายชื่อคู่ออกเป็นสองรายการ
unzip3: ('T1 *' T2 * 'T3) รายการ→' รายการ T1 * 'รายการ T2 *' รายการ T3	แบ่งรายชื่อสามรายการออกเป็นสามรายการ
zip: รายการ 'T1 →' รายการ T2 → ('T1 *' T2)	รวมสองรายการเป็นรายการคู่ ทั้งสองรายการต้องมีความยาวเท่ากัน
zip3: รายการ 'T1 →' รายการ T2 → 'รายการ T3 → (' T1 * 'T2 *' T3)	รวมสามรายการเป็นรายการสามเท่า รายการต้องมีความยาวเท่ากัน

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ฟังก์ชันข้างต้น -

ตัวอย่าง 1

โปรแกรมนี้แสดงการย้อนกลับรายการแบบวนซ้ำ -

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1

let reverse lt =
   let rec loop acc = function
      | [] -> acc
      | hd :: tl -> loop (hd :: acc) tl
   loop [] lt

printfn "The reversed list: %A" (reverse list1)

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

อย่างไรก็ตามคุณสามารถใช้ไฟล์ rev ฟังก์ชั่นของโมดูลเพื่อวัตถุประสงค์เดียวกัน -

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

ตัวอย่าง 2

โปรแกรมนี้แสดงการกรองรายการโดยใช้ List.filter วิธีการ -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

ตัวอย่างที่ 3

List.map วิธีการแมปรายการจากประเภทหนึ่งไปยังอีกประเภทหนึ่ง -

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]

ตัวอย่างที่ 4

List.append method และตัวดำเนินการ @ ต่อท้ายรายการหนึ่งเข้าด้วยกัน -

let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2

printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3

let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2

printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']

ตัวอย่างที่ 5

List.sortวิธีการจัดเรียงรายการ List.sum วิธีการให้ผลรวมขององค์ประกอบในรายการและ List.average วิธีการให้ค่าเฉลี่ยขององค์ประกอบในรายการ -

let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1

let list2 = List.sort list1
printfn "The sorted list: %A" list2

let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avg

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857

การดำเนินการ "พับ" ใช้ฟังก์ชันกับแต่ละองค์ประกอบในรายการรวมผลลัพธ์ของฟังก์ชันในตัวแปรตัวสะสมและส่งกลับตัวสะสมซึ่งเป็นผลมาจากการดำเนินการพับ

ตัวอย่างที่ 6

List.fold วิธีใช้ฟังก์ชันกับแต่ละองค์ประกอบจากซ้ายไปขวาในขณะที่ List.foldBack ใช้ฟังก์ชันกับแต่ละองค์ประกอบจากขวาไปซ้าย

let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])

เมื่อคุณคอมไพล์และรันโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.