DEV Community: AllenZhu

F# For Dummys - Day 16 Collections Sequence

AllenZhu — Tue, 28 May 2024 11:01:54 +0000

Today we learn Sequence, represents an ordered, read-only series of elements

Why Sequence

Sequences are particularly useful when you have a large, ordered collection of data but do not necessarily expect to use all of the elements.
Individual sequence elements are computed on-demand, so a sequence can provide better performance than a list in situations in which not all the elements are used

What is computed on-demand
like buying a burger in KFC, the staff prepared 1000 burgers in the early morning, so you got your burger immediately, all the burgers are made before customer order, this is called eager evaluation

then you ordered a fried chicken, the staff replies: sorry, you have to wait for a minute, as we need to fry the chicken first, they only do the work when someone ordered, this is called lazy evaluation, also known as On-demand computation

Create Sequence

Explicitly specifying elements

let seq1 = seq [1; 2; 3; 4]
printfn "seq: %A" seq1

Using range expression

let seq1 = seq { 1 .. 10 } // from 1 to 10
printfn "seq: %A" seq1 // seq: seq [1; 2; 3; 4; ...]

use step in range expression

let seq1 = seq { 1 .. 2 .. 10 } // start from 1, add 2 each time
printfn "seq: %A" seq1 // seq: seq [1; 3; 5; 7; ...]

Using for loop

let seq1 = seq { for i in 1 .. 10 -> i }
printfn "seq: %A" seq1

ofList Views the given list as a sequence

let inputs = [ 1; 2; 5 ]
let seq1 = inputs |> Seq.ofList
printfn "seq: %A" seq1

ofArray

let inputs = [| 1; 2; 5 |]
let seq1 = inputs |> Seq.ofArray
printfn "seq: %A" seq1

Seq.initInfinite generate an infinite sequence

let infiniteSeq = Seq.initInfinite (fun i -> i * 2)
printfn "infiniteSeq %A" infiniteSeq

define a start for infinite sequence

let start = 5
let infiniteSeq = Seq.initInfinite (fun i -> i + start)
printfn "infiniteSeq %A" infiniteSeq // infiniteSeq seq [5; 6; 7; 8; ...]

or define a start like this

let infiniteSeq = Seq.initInfinite ((+) 5)
printfn "infiniteSeq %A" infiniteSeq // infiniteSeq seq [5; 6; 7; 8; ...]

Loop Sequence

for loop

let numbers = seq { 1 .. 10 }

for number in numbers do
    printfn "Number: %d" number

Seq.iter

let numbers = seq { 1 .. 10 }

Seq.iter (fun x -> printfn "Number: %d" x) numbers

Access element

Seq.item

syntax: Seq.item index source, thrown ArgumentException when the index is negative or the input sequence does not contain enough elements

let numbers = seq { 1 .. 10 }
let thirdElement = Seq.item 2 numbers  // Indexing is zero-based

printfn "The third element is %d" thirdElement

Seq.head && Seq.tail

Seq.head: Returns the first element of the sequence
Seq.tail: Returns a sequence that skips 1 element of the underlying sequence and then yields the remaining elements of the sequence

let numbers = seq { 1 .. 10 }
let firstElement = Seq.head numbers
let restElement = Seq.tail numbers

printfn "The first element is %d" firstElement // The first element is 1
printfn "The rest element is %A" restElement // The rest element is seq [2; 3; 4; 5; ...]

Operate element

Seq.updateAt

Return a new sequence with the item at a given index set to the new value
syntax: Seq.updateAt index value source

let newSeq = Seq.updateAt 1 9 seq { 0; 1; 2 }
// let newSeq = Seq.updateAt 1 9 (seq { 0; 1; 2 })
printfn "newSeq: %A" newSeq // newSeq: seq [0; 9; 2]

Seq.filter

Returns a new collection containing only the elements of the collection for which the given predicate returns "true". This is a synonym for Seq.where
syntax: Seq.filter predicateFunc sourceSeq

let numbers = seq { 1 .. 10 }
let evenNumbers = Seq.filter (fun x -> x % 2 = 0) numbers

Seq.iter (fun x -> printfn "Even Number: %d" x) evenNumbers

Seq.map

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection
syntax: Seq.filter mappingFunc sourceSeq

let numbers = seq { 1 .. 10 }
let doubleNumbers = Seq.map (fun x -> x * 2) numbers

Seq.iter (fun x -> printfn "doubleNumbers: %d" x) doubleNumbers

Seq.fold

Applies a function to each element of the collection
syntax: Seq.fold folderFunc state sourceSeq

type Charge =
     | In of int
     | Out of int
let inputs = [In 1; Out 2; In 3]
let balance = Seq.fold (fun acc charge ->
    match charge with
    | In i -> acc + i
    | Out o -> acc - o) 0 inputs

