Zoeken…
Syntaxis
[] // een lege lijst.
head :: tail // een constructiecel met een element, head en een lijst, tail. :: wordt de operator Cons genoemd.
let list1 = [1; 2; 3] // Let op het gebruik van een puntkomma.
laat list2 = 0 :: list1 // resultaat is [0; 1; 2; 3]
let list3 = list1 @ list2 // resultaat is [1; 2; 3; 0; 1; 2; 3]. @ is de append-operator.
let list4 = [1..3] // resultaat is [1; 2; 3]
let list5 = [1..2..10] // resultaat is [1; 3; 5; 7; 9]
laat list6 = [voor i in 1..10 doen als i% 2 = 1 dan levert i] // resultaat is [1; 3; 5; 7; 9]
Basislijstgebruik
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
De totale som van getallen in een lijst berekenen
Door recursie
let rec sumTotal list =
match list with
| [] -> 0 // empty list -> return 0
| head :: tail -> head + sumTotal tail
Het bovenstaande voorbeeld zegt: "Kijk naar de list , is deze leeg? Retourneer 0. Anders is het een niet-lege lijst. Het kan dus [1] , [1; 2] , [1; 2; 3] enz. Zijn. Als list [1] is, bind dan de variabele head aan 1 en tail aan [] en voer vervolgens head + sumTotal tail .
Voorbeeld uitvoering:
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
Een meer algemene manier om het bovenstaande patroon in te kapselen is door functionele vouwen te gebruiken! sumTotal wordt dit:
let sumTotal list = List.fold (+) 0 list
Lijsten maken
Een manier om een lijst te maken, is door elementen tussen twee vierkante haken te plaatsen, gescheiden door puntkomma's. De elementen moeten van hetzelfde type zijn.
Voorbeeld:
> 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]
Wanneer een lijst geen element heeft, is deze leeg. Een lege lijst kan als volgt worden gedeclareerd:
> let emptyList = [];;
val emptyList : 'a list
Ander voorbeeld
Om een lijst met bytes te maken, gewoon om de gehele getallen te casten:
> let bytes = [byte(55); byte(10); byte(100)];;
val bytes : byte list = [55uy; 10uy; 100uy]
Het is ook mogelijk om lijsten met functies, van elementen van een eerder gedefinieerd type, van objecten van een klasse, enz. Te definiëren.
Voorbeeld
> 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]
ranges
Voor bepaalde soorten elementen (int, float, char, ...) is het mogelijk om een lijst te definiëren op basis van het startelement en het eindelement, met behulp van de volgende sjabloon:
[start..end]
Voorbeelden:
> 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]
U kunt ook een stap opgeven voor bepaalde typen, met het volgende model:
[start..step..end]
Voorbeelden:
> 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]
Generator
Een andere manier om een lijst te maken is om deze automatisch te genereren met behulp van een generator.
We kunnen een van de volgende modellen gebruiken:
[for <identifier> in range -> expr]
of
[for <identifier> in range do ... yield expr]
Voorbeelden
> 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]
operators
Sommige operatoren kunnen worden gebruikt om lijsten samen te stellen:
Nadelen operator:
Deze operator :: wordt gebruikt om een head-element toe te voegen aan een lijst:
> 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]
Aaneenschakeling
De samenvoeging van lijsten wordt uitgevoerd met de operator @.
> 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]
