# F# List

In this article, we show how to work with a List collection in F#.

A list is an ordered, immutable series of elements of the same type.

```let vals = [ 1; 2; 3; 4; 5 ]
```

A list can be created using a list literal. A list literal consists of elements separated with semicolons inside a pair of square brackets.

```let vals = [
1
2
3
4
5
]
```

In an alternative syntax, the semicolons are optional.

## F# List simple example

The following is a simple list example.

main.fsx
```let vals = [ 1; 2; 3; 4; 5; 6 ]

printfn "%A" vals
printfn "%d" vals.Length
printfn "%A" vals.Tail
```

We have a list of integers. We print the contents of the list, its head, size, and tail.

```let vals = [ 1; 2; 3; 4; 5; 6 ]
```

We define a list of integers with an array literal.

```printfn "%A" vals
```

With the `%A` format specifier, we pretty-print the list.

```printfn "%d" vals.Head
```

With the `Head` property, we print the first element of the list.

```printfn "%d" vals.Length
```

We get the size of a list with `Length`.

```printfn "%A" vals.Tail
```

With `Tail`, we get all but first elements of the list.

```λ dotnet fsi main.fsx
[1; 2; 3; 4; 5; 6]
1
6
[2; 3; 4; 5; 6]
```

## F# List iteration

In the next example, we loop over the elements of a list.

main.fsx
```let vals = [ 1; 2; 3; 4; 5; 6 ]

vals |> List.iter (printfn "%d")

printfn "------------------------"

for e in vals do
printfn "%d" e
```

We provide two basic ways of iteration.

```vals |> List.iter (printfn "%d")
```

The `List.iter` is the functional way of looping over list elements.

```for e in vals do
printfn "%d" e
```

The classic, imperative way is via a for loop.

```λ dotnet fsi main.fsx
1
2
3
4
5
6
------------------------
1
2
3
4
5
6
```

## F# List indexes

List elements are accessed through their indexes.

main.fsx
```let words = ["pen"; "cup"; "dog"; "person";

let w1 = List.item 1 words
printfn "%s" w1

let w2 = words
printfn "%s" w2

let i1 = List.findIndex(fun e -> e = "cup") words
printfn \$"The first index of cup is {i1}"

let i2 = List.findIndexBack(fun e -> e = "cup") words
printfn \$"The last index of cup is {i2}"
```

The program contains List indexing operations.

```let w1 = List.item 1 words
```

We get the second item of the list with `List.item`.

```let w2 = words
```

We can also use the classic C style syntax.

```let i1 = List.findIndex(fun e -> e = "cup") words
```

Fith `List.findIndex`, we find the first element that satisfies the given predicate function.

```let i2 = List.findIndexBack(fun e -> e = "cup") words
```

Fith `List.findIndexBack`, we find the last element that satisfies the given predicate function.

```λ dotnet fsi main.fsx
cup
pen
The first index of cup is 1
The last index of cup is 7
```

## F# List.map

The `List.map` function applies the given function to each of the elements of the collection.

main.fsx
```let vals = [1..10]

let res = List.map(fun e -> e * 2) vals
printfn "%A" res
```

We apply a map function on a list of integers.

```let vals = [ 1 .. 10]
```

We define a list with a range operator.

```let res = List.map(fun e -> e * 2) vals
```

Each of the elements of the list is multiplied by 2. The result is assigned to the `res` variable.

```λ dotnet fsi main.fsx
[2; 4; 6; 8; 10; 12; 14; 16; 18; 20]
```

## F# List.filter

We can filter list elements with `List.filter`.

main.fsx
```let vals = [-3; -2; 0; 1; -5; 7; 9]
let words = ["sky"; "war"; "rock"; "ocean"; "cloud"; "water"]

let pos = List.filter(fun e -> e > 0) vals
printfn "%A" pos

let res = List.filter(fun (e:string) -> e.StartsWith("w")) words
printfn "%A" res
```

In the program, we find out all positive numbers from a list of integers and all strings which start with 'w' in a list of words.

```let pos = List.filter(fun e -> e > 0) vals
```

The `List.filter` function takes a predicate function. All elements must satisfy the given predicate.

```let res = List.filter(fun (e:string) -> e.StartsWith("w")) words
```

Sometines, it is necessary to help the compiler with an explicity type definition.

```λ dotnet fsi main.fsx
[1; 7; 9]
["war"; "water"]
```

## F# merging lists

With the `@` operator, we can merge two lists.

main.fsx
```let a = [1; 2; 3; 4]
let b = [4; 4; 5; 6]

let merged = a @ b |> List.distinct
printfn "%A" merged

let merged2 = a @ b
printfn "%A" merged2
```

The program merges two lists.

```let merged = a @ b |> List.distinct
```

We merge two lists and pass the values to `List.distinct`, which removes duplicates.

```let merged2 = a @ b
```

We merge two lists; we have all values, including duplicates.

```λ dotnet fsi main.fsx
[1; 2; 3; 4; 5; 6]
[1; 2; 3; 4; 4; 4; 5; 6]
```

## F# sort List of integers

In the next example, we sort integers.

main.fsx
```let nums = [ -1; 6; -2; 3; 0; -4; 5; 1; 2 ]

nums |> List.sort |> printfn "%A"
nums |> List.sortDescending |> printfn "%A"

nums |> List.sortBy (abs) |> printfn "%A"
nums |> List.sortByDescending (abs) |> printfn "%A"
```