printfn "balance %A" balance // balance 2

or use pipeline operator to pass state sourceSeq, here is ||> for passing more than one param

type Charge =
     | In of int
     | Out of int
let inputs = [In 1; Out 2; In 3]
let balance = (0, inputs) ||> Seq.fold (fun acc charge ->
    match charge with
    | In i -> acc + i
    | Out o -> acc - o)

printfn "balance %A" balance // balance 2

F# For Dummys - Day 15 Collections Set

AllenZhu — Mon, 27 May 2024 08:39:41 +0000

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)}"

F# For Dummys - Day 14 Collections Map

AllenZhu — Sat, 25 May 2024 08:25:32 +0000

Today we learn Map, an immutable collection that stores key-value pairs

Map is immutable, it cannot be changed after created. Adding or removing elements return a new Map instead of modifying the existing one

Create Map

Explicitly specifying elements

let notEmptyMap = Map [ (1, "a"); (2, "b") ]

printfn "%A" notEmptyMap // map [(1, a); (2, b)]

Map.ofList

let map = 
    Map.ofList [
        (3, "three")
        (1, "one")
        (2, "two")
    ]

printfn "map: %A" map // map [(1, one); (2, two); (3, three)]

we can see the key is sorted from 3,1,2 to 1,2,3
what if the key is dulpicate

let map = 
    Map.ofList [
        (3, "three")
        (1, "one")
        (2, "two") // first key 2
        (2, "overwrite") // second key 2
    ]

printfn "%A" map // map [(1, one); (2, overwrite); (3, three)]

the value of the same key 2 is the last one, it overwrite the first one

Map.empty

create an empty map with int keys and string values

let emptyMap = Map.empty<int, string>
printfn "%A" emptyMap // map []

Access element

ContainsKey

Tests if an element is in the domain of the map

let sample = Map [ (1, "a"); (2, "b") ]

printfn "sample contain key 1: %b" (sample.ContainsKey 1) // sample contain key 1: true
printfn "sample contain key 3: %b" (sample.ContainsKey 3) // sample contain key 3: false

map.[key]

access by key in the domain will return the value, raise Exception if key not exists

let sample = Map [ (1, "a"); (2, "b") ]

printfn "access by key 1: %s" sample.[1] // access by key 1: a
printfn "access by key 3: %s" sample.[3] // Unhandled exception. System.Collections.Generic.KeyNotFoundException: The given key was not present in the dictionary

if you use browser environment, you may not see this Exception

TryFind

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not

let sample = Map [ (1, "a"); (2, "b") ]

printfn "TryFind key 1: %A" (sample.TryFind 1) // evaluates to Some "a"
printfn "TryFind key 3: %A" (sample.TryFind 3) // evaluates to None

TryGetValue

Lookup an element in the map, assigning to value if the element is in the domain of the map and returning false if not

let sample = Map [ (1, "a"); (2, "b") ]

printfn "access by key 1: %A" (sample.TryGetValue 1) // evaluates to (true, "a")
printfn "access by key 3: %A" (sample.TryGetValue 3) // evaluates to (false, null)

TryGetValue is added in F# 6.0

Conclusion: TryFind TryGetValueThe provide a safer way to access elements, and option type returned by TryFind TryGetValueThe fits naturally with F#'s pattern matching

Pattern Matching with Map

TryFind match

let mp = Map.ofList [("doot", 1); ("beef", 2); ("hoopty", 3)]

match Map.tryFind "doot" mp with
| Some value -> printfn "Value: %A" value
| None -> printfn "No value found!"

match Map.tryFind "goot" mp with
| Some value -> printfn "Value: %A" value
| None -> printfn "No value found!"

TryGetValue match

let mp = Map.ofList [("doot", 1); ("beef", 2); ("hoopty", 3)]

match mp.TryGetValue "doot" with
| (true, value) -> printfn "Value: %A" value
| (false, _) -> printfn "No value found!" // Value: 1

match mp.TryGetValue "goot" with
| (true, value) -> printfn "Value: %A" value
| (false, _) -> printfn "No value found!" // No value found!

Loop Map

for KeyValue(key, value) in

let map = Map.ofList [("doot", 1); ("beef", 2); ("hoopty", 3)]

for KeyValue(key, value) in map do
    printfn "Key: %s, Value: %d" key value

Map.iter

let map = Map.ofList [("doot", 1); ("beef", 2); ("hoopty", 3)]
map |> Map.iter (fun key value -> printfn "Key: %s, Value: %d" key value)

Modify element of Map

Add & Remove

let map = Map.ofList [("doot", 1); ("beef", 2); ("hoopty", 3)]

let mapWithAddedElement = map.Add("pork", 4)
printfn "Map after adding (4, \"four\"): %A" mapWithAddedElement

let mapWithRemovedElement = mapWithAddedElement.Remove("beef")
printfn "Map after removing key 2: %A" mapWithRemovedElement

