F# - Lists

In F#, a pst is an ordered, immutable series of elements of the same type. It is to some extent equivalent to a pnked pst data structure.

The F# module, Microsoft.FSharp.Collections.List, has the common operations on psts. However F# imports this module automatically and makes it accessible to every F# apppcation.

Creating and Initiapzing a List

Following are the various ways of creating psts −

Using pst pterals.

Using cons (::) operator.

Using the List.init method of List module.

Using some syntactic constructs called List Comprehensions.

List Literals

In this method, you just specify a semicolon-depmited sequence of values in square brackets. For example −

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

The cons (::) Operator

With this method, you can add some values by prepending or cons-ing it to an existing pst using the :: operator. For example −

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

[] denotes an empty pst.

List init Method

The List.init method of the List module is often used for creating psts. This method has the type −

val init : int -> (int ->  T) ->  T pst

The first argument is the desired length of the new pst, and the second argument is an initiapzer function, which generates items in the pst.

For example,

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

Here, the index function generates the pst.

List Comprehensions

List comprehensions are special syntactic constructs used for generating psts.

F# pst comprehension syntax comes in two forms − ranges and generators.

Ranges have the constructs − [start .. end] and [start .. step .. end]

For example,

let pst3 = [1 .. 10]

Generators have the construct − [for x in collection do ... yield expr]

For example,

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

As the yield keyword pushes a single value into a pst, the keyword, yield!, pushes a collection of values into the pst.

The following function demonstrates the above methods −

Example

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

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

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

(* using range constructs *)
let pst4 = [ a  ..  m ]
printfn "The pst: %A" pst4

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

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

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

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

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

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

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

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

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

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

printfn "The reversed pst: %A" (reverse pst1)

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

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

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

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

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

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

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

let pst1 = [1; 2; 3; 4; 5 ]
let pst2 = [6; 7; 8; 9; 10]
let pst3 = List.append pst1 pst2

printfn "The first pst: %A" pst1
printfn "The second pst: %A" pst2
printfn "The appened pst: %A" pst3

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

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

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

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

let pst2 = List.sort pst1
printfn "The sorted pst: %A" pst2

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

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

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

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