We have a list of integers. We sort them with `List.sort` and `List.sortDescending`.

```nums |> List.sortBy (abs) |> printfn "%A"
nums |> List.sortByDescending (abs) |> printfn "%A"
```

With the help of the `abs`, we sort integers regarless of their sign.

```λ dotnet fsi main.fsx
[-4; -2; -1; 0; 1; 2; 3; 5; 6]
[6; 5; 3; 2; 1; 0; -1; -2; -4]
[0; -1; 1; -2; 2; 3; -4; 5; 6]
[6; 5; -4; 3; -2; 2; -1; 1; 0]
```

## F# sort List of records

In the next example, we sort a list of records.

main.fsx
```type User =
{ Name: string
Occupation: string
Salary: int }

let users =
[ { Name = "John Doe"
Occupation = "gardener"
Salary = 1280 }
{ Name = "Roger Roe"
Occupation = "driver"
Salary = 860 }
{ Name = "Tom Brown"
Occupation = "shopkeeper"
Salary = 990 } ]

users
|> List.sortBy (fun u -> u.Salary)
|> List.iter (fun u -> printfn "%A" u)

printfn "--------------------------------"

users
|> List.sortByDescending (fun u -> u.Occupation)
|> List.iter (fun u -> printfn "%A" u)
```

The program contains a list of `User` records. We sort the users by their salaries and occupation.

```users
|> List.sortBy (fun u -> u.Salary)
|> List.iter (fun u -> printfn "%A" u)
```

The users are sorted by salaries in ascending order with `List.sortBy`.

```users
|> List.sortByDescending (fun u -> u.Occupation)
|> List.iter (fun u -> printfn "%A" u)
```

Here, the users are sorted by their occupation in descending order with `sortByDescending`.

```λ dotnet fsi main.fsx
{ Name = "Roger Roe"
Occupation = "driver"
Salary = 860 }
{ Name = "Tom Brown"
Occupation = "shopkeeper"
Salary = 990 }
{ Name = "John Doe"
Occupation = "gardener"
Salary = 1280 }
--------------------------------
{ Name = "Tom Brown"
Occupation = "shopkeeper"
Salary = 990 }
{ Name = "John Doe"
Occupation = "gardener"
Salary = 1280 }
{ Name = "Roger Roe"
Occupation = "driver"
Salary = 860 }
```

## F# List comprehension

List comprehension is a powerful syntax to generate lists. List comprehensions provide a concise way to create lists.

In F#, we can create list comprehensions with ranges and generators.

main.fsx
```let vals = [ -1; 0; 2; -2; 1; 3; 4; -6 ]

let pos =
[ for e in vals do
if e > 0 then yield e ]

printfn "%A" pos

printfn "---------------------------------"

[ for e in 1 .. 100 -> e * e ] |> printfn "%A"

printfn "---------------------------------"

[ for a in 1 .. 100 do
if a % 3 = 0 && a % 5 = 0 then yield a] |> printfn "%A"

printfn "---------------------------------"

let vals3 =
[ for x in 1 .. 3 do
for y in 1 .. 10 -> x, y ]

printfn "%A" vals3
```

In F#, list comprehensions use for loops, if conditions and the yield keyword.

```let vals = [ -1; 0; 2; -2; 1; 3; 4; -6 ]

let pos =
[ for e in vals do
if e > 0 then yield e ]
```

We have a list of values. A new list is constructed with a list comprehension. It contains only positive values.

```[ for e in 1 .. 100 -> e * e ] |> printfn "%A"
```

We can use ranges in list comprehensions.

```[ for a in 1 .. 100 do
if a % 3 = 0 && a % 5 = 0 then yield a] |> printfn "%A"
```

Here we use two if conditions.

```let vals3 =
[ for x in 1 .. 3 do
for y in 1 .. 10 -> x, y ]
```

Also, it is possible to use two for loops.

```λ dotnet fsi main.fsx
[2; 1; 3; 4]
---------------------------------
[1; 4; 9; 16; 25; 36; 49; 64; 81; 100; 121; 144; 169; 196; 225; 256; 289; 324;
361; 400; 441; 484; 529; 576; 625; 676; 729; 784; 841; 900; 961; 1024; 1089;
1156; 1225; 1296; 1369; 1444; 1521; 1600; 1681; 1764; 1849; 1936; 2025; 2116;
2209; 2304; 2401; 2500; 2601; 2704; 2809; 2916; 3025; 3136; 3249; 3364; 3481;
3600; 3721; 3844; 3969; 4096; 4225; 4356; 4489; 4624; 4761; 4900; 5041; 5184;
5329; 5476; 5625; 5776; 5929; 6084; 6241; 6400; 6561; 6724; 6889; 7056; 7225;
7396; 7569; 7744; 7921; 8100; 8281; 8464; 8649; 8836; 9025; 9216; 9409; 9604;
9801; 10000]
---------------------------------
[15; 30; 45; 60; 75; 90]
---------------------------------
[(1, 1); (1, 2); (1, 3); (1, 4); (1, 5); (1, 6); (1, 7); (1, 8); (1, 9); (1, 10);
(2, 1); (2, 2); (2, 3); (2, 4); (2, 5); (2, 6); (2, 7); (2, 8); (2, 9); (2, 10);
(3, 1); (3, 2); (3, 3); (3, 4); (3, 5); (3, 6); (3, 7); (3, 8); (3, 9); (3, 10)]
```