Change

Map.change key func table

Returns a new map with the value stored under key changed according to func.

let input = Map [ (1, "a"); (2, "b") ]

let changed_map = input |> Map.change 1 (fun x ->
    match x with
    | Some s -> Some (s + "z")
    | None -> None
)
printfn "changed map: %A" changed_map // evaluates to map [(1, "az"); (2, "b")]

Practice

Counting Words in text: "hello world hello map in F#"

let text = "hello world hello map in F#"
let words = text.Split(' ') // ["hello", "world", "hello", "map", "in", "F#"]

let wordCountMap = 
    words 
    |> Array.fold (fun acc word ->
        if Map.containsKey word acc then // Static Member Function
            let count = acc.[word]
            acc.Add(word, count + 1)
        else
            acc.Add(word, 1)
    ) Map.empty

printfn "Word count map: %A" wordCountMap // Word count map: map [(F#, 1); (hello, 2); (in, 1); (map, 1); (world, 1)]

the solution use Map.containsKey which is Static Member Function, we can use acc Instance Member Function like this:

let text = "hello world hello map in F#"
let words = text.Split(' ')
printfn "words: %A" words

let wordCountMap = 
    words 
    |> Array.fold (fun (acc: Map<string, int>) word ->
        if acc.ContainsKey word then // Instance Member Function
            let count = acc.[word]
            acc.Add(word, count + 1)
        else
            acc.Add(word, 1)
    ) Map.empty

printfn "Word count map: %A" wordCountMap

Static Member Function and Instance Member Function will be introduced in OOP

F# For Dummys - Day 13 Collections Array

AllenZhu — Thu, 23 May 2024 14:27:57 +0000

Today we introduce another collection Array
Array is a type of collection that stores a fixed-size sequence of elements of the same type
Array is mutable, you can change the elements after the array has been created

Create Array

Explicitly specifying elements

let array1 = [| 1; 2; 3 |]

the ; could be omit between elements if you write them in seperated lines

let array1 =
    [|
        1
        2
        3
     |]

all elements should be the same type

let array1 = [| 1; 2; "3"|]

the first elements is int, the last is string, will get compile error:
All elements of an array must be implicitly convertible to the type of the first element, which here is 'int'. This element has type 'string'

Using comprehensions

let array1 = [| for i in 1 .. 5 -> i * i |] // [| 1; 4; 9; 16; 25 |]

Array.Empty Returns an empty array of the given type

let myEmptyArray = Array.empty // Evaluates to [| |]

Array.init Creates an array given the dimension and a generator function to compute the elements syntax: Array.init count initializer

let array0 = Array.init 5 (fun i -> i) // [| 0; 1; 2; 3; 4 |]

Array.create syntax: Array.init count value Creates an array whose elements are all initially the given value

let zeroes = Array.create 5 0 // zeroes = [| 0; 0; 0; 0; 0 |]

Array.zeroCreate

let arrayOfTenZeroes : int array = Array.zeroCreate 5 // [| 0; 0; 0; 0; 0 |]

Get element of Array

Using index

let array0 = Array.init 5 (fun i -> i)

printfn "first element %A" array0.[0] // first element 0

Using slice

let array0 = Array.init 5 (fun i -> i)

printfn "elements from 0 to 2: %A" array0.[0..2] // elements from 0 to 2: 0,1,2
printfn "elements from 2 to the end: %A" array0.[2..] // elements from 2 to the end: 2,3,4

Using build in method get

let inputs = [| "a"; "b"; "c" |]
let secondElement = Array.get inputs 1

printfn "secondElement: %s" secondElement // secondElement: b

Loop an Array

for...in

let array1 = [| for i in 1 .. 5 -> i * i |]

for number in array1 do
    printfn "Number: %d" number

Array.iter syntax: Array.iter action array

let array1 = [| for i in 1 .. 5 -> i * i |]

Array.iter (printfn "Number: %d") array1

Modify element of Array

Using index to set value

let inputs = [| "a"; "b"; "c" |]
inputs.[0] <- "d"

printfn "inputs: %A" inputs // d,b,c

Using build in method set syntax: Array.set array index value

let array1 = [| for i in 1 .. 5 -> i * i |]
printfn "array1 before set: %A" array1 // [| 1; 4; 9; 16; 25 |]

for i in 0 .. array1.Length - 1 do
    Array.set array1 i (i * 2)

printfn "array1 after set: %A" array1 // [| 0; 2; 4; 6; 8 |]

Pattern Matching with Array

let sumFirstTwoElements arr =
    match arr with
    | [| x; y |] -> x + y
    | [| x |] -> x
    | [| |] -> 0
    | _ -> failwith "Array has more than two elements."

let sum1 = sumFirstTwoElements [| 1; 2 |]
let sum2 = sumFirstTwoElements [| 5 |]
let sum3 = sumFirstTwoElements [| |]

