खोज…
वाक्य - विन्यास
[] // एक खाली सूची।
सिर :: पूंछ // एक निर्माण सेल, जो एक तत्व, सिर और एक सूची है, पूंछ। :: विपक्ष ऑपरेटर कहा जाता है।
चलो सूची 1 = [1; 2; 3] // एक अर्धविराम के उपयोग पर ध्यान दें।
सूची 2 = 0 :: सूची 1 // परिणाम [0 है; 1; 2; 3]
सूची 3 = सूची 1 @ सूची 2 // परिणाम [1] है; 2; 3; 0; 1; 2; ३]। @ परिशिष्ट परिचालक है।
चलो सूची 4 = [1..3] // परिणाम है [1; 2; 3]
चलो सूची 5 = [1..2..10] // परिणाम है [1; 3; 5; 7; 9]
चलो सूची 6 = [के लिए मैं में 1..10 करते हैं अगर मैं% 2 = 1 तो उपज मैं] // परिणाम [1 है; 3; 5; 7; 9]
मूल सूची उपयोग
let list1 = [ 1; 2 ]
let list2 = [ 1 .. 100 ]
// Accessing an element
printfn "%A" list1.[0]
// Pattern matching
let rec patternMatch aList =
match aList with
| [] -> printfn "This is an empty list"
| head::tail -> printfn "This list consists of a head element %A and a tail list %A" head tail
patternMatch tail
patternMatch list1
// Mapping elements
let square x = x*x
let list2squared = list2
|> List.map square
printfn "%A" list2squared
एक सूची में संख्याओं की कुल राशि की गणना
पुनरावृत्ति द्वारा
let rec sumTotal list =
match list with
| [] -> 0 // empty list -> return 0
| head :: tail -> head + sumTotal tail
उपरोक्त उदाहरण कहता है: " list , क्या यह खाली है? वापसी 0. अन्यथा यह एक गैर-रिक्त सूची है। इसलिए यह [1] , [1; 2] , [1; 2; 3] आदि हो सकता है। यदि list [1] है तो चर head को 1 और tail को [] head + sumTotal tail और फिर head + sumTotal tail निष्पादित करें।
उदाहरण निष्पादन:
sumTotal [1; 2; 3]
// head -> 1, tail -> [2; 3]
1 + sumTotal [2; 3]
1 + (2 + sumTotal [3])
1 + (2 + (3 + sumTotal [])) // sumTotal [] is defined to be 0, recursion stops here
1 + (2 + (3 + 0)))
1 + (2 + 3)
1 + 5
6
कार्यात्मक पैटर्न का उपयोग करके उपरोक्त पैटर्न को संक्षिप्त करने का एक अधिक सामान्य तरीका है! sumTotal यह हो जाता है:
let sumTotal list = List.fold (+) 0 list
सूचियाँ बनाना
सूची बनाने का एक तरीका अर्धविराम द्वारा अलग किए गए दो वर्ग कोष्ठक में तत्वों को रखना है। तत्वों का प्रकार समान होना चाहिए।
उदाहरण:
> let integers = [1; 2; 45; -1];;
val integers : int list = [1; 2; 45; -1]
> let floats = [10.7; 2.0; 45.3; -1.05];;
val floats : float list = [10.7; 2.0; 45.3; -1.05]
जब किसी सूची में कोई तत्व नहीं है, तो वह खाली है। एक खाली सूची इस प्रकार घोषित की जा सकती है:
> let emptyList = [];;
val emptyList : 'a list
अन्य उदाहरण
बाइट की एक सूची बनाने के लिए, केवल पूर्णांक बनाने के लिए:
> let bytes = [byte(55); byte(10); byte(100)];;
val bytes : byte list = [55uy; 10uy; 100uy]
पहले से परिभाषित एक प्रकार के तत्वों के कार्यों की सूचियों को परिभाषित करना भी संभव है, एक वर्ग की वस्तुओं आदि।
उदाहरण
> type number = | Real of float | Integer of int;;
type number =
| Real of float
| Integer of int
> let numbers = [Integer(45); Real(0.0); Integer(127)];;
val numbers : number list = [Integer 45; Real 0.0; Integer 127]
सीमाओं
कुछ विशेष प्रकार के तत्वों के लिए (int, float, char, ...), निम्न टेम्पलेट का उपयोग करके प्रारंभ तत्व और अंतिम तत्व द्वारा एक सूची को परिभाषित करना संभव है:
[start..end]
उदाहरण:
> let c=['a' .. 'f'];;
val c : char list = ['a'; 'b'; 'c'; 'd'; 'e'; 'f']
let f=[45 .. 60];;
val f : int list =
[45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56; 57; 58; 59; 60]
आप निम्न मॉडल के साथ कुछ प्रकारों के लिए एक कदम भी निर्दिष्ट कर सकते हैं:
[start..step..end]
उदाहरण:
> let i=[4 .. 2 .. 11];;
val i : int list = [4; 6; 8; 10]
> let r=[0.2 .. 0.05 .. 0.28];;
val r : float list = [0.2; 0.25]
जनक
एक सूची बनाने का दूसरा तरीका जनरेटर का उपयोग करके इसे स्वचालित रूप से उत्पन्न करना है।
हम निम्नलिखित में से एक मॉडल का उपयोग कर सकते हैं:
[for <identifier> in range -> expr]
या
[for <identifier> in range do ... yield expr]
उदाहरण
> let oddNumbers = [for i in 0..10 -> 2 * i + 1];; // odd numbers from 1 to 21
val oddNumbers : int list = [1; 3; 5; 7; 9; 11; 13; 15; 17; 19; 21]
> let multiples3Sqrt = [for i in 1..27 do if i % 3 = 0 then yield sqrt(float(i))];; //sqrt of multiples of 3 from 3 to 27
val multiples3Sqrt : float list =
[1.732050808; 2.449489743; 3.0; 3.464101615; 3.872983346; 4.242640687; 4.582575695; 4.898979486; 5.196152423]
ऑपरेटर्स
कुछ ऑपरेटरों का उपयोग सूचियों के निर्माण के लिए किया जा सकता है:
विपक्ष ऑपरेटर ::
यह ऑपरेटर :: किसी सूची में एक मुख्य तत्व जोड़ने के लिए उपयोग किया जाता है:
> let l=12::[] ;;
val l : int list = [12]
> let l1=7::[14; 78; 0] ;;
val l1 : int list = [7; 14; 78; 0]
> let l2 = 2::3::5::7::11::[13;17] ;;
val l2 : int list = [2; 3; 5; 7; 11; 13; 17]
कड़ी
सूचियों का संघटन ऑपरेटर @ के साथ किया जाता है।
> let l1 = [12.5;89.2];;
val l1 : float list = [12.5; 89.2]
> let l2 = [1.8;7.2] @ l1;;
val l2 : float list = [1.8; 7.2; 12.5; 89.2]