F# For Dummys – Day 15 Collections Set

Today we learn Set, an immutable collection that automatically ensures all its elements are unique and sorted

Create Set

Using set notation

 let numberSet = set [1; 3; 5; 4; 2; 3]
 printfn “numberSet: %A” numberSet // numberSet: set [1; 2; 3; 4; 5]

from List

 let fruits = Set.ofList [“apple”; “banana”; “orange”; “apple”]
 printfn “Fruits: %A” fruits

Set.empty create an empty Set

 let emptySet = Set.empty
 printfn “emptySet: %A” emptySet // emptySet: set []

Get element not support

 let fruits = Set.ofList [“apple”; “banana”; “orange”]
 printfn “Fruits first element: %A” fruits.[0]

raise Error: The type ‘Set<_>’ does not define the field, constructor or member ‘Item’

Add/Remove element

Set.add
Returns a new set with an element added to the set. No exception is raised if the set already contains the given element

 let set = Set.empty.Add(1).Add(1).Add(2)
 printfn $”The new set is: {set}”

Set.remove
Returns a new set with the given element removed. No exception is raised if the set doesn’t contain the given element

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $”The set without 1 is {Set.remove 1 set}” // The set without 1 is set [2; 3]
 printfn $”The set without 1 is {Set.remove 4 set}” // The set without 1 is set [1; 2; 3]

we can see set itself didn’t change after remove 1

Loop Set

for … in

let fruits = Set.ofList [“apple”; “banana”; “orange”; “grape”]

for fruit in fruits do
printfn “Fruit: %s” fruit

Set.iter
Applies the given function to each element of the set, in order according to the comparison function

 let set = Set.empty.Add(1).Add(2).Add(3)
 Set.iter (fun x -> printfn $”The set contains {x}”) set

Element operation

Contains
syntax: Set.Contains element set
Evaluates to “true” if the given element is in the given set

 let set = Set.empty.Add(2).Add(3)
 printfn $”Does the set contain 1? {Set.contains 1 set}” // Does the set contain 1? false

use Instance Member Function

 let set = Set.empty.Add(2).Add(3)
 printfn $”Does the set contain 1? {set.Contains(1)}”  // Does the set contain 1? false

exists
syntax: Set.exists predicate set
Tests if any element of the collection satisfies the given predicate

 let set = Set.empty.Add(1).Add(2).Add(3)
 printfn $”Does the set contain even number? {Set.exists (fun x -> x % 2 = 0) set}” // Does the set contain even number? true

filter
syntax: Set.filter predicate set
Returns a new collection containing only the elements of the collection for which the given predicate returns True

 let set = Set.empty.Add(1).Add(2).Add(3).Add(4)
 printfn $”The set with even numbers is {Set.filter (fun x -> x % 2 = 0) set}” // The set with even numbers is set [2; 4]

Set operation

Lucy and Lily having breakfast:
Lucy have milk, boiled egg and sausages, Lily have milk, bacon and fried egg,
we can define their food list by 2 Sets: set [“milk”, “boiled egg”, “sausages”], set [“milk”, “bacon”, “fried egg”]

union
union is all the elements in 2 Sets

 let LucyBreakfastSet = set [“milk”; “boiled egg”; “sausages”]
 let LilyBreakfastSet = set [“milk”; “bacon”; “fried egg”]
 printfn $”The union of {LucyBreakfastSet} and {LilyBreakfastSet} is {(Set.union LucyBreakfastSet LilyBreakfastSet)}”

the union is expected to be “milk”, “boiled egg”, “sausages”, “bacon”, “fried egg”
results: The union of set [boiled egg; milk; sausages] and set [bacon; fried egg; milk] is set [bacon; boiled egg; fried egg; milk; sausages]

intersect
Computes the intersection of the two sets, the common elements they share

 let LucyBreakfastSet = set [“milk”; “boiled egg”; “sausages”]
 let LilyBreakfastSet = set [“milk”; “bacon”; “fried egg”]
 printfn $”The intersect of {LucyBreakfastSet} and {LilyBreakfastSet} is {(Set.intersect LucyBreakfastSet LilyBreakfastSet)}”

the intersect is expected to be “milk”
results: The intersect of set [boiled egg; milk; sausages] and set [bacon; fried egg; milk] is set [milk]

difference
difference returns a new set with the elements of the second set removed from the first set, which is the left colored part in the picture (A left B right)

if we put Lucy’s breakfast in the first place

 let LucyBreakfastSet = set [“milk”; “boiled egg”; “sausages”]
 let LilyBreakfastSet = set [“milk”; “bacon”; “fried egg”]
 printfn $”The difference of {LucyBreakfastSet} and {LilyBreakfastSet} is {(Set.difference LucyBreakfastSet LilyBreakfastSet)}”

we got “boiled egg”; “sausages”
result: The difference of set [boiled egg; milk; sausages] and set [bacon; fried egg; milk] is set [boiled egg; sausages]
Set.difference LucyBreakfastSet LilyBreakfastSet is equivalent to LucyBreakfastSet – LilyBreakfastSet
we can understand like this: remove the food Lily also had in Lucy’s food

 let LucyBreakfastSet = set [“milk”; “boiled egg”; “sausages”]
 let LilyBreakfastSet = set [“milk”; “bacon”; “fried egg”]
 printfn $”The difference of {LucyBreakfastSet} and {LilyBreakfastSet} is {(LucyBreakfastSet – LilyBreakfastSet)}”