printfn "Sum of first two elements: %d" sum1 // 3
printfn "Sum of first element: %d" sum2 // 5
printfn "Sum of empty array: %d" sum3 // 0

Operate Array

Concat Builds a new array that contains the elements of each of the given sequence of arrays Array.concat arrays

let inputs = [ [| 1; 2 |]; [| 3 |]; [| 4; 5 |] ]
let newArray = inputs |> Array.concat

printfn "newArray: %A" newArray

Append Builds a new array that contains the elements of the first array followed by the elements of the second array syntax: Array.append array1 array2

let results = Array.append [| 1; 2 |] [| 3; 4 |]

printfn "results: %A" results

Filter

let originalArray = [| 1; 2; 3; 4; 5; 6 |]
let evenNumbers = Array.filter (fun x -> x % 2 = 0) originalArray

printfn "evenNumbers: %A" evenNumbers // 2, 4, 6

let originalArray = [| 1; 2; 3 |]
let doubleArray = Array.map (fun x -> 2 * x) originalArray

printfn "doubleArray: %A" doubleArray // doubleArray: 2,4,6

Fold

let numbers = [| 1; 2; 3; 4; 5 |]
let sum = Array.fold (fun acc x -> acc + x) 0 numbers

printfn "sum: %i" sum // sum: 15

F# For Dummys - Day 12 Collections List

AllenZhu — Thu, 23 May 2024 08:17:06 +0000

Today we learn List, an immutable, ordered collection of elements of the same type
The term "ordered" here means that the list maintains the sequence in which elements were added, doesn't mean List is sorted

Create List

Explicitly specifying elements

let numbers = [1; 2; 3; 4; 5]
let names = ["Alice"; "Bob"; "Charlie"]

the ; could be omit between elements if you write them in seperated lines

let list123 = [ 1 // first comment
                2 // second comment
                3 // third comment
                ]

all elements should be the same type

let list123 = ["1"; 2; 3]

the first elements is string, the rest is int, will get compile error:
All elements of a list must be implicitly convertible to the type of the first element, which here is 'string'. This element has type 'int'.(1,21)

Using a range

let numbers = [1..5] // Equivalent to [1; 2; 3; 4; 5]
let evenNumbers = [2..2..10] // Equivalent to [2; 4; 6; 8; 10]

Using list comprehensions

let doubles = [for x in 1..5 -> x * 2] // Equivalent to [2; 4; 6; 8; 10]
let doubles = [for x in 2..2..10 -> x * 2] // Equivalent to [4; 8; 12; 16; 20]

Get element of List

Using index

let numbers = [1; 2; 3]
let firstNumber = numbers.[0]  // first number 1
let thirdNumber = numbers.[2]  // third number 3

printfn "firstNumber %i thirdNumber %i" firstNumber thirdNumber

if you use index not exist in List, will got index out of range exception

let numbers = [1; 2; 3]
let forthNumber = numbers.[4]

printfn "forthNumber %i" forthNumber

compile error:
Unhandled exception. System.ArgumentException: The index was outside the range of elements in the list
the browser environment have bug about this exception

Using build-in method List.item

let numbers = [1; 2; 3]
let firstNumber =  numbers |> List.item 0

printfn "firstNumber %i" firstNumber

head and tail List.head, get first element

let numbers = [1; 2; 3]
let head = numbers |> List.head

printfn "head %i" head

List.tail, return list after removing the first element, not the last element

let numbers = [1; 2; 3]
let tail = numbers |> List.tail

printfn "tail %A" tail // tail [2; 3]
printfn "numbers %A" numbers // numbers [1; 2; 3]

tail is a new List not including the first element, it won't change the value of original List numbers

Loop a List

for...in

let numbers = [1; 2; 3]

for number in numbers do
    printfn "Number: %d" number

List.iter

let numbers = [1; 2; 3]

List.iter (fun number -> printfn "Number: %d" number) numbers

fun define a lambda function here, it's equivalent to

let numbers = [1; 2; 3]
let printElement number = 
    printfn "Number: %d" number

List.iter printElement numbers

Pattern Matching with List

let numbers0 = []
let numbers1 = [1]
let numbers3 = [1; 2; 3]
let describeList lst =
    match lst with
    | [] -> "The list is empty"
    | [x] -> sprintf "The list has one element: %d" x
    | [x; y] -> sprintf "The list has two elements: %d and %d" x y
    | x :: xs -> sprintf "The list starts with %d and has more elements" x

printfn "%s" (describeList numbers0)  // The list is empty
printfn "%s" (describeList numbers1)  // The list has one element: 1
printfn "%s" (describeList numbers3)  // The list starts with %d and has more elements

Operate List

lists are indeed immutable, which means that you cannot modify a list after it has been created. Any operation that appears to modify a list (such as appending or prepending an element) actually creates a new list

Prepending an element

let originalList = [2; 3; 4]
let newList = 1 :: originalList

printfn "Original List: %A" originalList // Original List: [2; 3; 4]
printfn "New List: %A" newList //  New List: [1; 2; 3; 4]

Appending an element

let originalList = [1; 2; 3]
let newList = originalList @ [4]

printfn "Original List: %A" originalList  // Original List: [1; 2; 3]
printfn "New List: %A" newList //  New List: [1; 2; 3; 4]

Concatenate Lists

let originalList = [1; 2; 3]
let newList = List.append originalList [4]

printfn "Original List: %A" originalList
printfn "New List: %A" newList

Filter

you can not remove an element in List directly as List is immutable, but you can filter element based on some condition, put them into a new List

let numbers = [1; 2; 3; 4; 5]
let evenNumbers = List.filter (fun x -> x % 2 = 0) numbers

printfn "evenNumbers: %A" evenNumbers // evenNumbers: [2; 4]

apply an operation to every elements in List, you can use loop/List comprehensions to achieve that, or use Map

let numbers = [1; 2; 3; 4; 5]
let doubleNumbers = List.map (fun x -> 2 * x) numbers

printfn "doubleNumbers: %A" doubleNumbers // doubleNumbers:  [2; 4; 6; 8; 10]

Fold

"fold" or "compress" elements of List of into a single value by applying a function repeatedly

let numbers = [1; 2; 3; 4; 5]
let sum = List.fold (fun acc x -> acc + x) 0 numbers  // 15

printfn "sum: %i" sum // sum: 15

step 1: acc = 0 and x = 1 New acc = 0 + 1 = 1
step 2: acc = 1 and x = 2 New acc = 1 + 2 = 3
step 3: acc = 3 and x = 3 New acc = 3 + 3 = 6
step 4: acc = 6 and x = 4 New acc = 6 + 4 = 10
step 5: acc = 10 and x = 5 New acc = 10 + 5 = 15

F# For Dummys - Day 11 Collections Tuple

AllenZhu — Wed, 22 May 2024 13:30:14 +0000

Today we learn Tuple, as the first data structure of Collections
tuple is a simple data structure that combine elements together. These elements can be different types

(1, 2)

// Triple of strings.
("one", "two", "three")

// Tuple of generic types.
(a, b)

// Tuple that has mixed types.
("one", 1, 2.0)

// Tuple of integer expressions.
(a + 1, b + 1)

let's do some practices

defining a tuple with 2 elements

let person = ("John", 30)
let (name, age) = person   // this is unpack, unpack first element of person to name, second to age

printfn "Name: %s, Age: %d" name age

you can also get the element by fst snd for a tuple with 2 elements like below

let person = ("John", 30)
let name = fst person   // "John"
let age = snd person    // 30

printfn "Name: %s, Age: %d" name age

defining a tuple with 3 elements

let point = (3, 4, 5)
let (x, y, z) = point

printfn "Point coordinates: x = %d, y = %d, z = %d" x y z

there is no trd to get third element of tuple with 3 elements
there is no empty tuple, () is not empty tuple, it's more like Null

ignore element of tuple

let point = (3, 4, 5)
let (x, _, z) = point

printfn "Point coordinates: x = %d, z = %d" x z

the second element 4 will be ignored

return a tuple in function

let getPersonInfo() = ("John", 30)
let (personName, personAge) = getPersonInfo()

printfn "Person Name: %s, Person Age: %d" personName personAge

access elements of tuple in match

let print tuple1 =
   match tuple1 with
    | (a, b) -> printfn "Pair %A %A" a b // %A can format any type

print (1, 2)
print ("John", 30)

Tuples are particularly useful when you need to return multiple values from a function or when you want to combine several values together

F# For Dummys - Day 10 Loop

AllenZhu — Tue, 21 May 2024 12:12:33 +0000

Today we learn loop, do a task repeatly

What is loop

loop is used to repeat a block of code multiple times
we need to set when to start, how many times it repeats or condition to end loops
a loop never ends is called infinite loop

Three ways to loop

for loop Iterates over a specified range of values. The loop variable takes each value in the range one by one

// Forward for loop
for i = 1 to 5 do
    printfn "Jim has run %d laps" i

// Reverse for loop
for i = 5 downto 1 do
    printfn "Days until birthday: %d days left" (i - 1)

while loop Repeatedly executes the block of code as long as the condition remains true

let mutable counter = 1
while counter <= 5 do
    printfn "Jim has run %d laps" counter
    counter <- counter + 1

recursive function Calls itself with updated parameters

syntax: let rec funcName

let rec recursiveLoop n =
    if n > 0 then
        printfn "Jim run 1 lap: %d laps left" (n - 1)
        recursiveLoop (n - 1)

recursiveLoop 5

Understanding recursive function:

Imagine you have a set of Russian dolls, where each doll contains a smaller doll inside it

To find the smallest doll, you would:

Open the current doll
Check if there is another smaller doll inside
If there is, repeat the process with the smaller doll

// Pseudocode
let findSmallestDoll doll =
    if doll contains no smaller doll then
        return doll
    else
        let innerDoll = open(doll) // smaller doll inside
        findSmallestDoll(innerDoll)

How to choose

for loop is simple and easy to understand when iterating over a known range of values
while loop is useful when the number of iterations is not known beforehand
recursive function making code more expressive and often easier to reason about

exercises:

1 + 2 + 3 + ... + 99 + 100 = ?
1 + 3 + 5 + ... + 97 + 99 = ?

answers:
question 1

let mutable sum = 0
for i = 1 to 100 do
    sum <- sum + i
printfn "Sum using for loop: %d" sum

while

let mutable sum = 0
let mutable counter = 1
while counter <= 100 do
    sum <- sum + counter
    counter <- counter + 1
printfn "Sum using while loop: %d" sum

recursive function

let rec sumRecursive n acc =
    if n = 0 then acc
    else sumRecursive (n - 1) (acc + n)

printfn "Sum using recursive function: %d" (sumRecursive 100 0)

question 2

let mutable sum = 0
for i = 1 to 100 do
    if i % 2 <> 0 then
        sum <- sum + i
printfn "Sum using for loop: %d" sum

while

let mutable sum = 0
let mutable counter = 1
while counter <= 100 do
    if counter % 2 <> 0 then
        sum <- sum + counter
    counter <- counter + 1
printfn "Sum using while loop: %d" sum

recursive function

let rec sumOddRecursive n acc =
    if n = 0 then acc
    else 
        let newAcc = if n % 2 <> 0 then acc + n else acc
        sumOddRecursive (n - 1) newAcc

printfn "Sum using recursive function: %d" (sumOddRecursive 100 0)

F# For Dummys - Day 9 Branching

AllenZhu — Mon, 20 May 2024 12:52:47 +0000

Today we learn control flow, or branching
sometimes we need to execute a block of code only when it meets some condition

//Pseudocode
if conditionOne then doTaskOne
else if conditionTwo then doTaskTwo
else doSomethingElse

we introduce 2 ways of branching

if...then

let temperature = 15

if temperature < 0 then
    printfn "Wear down coat"
elif temperature < 10 then
    printfn "Wear sweater"
elif temperature < 20 then
    printfn "Wear long sleeves"
elif temperature < 30 then
    printfn "Wear T-shirt"
else
    printfn "Wear bikini"

temperature = 15, the first branch suits is temperature < 20 , even though temperature < 30 is also true, the rest logic will not execute

match...with

// Match expression. 
match test-expression with
| pattern1 [ when condition ] -> result-expression1
| pattern2 [ when condition ] -> result-expression2
| ...

equivalent example:

let temperature = 15

match temperature with
| temperature when temperature < 0 -> printfn "Wear down coat"
| temperature when temperature < 10 -> printfn "Wear sweater"
| temperature when temperature < 20 -> printfn "Wear long sleeves"
| temperature when temperature < 30 -> printfn "Wear T-shirt"
| _ -> printfn "Wear bikini"

AND Pattern: we can combine conditions with (&&) operator, it hits when both condition match

let age = 10

match age with
| age when age > 0 && age <= 1 -> printfn "Infant"
| age when age > 1 && age <= 12 -> printfn "Child"
| age when age > 12 && age <= 16 -> printfn "Teenager"
| age when age > 16 -> printfn "Adults"
| _ -> printfn "Not born"

OR Pattern: we can combine patterns using the (||) operator to match multiple patterns

let x = 10

match x with
| x when x > 0 || x = 0 -> printfn "Positive or Zero"
| _ -> printfn "Negative"

we can define a pattern matching function

let temperature = 15

let clothingAdvice temp =
    match temp with
    | t when t < 0 -> "Wear down coat"
    | t when t < 10 -> "Wear sweater"
    | t when t < 20 -> "Wear long sleeves"
    | t when t < 30 -> "Wear T-shirt"
    | _ -> "Wear bikini"

printfn "%s" (clothingAdvice temperature)

another example from windows documentation

type Shape =
    | Square of side: double
    | Rectangle of width: double * length: double

let getArea shape =
    match shape with
    | Square side -> side * side
    | Rectangle (width, length) -> width * length

let square = Square 2.0
printfn $"The area of the square is {getArea square}"
let rect = Rectangle (3.0, 2.0)
printfn $"The area of the rect is {getArea rect}"

getArea function calculate the area according to different shape
for a Square, it use side * side = 2.0 * 2.0
for a Rectangle, it use width * length = 3.0 * 2.0

The area of the square is 4
The area of the rect is 6

we didn't learn type yet, it defines a Union type here, and there is more powerful usage of match, we will introduce type, Union and discover more usage of match in the coming days

F# For Dummys - Day 8 Function && Pipeline

AllenZhu — Mon, 20 May 2024 11:11:06 +0000

Today we learn how to define a function and pipeline

what is function

function is a block of code that takes input values (parameters), and returns an output value
normally we perform some task with the input, it will be less useful just return the input value

funtion no param input:

let say_hello() = "Hello"
printfn "say_hello: %s" (say_hello())

funtion one param input

let say_hello_to name = "Hello " + name
printfn "say_hello_to: %s" (say_hello_to "Lucy")

funtion two param input

let say_hello_to name0 name1 = name0 + " say Hello to " + name1
printfn "say_hello_to: %s" (say_hello_to "Lucy" "Lily")

function can be a param of other function

let applyTwice f x = f (f x)
let increment x = x + 1
let result = applyTwice increment 5

printfn "Result: %d" result

increment is the first param of function applyTwice here, it's increment(increment(x)), result is (5 + 1) + 1 = 7

lambda

lambda expression is an anonymous function (a function without a name) that you can define in place, often to be passed as an argument to higher-order functions
syntax of a lambda expression

fun arguments -> expression

a simple add function

let add x y = 
    x + y
printfn "%d" (add 3 5)  // Output: 8

a lambda version

printfn "%d" ((fun x y -> x + y) 3 5)  // Output: 8

you can not use this fun at other place as it Dispose after finish

pipeline

forward pipeline |>, data flow from left to right

we can combine multiple functions one after one
function1 |> function2 |> function3, it's called pipeline
the function param example could be like this:

let applyTwice f x = f x |> f
let increment x = x + 1
let result = applyTwice increment 5

printfn "Result: %d" result

another longer pipeline

let addOne x = x + 1
let square x = x * x
let subtractFive x = x - 5

let result = 5 |> addOne |> square |> subtractFive // (5 + 1)^2 - 5
printfn "The result is %d" result // output: The result is 31

the output of first function is the input of next function
result = 5 |> addOne, addOne get 5, return 5 + 1 = 6, square get 6, return 6 * 6 = 36, substractFive get 36, return 36 -5 = 31

<| backward pipeline, data flow from right to left

let addOne x = x + 1
let square x = x * x
let subtractFive x = x - 5

let result = subtractFive <| (square <| (addOne 5))
printfn "The result is %d" result // output: The result is 31

why pipeline

an example for morning routine

let getOutOfBed () = "Out of bed"
let brushTeeth state = state + " -> Brushed teeth"
let takeShower state = state + " -> Took shower"
let getDressed state = state + " -> Got dressed"
let eatBreakfast state = state + " -> Ate breakfast"

let morningRoutine =
    getOutOfBed ()
    |> brushTeeth
    |> takeShower
    |> getDressed
    |> eatBreakfast

printfn "Morning routine completed: %s" morningRoutine // output: Morning routine completed: Out of bed -> Brushed teeth -> Took shower -> Got dressed -> Ate breakfast

there is an equivalent way to get the same result, which is nested function calls

let getOutOfBed () = "Out of bed"
let brushTeeth state = state + " -> Brushed teeth"
let takeShower state = state + " -> Took shower"
let getDressed state = state + " -> Got dressed"
let eatBreakfast state = state + " -> Ate breakfast"

let morningRoutine = eatBreakfast(getDressed(takeShower(brushTeeth(getOutOfBed()))))
printfn "Morning routine completed: %s" morningRoutine

the last function eatBreakfast is put in the first place
which way do you prefer
we can see the pipeline way is more readable in this style:

The order of operations is written in a natural, top-to-bottom manner, which is easier to read and understand
It is more intuitive because it reads like a sequence of steps or instructions
Adding or removing steps is straightforward, you just add or remove lines
Each function operates on the result of the previous function, clearly showing the flow of data

pipeline way is recommended in F#, the data flows in pipeline, elegant!

F# For Dummys - Day 7 Operators

AllenZhu — Sat, 18 May 2024 12:08:33 +0000

Today we learn operators and do some exercises

Operators

Operators are special symbols that perform operations on one or more operands (values or variables)
operator for 2 variables:
like +: 1 + 1 = 2, the '+' here is operator, it add the left number 1 and right number 1
we introduce 6 operators

let num0 = 1
let num1 = 1
let sum = num0 + num1

printfn "1 + 1 = %i" sum // output: 1 + 1 = 2

let num0 = 2
let num1 = 1
let difference = num0 - num1

printfn "2 - 1 = %i" difference // output: 2 - 1 = 1

let num0 = 4
let num1 = 2
let quotient = num0 / num1

printfn "4 / 2 = %i" quotient // output: 4 / 2 = 2

let num0 = 3
let num1 = 2
let remainder = num0 % num1

printfn "3 %% 2 = %i" remainder // output: 3 % 2 = 1

let num0 = 3
let num1 = 2
let equal = num0 <> num1

printfn "is 3 not equals 2? %b" equal // output: is 3 not equals 2? true

let num0 = 3
let num1 = 2
let equal = num0 = num1

printfn "is 3 equals 2? %b" equal // output: is 3 equals 2? false

exercises

1 + 2 * 3 = ?
(1 + 2) * 3 = ?
2 + 2 = 2 * 2?
there are 20 apples for lunch, 10 students in the class, how many apples one student can get?
there are 21 apples for lunch, 10 students in the class, how many apples left?

answers

'*' has higher priority than +

let results = 1 + 2 * 3
printfn "1 + 2 * 3 = %i" results // output: 1 + 2 * 3 = 7

() changed the priority, + inside has higher priority than *

let results = (1 + 2) * 3
printfn "(1 + 2) * 3 = %i" results // output: (1 + 2) * 9

= can compare expression, the right = has higher priority than left =, which asign value of results

let results = 2 + 2 = 2 * 2
printfn "2 + 2 = 2 * 2 is %b" results // output: 2 + 2 = 2 * 2 is true

let number_of_apples = 20
let number_of_students = 10
let apples_of_each_student = number_of_apples / number_of_students
printfn "every student can get %i apple" apples_of_each_student // output: every student can get 2 apple

let number_of_apples = 21
let number_of_students = 10
let apples_left = number_of_apples % number_of_students
printfn "%i apple left after distributing" apples_left // output: 1 apple left after distributing

F# For Dummys - Day 6 Format

AllenZhu — Fri, 17 May 2024 03:48:15 +0000

Today we learn how to format the output of println, and a new type char

what is formatting?

formatting is converting values into strings according to a specified format
we introduce 2 ways to format:

String interpolation: one way to combine variables and text is to use something called interpolation actually we used it yesterday

let name = "Lucy"
let age = 14
printfn $"my name is {name}, I'm {age} years old"

$ tell the compiler: please use the variable we defined before in this string
{} indicate what exactly the variables we need, here in this example is {name} and {age}
so it will replace the value of variables at the location of brace
like type of age is int, it's converted to string '14' in the final output, we didn't transfer it explicitly

Specifiers: You can also use format specifiers as part of what you're trying to print. Using specifiers is the most commonly used way to format in F# Let's use specifier to format in our example:

let name = "Lucy"
let age = 14
printfn "my name is %s, I'm %i years old" name age

you can see the output is the same
%s is for name, it's for string type
%i is for age, it's for int type
we introduce 4 of them today:

%b for bool

let is_this_apple = true
let is_this_orange = false

printfn "Is this an apple? %b" is_this_apple
printfn "Is this an orange? %b" is_this_orange

%c for char
we have learned string type to describe a text, it represents a sequence of characters
while char represents a single character, like 'a', 'b', 'c', 'd' or '!', '@', '#', '$'
string and char are different types, not just the length, you can not concat them like this:

let str = "Hello"
let ch = '!'
let result = str + ch

printfn "%s" result  // Output: Hello!

will get error: The type 'char' does not match the type 'string'

we can transfer a char to string like this, then can concat them properly

let str = "Hello"
let ch = '!'
let result = str + (string)ch

printfn "%s" result  // Output: Hello!

the full specifiers for other types are here

F# For Dummys - Day 5 Mutable

AllenZhu — Thu, 16 May 2024 08:20:05 +0000

Today we learn how to change the value of variable(not variable actually)
remember how to define a value

let name = "Lucy"

can we change our name? let's try to change the value of our string variable

let name = "Lucy"
name <- "Lily"
printfn $"{name}"

Run, whoops, compile error

the error message on the Problems window:

This value is not mutable. Consider using the mutable keyword, e.g. 'let mutable name = expression'.(2,1)</br>

obviously, change value of name is not allowed
luckily, the error message is clear and friendly, it even suggest how to fix the problem
let's try it's sugguestion:

let mutable name = "Lucy"
name <- "Lily"
printfn $"{name}"

run the code, name has been changed successfully!

conclusion:
value we define in F# is immutable by default, we need to explicitly add 'mutable' before value, now we can call it variables, as we can change it's value later

Let's do a practice:
my name is Lucy, I'm 14 year's old

let name = "Lucy"
let age = 14
printfn $"my name is {name}, I'm {age} years old"

my sister is Lily, she's 11 year's old, please introduce herself for Lily without define new values
answer:

let mutable name = "Lucy" // name is variable now
let mutable age = 14
printfn $"my name is {name}, I'm {age} years old"
name <- "Lily"
age <- 11
printfn $"my name is {name}, I'm {age} years old"

output: