F# on My Notes

Overview

Mon, 01 Jan 0001 00:00:00 +0000

F`#`#

F# is an open-source, cross-platform, interoperable programming language for writing succinct, robust and performant code. Your focus remains on your problem domain, rather than the details of programming.

Organizing F# Code#

The following table shows reference articles related to organizing your F# code.

Title	Description
Namespaces	Learn about namespace support in F#. A namespace lets you organize code into areas of related functionality by enabling you to attach a name to a grouping of program elements.
Modules	Learn about modules. An F# module is like a namespace and can also include values and functions. Grouping code in modules helps keep related code together and helps avoid name conflicts in your program.
open Declarations	Learn about how open works. An open declaration specifies a module, namespace, or type whose elements you can reference without using a fully qualified name.
Signatures	Learn about signatures and signature files. A signature file contains information about the public signatures of a set of F# program elements, such as types, namespaces, and modules. It can be used to specify the accessibility of these program elements.
Access Control	Learn about access control in F#. Access control means declaring what clients are able to use certain program elements, such as types, methods, functions, and so on.
XML Documentation	Learn about support for generating documentation files for XML doc comments, also known as triple slash comments. You can produce documentation from code comments in F# as in other .NET languages.

Literals and Strings#

The following table shows reference articles that describe literals and strings in F#.

Functions

Mon, 01 Jan 0001 00:00:00 +0000

F# Function#

Functions are the fundamental unit of program execution in any programming language. As in other languages, an F# function has a name, can have parameters and take arguments, and has a body. F# also supports functional programming constructs such as treating functions as values, using unnamed functions in expressions, composition of functions to form new functions, curried functions, and the implicit definition of functions by way of the partial application of function arguments.

C.U.R.S.

Mon, 01 Jan 0001 00:00:00 +0000

Class#

Classes are types that represent objects that can have properties, methods, and events.

Syntax#

// Class definition:
type [access-modifier] type-name [type-params] [access-modifier] ( parameter-list ) [ as identifier ] =
[ class ]
[ inherit base-type-name(base-constructor-args) ]
[ let-bindings ]
[ do-bindings ]
member-list
...
[ end ]
// Mutually recursive class definitions:
type [access-modifier] type-name1 ...
and [access-modifier] type-name2 ...
...

Constructors#

The constructor is code that creates an instance of the class type. In an F# class, there is always a primary constructor whose arguments are described in the parameter-list that follows the type name, and whose body consists of the let (and let rec) bindings at the start of the class declaration and the do bindings that follow. The arguments of the primary constructor are in scope throughout the class declaration.

Collections 1

Mon, 01 Jan 0001 00:00:00 +0000

Array#

Arrays are fixed-size, zero-based, mutable collections of consecutive data elements that are all of the same type.

Create array#

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

// Put each element on a separate line, in which case the semicolon separator is optional.
let array1 =
 [|
 1
 2
 3
 |]

// The type of the array elements is inferred from the literals used and must be consistent. 
// The following code causes an error because 1.0 is a float and 2 and 3 are integers.
// Causes an error.
// let array2 = [| 1.0; 2; 3 |]


// Use sequence expressions to create arrays.
let array3 = [| for i in 1 .. 10 -> i * i |]

// use Array.zeroCreate
let arrayOfTenZeroes : int array = Array.zeroCreate 10

// use Array.empty
let myEmptyArray = Array.empty
printfn "Length of empty array: %d" myEmptyArray.Length
// Length of empty array: 0

// use Array.create
printfn "Array of floats set to 5.0: %A" (Array.create 10 5.0)
// Area of floats set to 5.0: [|5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0; 5.0|]

// Array.init
printfn "Array of squares: %A" (Array.init 10 (fun index -> index * index))
// Array of squares: [|0; 1; 4; 9; 16; 25; 36; 49; 64; 81|]

Copy#

open System.Text

let firstArray : StringBuilder array = Array.init 3 (fun index -> new StringBuilder(""))
let secondArray = Array.copy firstArray
// Reset an element of the first array to a new value.
firstArray[0] <- new StringBuilder("Test1")
// Change an element of the first array.
firstArray[1].Insert(0, "Test2") |> ignore
printfn "%A" firstArray
printfn "%A" secondArray
// output
// [|Test1; Test2; |]
// [|; Test2; |]

Access#

// Accesses elements from 0 to 2.
array1[0..2]

// Accesses elements from the beginning of the array to 2.
array1[..2]

// Accesses elements from 2 to the end of the array.
array1[2..]

Functions#

// Array.sub 
let a1 = [| 0 .. 99 |]
let a2 = Array.sub a1 5 10
printfn "%A" a2
// output
// [|5; 6; 7; 8; 9; 10; 11; 12; 13; 14|]


// Array.append creates a new array by combining two existing arrays.
printfn "%A" (Array.append [| 1; 2; 3|] [| 4; 5; 6|])
// output
// [|1; 2; 3; 4; 5; 6|]




// Array.choose selects elements of an array to include in a new array. 
printfn "%A" (Array.choose (fun elem -> if elem % 2 = 0 then
 Some(float (elem*elem - 1))
 else
 None) [| 1 .. 10 |])
// output
// [|3.0; 15.0; 35.0; 63.0; 99.0|]


// Array.collect runs a specified function on each array element of an existing array and then collects the elements generated by the function and combines them into a new array. 
printfn "%A" (Array.collect (fun elem -> [| 0 .. elem |]) [| 1; 5; 10|])
// output
// [|0; 1; 0; 1; 2; 3; 4; 5; 0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]


Array.concat takes a sequence of arrays and combines them into a single array. The following code demonstrates Array.concat.

F#

Copy
Array.concat [ [|0..3|] ; [|4|] ]
//output [|0; 1; 2; 3; 4|]

Array.concat [| [|0..3|] ; [|4|] |]
//output [|0; 1; 2; 3; 4|]



// Array.filter takes a Boolean condition function and generates a new array that contains only those elements from the input array for which the condition is true.
printfn "%A" (Array.filter (fun elem -> elem % 2 = 0) [| 1 .. 10|])
// The output
// [|2; 4; 6; 8; 10|]


// Array.rev generates a new array by reversing the order of an existing array. 
let stringReverse (s: string) =
 System.String(Array.rev (s.ToCharArray()))

printfn "%A" (stringReverse("!dlrow olleH"))
// The output 
// "Hello world!"

// You can easily combine functions in the array module that transform arrays by using the pipeline operator (|>)
[| 1 .. 10 |]
|> Array.filter (fun elem -> elem % 2 = 0)
|> Array.choose (fun elem -> if (elem <> 8) then Some(elem*elem) else None)
|> Array.rev
|> printfn "%A"
// output
// [|100; 36; 16; 4|]

Multidimensional arrays#

let my2DArray = array2D [ [ 1; 0]; [0; 1] ]
let arrayOfArrays = [| [| 1.0; 0.0 |]; [|0.0; 1.0 |] |]
let twoDimensionalArray = Array2D.init 2 2 (fun i j -> arrayOfArrays[i][j])

Slicing#

// Get rows 1 to N from an NxM matrix (returns a matrix):
matrix[1.., *]

// Get rows 1 to 3 from a matrix (returns a matrix):
matrix[1..3, *]

// Get columns 1 to 3 from a matrix (returns a matrix):
matrix[*, 1..3]

// Get a 3x3 submatrix:
matrix[1..3, 1..3]

// Get row 3 from a matrix as a vector:
matrix[3, *]

// Get column 3 from a matrix as a vector:
matrix[*, 3]

Matrix & slicing#


type Matrix<'T>(N: int, M: int) =
 let internalArray = Array2D.zeroCreate<'T> N M

 member this.Item
 with get(a: int, b: int) = internalArray[a, b]
 and set(a: int, b: int) (value:'T) = internalArray[a, b] <- value

 member this.GetSlice(rowStart: int option, rowFinish : int option, colStart: int option, colFinish : int option) =
 let rowStart =
 match rowStart with
 | Some(v) -> v
 | None -> 0
 let rowFinish =
 match rowFinish with
 | Some(v) -> v
 | None -> internalArray.GetLength(0) - 1
 let colStart =
 match colStart with
 | Some(v) -> v
 | None -> 0
 let colFinish =
 match colFinish with
 | Some(v) -> v
 | None -> internalArray.GetLength(1) - 1
 internalArray[rowStart..rowFinish, colStart..colFinish]

 member this.GetSlice(row: int, colStart: int option, colFinish: int option) =
 let colStart =
 match colStart with
 | Some(v) -> v
 | None -> 0
 let colFinish =
 match colFinish with
 | Some(v) -> v
 | None -> internalArray.GetLength(1) - 1
 internalArray[row, colStart..colFinish]

 member this.GetSlice(rowStart: int option, rowFinish: int option, col: int) =
 let rowStart =
 match rowStart with
 | Some(v) -> v
 | None -> 0
 let rowFinish =
 match rowFinish with
 | Some(v) -> v
 | None -> internalArray.GetLength(0) - 1
 internalArray[rowStart..rowFinish, col]

module test =
 let generateTestMatrix x y =
 let matrix = new Matrix<float>(3, 3)
 for i in 0..2 do
 for j in 0..2 do
 matrix[i, j] <- float(i) * x - float(j) * y
 matrix

 let test1 = generateTestMatrix 2.3 1.1
 let submatrix = test1[0..1, 0..1]
 printfn $"{submatrix}"

 let firstRow = test1[0,*]
 let secondRow = test1[1,*]
 let firstCol = test1[*,0]
 printfn $"{firstCol}"

Search#


// Array.find takes a Boolean function and returns the first element for which 
// the function returns true, or raises a 
// System.Collections.Generic.KeyNotFoundException if no element that satisfies
// the conditionis found. 
// Array.findIndex is like Array.find, except that it returns the index of 
// the element instead of the element itself.

// The following code uses Array.find and Array.findIndex to locate a number that 
// is both a perfect square and perfect cube.

let arrayA = [| 2 .. 100 |]
let delta = 1.0e-10
let isPerfectSquare (x:int) =
 let y = sqrt (float x)
 abs(y - round y) < delta
let isPerfectCube (x:int) =
 let y = System.Math.Pow(float x, 1.0/3.0)
 abs(y - round y) < delta
let element = Array.find (fun elem -> isPerfectSquare elem && isPerfectCube elem) arrayA
let index = Array.findIndex (fun elem -> isPerfectSquare elem && isPerfectCube elem) arrayA
printfn "The first element that is both a square and a cube is %d and its index is %d." element index
// The output is as follows.
// The first element that is both a square and a cube is 64 and its index is 62.

// ----------------------------------------------------------------------------
// Array.tryFind is like Array.find, except that its result is an option type, 
// and it returns None if no element is found. Array.tryFind should be used 
// instead of Array.find when you do not know whether a matching element is 
// in the array. Similarly, Array.tryFindIndex is like Array.findIndex except 
// that the option type is the return value. If no element is found, the option is None.

let delta = 1.0e-10
let isPerfectSquare (x:int) =
 let y = sqrt (float x)
 abs(y - round y) < delta
let isPerfectCube (x:int) =
 let y = System.Math.Pow(float x, 1.0/3.0)
 abs(y - round y) < delta
let lookForCubeAndSquare array1 =
 let result = Array.tryFind (fun elem -> isPerfectSquare elem && isPerfectCube elem) array1
 match result with
 | Some x -> printfn "Found an element: %d" x
 | None -> printfn "Failed to find a matching element."

lookForCubeAndSquare [| 1 .. 10 |]
lookForCubeAndSquare [| 100 .. 1000 |]
lookForCubeAndSquare [| 2 .. 50 |]
// The output is as follows.
// Found an element: 1
// Found an element: 729
// Failed to find a matching element.


// ----------------------------------------------------------------------------
// Use Array.tryPick when you need to transform an element in addition to finding it. 
// The result is the first element for which the function returns the transformed 
// element as an option value, or None if no such element is found.
// The following code shows the use of Array.tryPick. In this case, instead of
// a lambda expression, several local helper functions are defined to simplify the code.

let findPerfectSquareAndCube array1 =
 let delta = 1.0e-10
 let isPerfectSquare (x:int) =
 let y = sqrt (float x)
 abs(y - round y) < delta
 let isPerfectCube (x:int) =
 let y = System.Math.Pow(float x, 1.0/3.0)
 abs(y - round y) < delta
 // intFunction : (float -> float) -> int -> int
 // Allows the use of a floating point function with integers.
 let intFunction function1 number = int (round (function1 (float number)))
 let cubeRoot x = System.Math.Pow(x, 1.0/3.0)
 // testElement: int -> (int * int * int) option
 // Test an element to see whether it is a perfect square and a perfect
 // cube, and, if so, return the element, square root, and cube root
 // as an option value. Otherwise, return None.
 let testElement elem =
 if isPerfectSquare elem && isPerfectCube elem then
 Some(elem, intFunction sqrt elem, intFunction cubeRoot elem)
 else None
 match Array.tryPick testElement array1 with
 | Some (n, sqrt, cuberoot) -> printfn "Found an element %d with square root %d and cube root %d." n sqrt cuberoot
 | None -> printfn "Did not find an element that is both a perfect square and a perfect cube."

findPerfectSquareAndCube [| 1 .. 10 |]
findPerfectSquareAndCube [| 2 .. 100 |]
findPerfectSquareAndCube [| 100 .. 1000 |]
findPerfectSquareAndCube [| 1000 .. 10000 |]
findPerfectSquareAndCube [| 2 .. 50 |]
// The output is as follows.
// Found an element 1 with square root 1 and cube root 1.
// Found an element 64 with square root 8 and cube root 4.
// Found an element 729 with square root 27 and cube root 9.
// Found an element 4096 with square root 64 and cube root 16.
// Did not find an element that is both a perfect square and a perfect cube.

Modify arrays#

Array.set sets an element to a specified value. Array.fill sets a range of elements in an array to a specified value. The following code provides an example of Array.fill.

Collections 2

Mon, 01 Jan 0001 00:00:00 +0000

List#

A list in F# is an ordered, immutable series of elements of the same type. To perform basic operations on lists, use the functions in the List module.

Creating & appending#

Creating and Initializing Lists

// --- creating ---
let list123 = [ 1; 2; 3 ]

// You can also put line breaks between elements, in which case the semicolons are optional. 
let list123 = [
 1
 2
 3 ]


// Normally, all list elements must be the same type. 
// An exception is that a list in which the elements are specified to be a base type
// can have elements that are derived types. Thus the following is acceptable, 
// because both Button and CheckBox derive from Control.
let myControlList : Control list = [ new Button(); new CheckBox() ]

// using a range indicated by integers separated by the range operator (..)
let list1 = [ 1 .. 10 ]


// An empty list.
let listEmpty = []

// use a sequence expression to create a list.
let listOfSquares = [ for i in 1 .. 10 -> i*i ]

// ---- appending -------
// You can attach elements to a list by using the :: (cons) operator. 
// If list1 is [2; 3; 4], the following code creates list2 as [100; 2; 3; 4].
let list2 = 100 :: list1

// You can concatenate lists that have compatible types by using the @ operator, as in the following code. 
// If list1 is [2; 3; 4] and list2 is [100; 2; 3; 4], this code creates list3 as [2; 3; 4; 100; 2; 3; 4].
let list3 = list1 @ list2

Properties#

The list type supports the following properties:

Collections 3

Mon, 01 Jan 0001 00:00:00 +0000

Seq#

A sequence is a logical series of elements all of one type. 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 only as required, so a sequence can provide better performance than a list in situations in which not all the elements are used.

// Sequence that has an increment.
seq { 0 .. 10 .. 100 }

// uses the -> operator, which allows you to specify an expression 
// whose value will become a part of the sequence. 
seq { for i in 1 .. 10 -> i * i }


// specify the do keyword, with an optional yield that follows:
seq { for i in 1 .. 10 do yield i * i }

// The 'yield' is implicit and doesn't need to be specified in most cases.
seq { for i in 1 .. 10 do i * i }

// The following code generates a list of coordinate pairs along with 
// an index into an array that represents the grid. 
// Note that the first for expression requires a do to be specified.
let (height, width) = (10, 10)
let sequence = seq {
 for row in 0 .. width - 1 do
 for col in 0 .. height - 1 ->
 (row, col, row*width + col)
 }

for e in sequence do
 printfn "%A" e

// (0, 0, 0)
// (0, 1, 1)
// (0, 2, 2)
// ...
// (0, 9, 9)
// (1, 0, 10)
// (1, 1, 11)
// (1, 2, 12)
// ...
// (9, 9, 99)

yield! keyword#

// Repeats '1 2 3 4 5' ten times
seq {
 for _ in 1..10 do
 yield! seq { 1; 2; 3; 4; 5}
}

// When yield! is used in an expression, all other single values 
// must use the yield keyword:
// Combine repeated values with their values
seq {
 for x in 1..10 do
 yield x
 yield! seq { for i in 1..x -> i}
}


// Prime number
// Recursive isprime function.
let isprime n =
 let rec check i =
 i > n/2 || (n % i <> 0 && check (i + 1))
 check 2

let aSequence =
 seq {
 for n in 1..100 do
 if isprime n then
 n
 }

for x in aSequence do
 printfn "%d" x
// output
// 1 2 3 5 7 ...47 53 ... 89 97


// Following example creates a multiplication table that consists of 
// tuples of three elements, each consisting of two factors and the product
let multiplicationTable =
 seq {
 for i in 1..9 do
 for j in 1..9 ->
 (i, j, i*j)
 }



// Yield the values of a binary tree in a sequence.
type Tree<'a> =
 | Tree of 'a * Tree<'a> * Tree<'a>
 | Leaf of 'a

// inorder : Tree<'a> -> seq<'a>
let rec inorder tree =
 seq {
 match tree with
 | Tree(x, left, right) ->
 yield! inorder left
 yield x
 yield! inorder right
 | Leaf x -> yield x
 }

let mytree = Tree(6, Tree(2, Leaf(1), Leaf(3)), Leaf(9))
let seq1 = inorder mytree
printfn "%A" seq1
// outut 
// seq [1; 2; 3; 6; ...]

Functions#


// Using Seq.empty, or you can create a sequence of just one 
// specified element by using Seq.singleton.
let seqEmpty = Seq.empty
let seqOne = Seq.singleton 10
printfn "%A" seqOne
// output: seq [10]

// use Seq.init to create a sequence for which the elements are created 
// by using a function that you provide. You also provide a size for 
// the sequence. This function is just like List.init, except that the 
// elements are not created until you iterate through the sequence.
let seqFirst5MultiplesOf10 = Seq.init 5 (fun n -> n * 10)
Seq.iter (fun elem -> printf "%d " elem) seqFirst5MultiplesOf10
// The output is
// 0 10 20 30 40

// Convert an array to a sequence by using a cast.
let seqFromArray1 = [| 1 .. 10 |] :> seq<int>

// Convert an array to a sequence by using Seq.ofArray.
let seqFromArray2 = [| 1 .. 10 |] |> Seq.ofArray

// using Seq.cast, you can create a sequence from a weakly typed 
// collection, such as those defined in System.Collections. 
open System

let arr = ResizeArray<int>(10)

for i in 1 .. 10 do
 arr.Add(10)

let seqCast = Seq.cast arr


// Seq.unfold generates a sequence from a computation function that takes 
// a state and transforms it to produce each subsequent element in the sequence
let seq1 =
 0 // Initial state
 |> Seq.unfold (fun state ->
 if (state > 20) then
 None
 else
 Some(state, state + 1))

printfn "The sequence seq1 contains numbers from 0 to 20."

for x in seq1 do
 printf "%d " x
// output
// The sequence seq1 contains numbers from 0 to 20.
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

let fib =
 (1, 1) // Initial state
 |> Seq.unfold (fun state ->
 if (snd state > 1000) then
 None
 else
 Some(fst state + snd state, (snd state, fst state + snd state)))

printfn "\nThe sequence fib contains Fibonacci numbers."
for x in fib do printf "%d " x
// output
// The sequence fib contains Fibonacci numbers.
// 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Example#

// generateInfiniteSequence generates sequences of floating point
// numbers. The sequences generated are computed from the fDenominator
// function, which has the type (int -> float) and computes the
// denominator of each term in the sequence from the index of that
// term. The isAlternating parameter is true if the sequence has
// alternating signs.
let generateInfiniteSequence fDenominator isAlternating =
 if (isAlternating) then
 Seq.initInfinite (fun index ->
 1.0 /(fDenominator index) * (if (index % 2 = 0) then -1.0 else 1.0))
 else
 Seq.initInfinite (fun index -> 1.0 /(fDenominator index))

// The harmonic alternating series is like the harmonic series
// except that it has alternating signs.
let harmonicAlternatingSeries = generateInfiniteSequence (fun index -> float index) true

// This is the series of reciprocals of the odd numbers.
let oddNumberSeries = generateInfiniteSequence (fun index -> float (2 * index - 1)) true

// This is the series of recipocals of the squares.
let squaresSeries = generateInfiniteSequence (fun index -> float (index * index)) false

// This function sums a sequence, up to the specified number of terms.
let sumSeq length sequence =
 (0, 0.0)
 |>
 Seq.unfold (fun state ->
 let subtotal = snd state + Seq.item (fst state + 1) sequence
 if (fst state >= length) then
 None
 else
 Some(subtotal, (fst state + 1, subtotal)))

// This function sums an infinite sequence up to a given value
// for the difference (epsilon) between subsequent terms,
// up to a maximum number of terms, whichever is reached first.
let infiniteSum infiniteSeq epsilon maxIteration =
 infiniteSeq
 |> sumSeq maxIteration
 |> Seq.pairwise
 |> Seq.takeWhile (fun elem -> abs (snd elem - fst elem) > epsilon)
 |> List.ofSeq
 |> List.rev
 |> List.head
 |> snd

// Compute the sums for three sequences that converge, and compare
// the sums to the expected theoretical values.
let result1 = infiniteSum harmonicAlternatingSeries 0.00001 100000
printfn "Result: %f ln2: %f" result1 (log 2.0)
// output
// Result: 0.693152 ln2: 0.693147

let pi = Math.PI
let result2 = infiniteSum oddNumberSeries 0.00001 10000
printfn "Result: %f pi/4: %f" result2 (pi/4.0)
// output
// Result: 0.785373 pi/4: 0.785398

// Because this is not an alternating series, a much smaller epsilon
// value and more terms are needed to obtain an accurate result.
let result3 = infiniteSum squaresSeries 0.0000001 1000000
printfn "Result: %f pi*pi/6: %f" result3 (pi*pi/6.0)
// output
// Result: 1.644618 pi*pi/6: 1.644934

Transforming#

// Seq.pairwise creates a new sequence in which successive elements of the input
// sequence are grouped into tuples.
let printSeq seq1 = Seq.iter (printf "%A ") seq1; printfn ""
let seqPairwise = Seq.pairwise (seq { for i in 1 .. 10 -> i*i })
printSeq seqPairwise
// output
// (1, 4) (4, 9) (9, 16) (16, 25) (25, 36) (36, 49) (49, 64) (64, 81) (81, 100) 


printfn ""
let seqDelta = Seq.map (fun elem -> snd elem - fst elem) seqPairwise
printSeq seqDelta
// output
// 3 5 7 9 11 13 15 17 19 



// Seq.windowed is like Seq.pairwise, except that instead of producing a 
// sequence of tuples, it produces a sequence of arrays that contain copies 
// of adjacent elements (a window) from the sequence. You specify the number 
// of adjacent elements you want in each array.

let seqNumbers = [ 1.0; 1.5; 2.0; 1.5; 1.0; 1.5 ] :> seq<float>
let seqWindows = Seq.windowed 3 seqNumbers
let seqMovingAverage = Seq.map Array.average seqWindows
printfn "Initial sequence: "
printSeq seqNumbers
// 1.0 1.5 2.0 1.5 1.0 1.5 
printfn "\nWindows of length 3: "
printSeq seqWindows
// [|1.0; 1.5; 2.0|] [|1.5; 2.0; 1.5|] [|2.0; 1.5; 1.0|] [|1.5; 1.0; 1.5|] 

printfn "\nMoving average: "
printSeq seqMovingAverage
// 1.5 1.666666667 1.5 1.333333333

Sorting, Comparing & Grouping#

// Seq.compareWith function. The function compares successive elements in 
// turn, and stops when it encounters the first unequal pair. Any additional 
// elements do not contribute to the comparison.
let sequence1 = seq { 1 .. 10 }
let sequence2 = seq { 10 .. -1 .. 1 }

// Compare two sequences element by element.
let compareSequences =
 Seq.compareWith (fun elem1 elem2 ->
 if elem1 > elem2 then 1
 elif elem1 < elem2 then -1
 else 0)

let compareResult1 = compareSequences sequence1 sequence2
match compareResult1 with
| 1 -> printfn "Sequence1 is greater than sequence2."
| -1 -> printfn "Sequence1 is less than sequence2."
| 0 -> printfn "Sequence1 is equal to sequence2."
| _ -> failwith("Invalid comparison result.")
// val compareResult1: int = -1


// Seq.countBy takes a function that generates a value called a key for 
// each element. A key is generated for each element by calling this function 
// on each element. Seq.countBy then returns a sequence that contains the key 
// values, and a count of the number of elements that generated each value of 
// the key.

let mySeq1 = seq { 1.. 100 }

let printSeq seq1 = Seq.iter (printf "%A ") seq1

let seqResult =
 mySeq1
 |> Seq.countBy (fun elem ->
 if elem % 3 = 0 then 0
 elif elem % 3 = 1 then 1
 else 2)

printSeq seqResult
// (1, 34) (2, 33) (0, 33)



// Seq.groupBy takes a sequence and a function that generates a key from an 
// element. The function is executed on each element of the sequence. 
// Seq.groupBy returns a sequence of tuples, where the first element of each 
// tuple is the key and the second is a sequence of elements that produce 
// that key.

let sequence = seq { 1 .. 100 }

let printSeq seq1 = Seq.iter (printf "%A ") seq1

let sequences3 =
 sequences
 |> Seq.groupBy (fun index ->
 if (index % 3 = 0) then 0
 elif (index % 3 = 1) then 1
 else 2)

sequences3 |> printSeq
// (1, seq [1; 4; 7; 10; ...]) (2, seq [2; 5; 8; 11; ...]) (0, seq [3; 6; 9; 12; ...])




// Seq.distinct. Or Seq.distinctBy, which takes a key-generating function to 
// be called on each element. The resulting sequence contains elements of the 
// original sequence that have unique keys; later elements that produce a 
// duplicate key to an earlier element are discarded.
let binary n =
 let rec generateBinary n =
 if (n / 2 = 0) then [n]
 else (n % 2) :: generateBinary (n / 2)

 generateBinary n
 |> List.rev
 |> Seq.ofList

printfn "%A" (binary 1024)
// [1; 0; 0; 0; 0; 0; 0; 0; 0; 0; 0]


let resultSequence = Seq.distinct (binary 1024)
printfn "%A" resultSequence
// seq [1; 0]

let inputSequence = { -5 .. 10 }
let printSeq seq1 = Seq.iter (printf "%A ") seq1

printfn "Original sequence: "
printSeq inputSequence
// -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 

printf ""
printfn "\nSequence with distinct absolute values: "
let seqDistinctAbsoluteValue = Seq.distinctBy (fun elem -> abs elem) inputSequence
printSeq seqDistinctAbsoluteValue
// -5 -4 -3 -2 -1 0 6 7 8 9 10

Slice#

In F#, a slice is a subset of any data type. Slices are similar to indexers, but instead of yielding a single value from the underlying data structure, they yield multiple ones. Slices use the .. operator syntax to select the range of specified indices in a data type.

Pattern Matching

Mon, 01 Jan 0001 00:00:00 +0000

Pattern#

Patterns are rules for transforming input data. They are used throughout F# to compare data with a logical structure or structures, decompose data into constituent parts, or extract information from data in various ways.

Name	Description	Example
Constant pattern	Any numeric, character, or string literal, an enumeration constant, or a defined literal identifier	1.0, “test”, 30, Color.Red
Identifier pattern	A case value of a discriminated union, an exception label, or an active pattern case	Some(x) Failure(msg)
Variable pattern	identifier	a
as pattern	pattern as identifier	(a, b) as tuple1
OR pattern	pattern1	pattern2
AND pattern	pattern1 & pattern2	(a, b) & (_, “test”)
Cons pattern	identifier :: list-identifier	h :: t
List pattern	[ pattern_1; … ; pattern_n ]	[ a; b; c ]
Array pattern	[	pattern_1; ..; pattern_n
Parenthesized pattern	( pattern )	( a )
Tuple pattern	( pattern_1, … , pattern_n )	( a, b )
Record pattern	{ identifier1 = pattern_1; … ; identifier_n = pattern_n }	{ Name = name; }
Wildcard pattern	_	_
Pattern together with type annotation	pattern : type	a : int
Type test pattern	:? type [ as identifier ]	:? System.DateTime as dt
Null pattern	null	null
Nameof pattern	nameof expr	nameof str

Constant Patterns#


[<Literal>]
let Three = 3

let filter123 x =
 match x with
 // The following line contains literal patterns combined with an OR pattern.
 | 1 | 2 | Three -> printfn "Found 1, 2, or 3!"
 // The following line contains a variable pattern.
 | var1 -> printfn "%d" var1

for x in 1..10 do filter123 x
// Found 1, 2, or 3!
// Found 1, 2, or 3!
// Found 1, 2, or 3!
// 4
// 5
// 6
// 7
// 8
// 9
// 10


type Color =
 | Red = 0
 | Green = 1
 | Blue = 2

let printColorName (color:Color) =
 match color with
 | Color.Red -> printfn "Red"
 | Color.Green -> printfn "Green"
 | Color.Blue -> printfn "Blue"
 | _ -> ()

printColorName Color.Red
printColorName Color.Green
printColorName Color.Blue
// Red
// Green
// Blue

Identifier Patterns#

let printOption (data : int option) =
 match data with
 | Some var1 -> printfn "%d" var1
 | None -> ()

type PersonName =
 | FirstOnly of string
 | LastOnly of string
 | FirstLast of string * string

let constructQuery personName =
 match personName with
 | FirstOnly(firstName) -> printfn "May I call you %s?" firstName
 | LastOnly(lastName) -> printfn "Are you Mr. or Ms. %s?" lastName
 | FirstLast(firstName, lastName) -> printfn "Are you %s %s?" firstName lastName

constructQuery (FirstOnly("john"))
constructQuery (LastOnly("smith"))
constructQuery (FirstLast("john","smith"))
// May I call you john?
// Are you Mr. or Ms. smith?
// Are you john smith?

Variable Patterns#

let function1 x =
 match x with
 | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2
 | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2
 | (var1, var2) -> printfn "%d equals %d" var1 var2

function1 (1,2)
function1 (2, 1)
function1 (0, 0)
// 1 is less than 2
// 2 is greater than 1
// 0 equals 0

as Pattern#

The as pattern is a pattern that has an as clause appended to it.

Active Patterns

Mon, 01 Jan 0001 00:00:00 +0000

Active Patterns#

Active patterns enable you to define named partitions that subdivide input data, so that you can use these names in a pattern matching expression just as you would for a discriminated union. You can use active patterns to decompose data in a customized manner for each partition.

Syntax#

// Active pattern of one choice.
let (|identifier|) [arguments] valueToMatch = expression

// Active Pattern with multiple choices.
// Uses a FSharp.Core.Choice<_,...,_> based on the number of case names. In F#, the limitation n <= 7 applies.
let (|identifier1|identifier2|...|) valueToMatch = expression

// Partial active pattern definition.
// Uses a FSharp.Core.option<_> to represent if the type is satisfied at the call site.
let (|identifier|_|) [arguments] valueToMatch = expression

Examples#

Multiple choices

let (|Even|Odd|) input = if input % 2 = 0 then Even else Odd
let TestNumber input =
 match input with
 | Even -> printfn "%d is even" input
 | Odd -> printfn "%d is odd" input

TestNumber 7
TestNumber 11
TestNumber 32
// output
// 7 is odd
// 11 is odd
// 32 is even

Decompose data types


open System.Drawing

let (|RGB|) (col : System.Drawing.Color) =
 ( col.R, col.G, col.B )

let (|HSB|) (col : System.Drawing.Color) =
 ( col.GetHue(), col.GetSaturation(), col.GetBrightness() )

let printRGB (col: System.Drawing.Color) =
 match col with
 | RGB(r, g, b) -> printfn " Red: %d Green: %d Blue: %d" r g b

let printHSB (col: System.Drawing.Color) =
 match col with
 | HSB(h, s, b) -> printfn " Hue: %f Saturation: %f Brightness: %f" h s b

let printAll col colorString =
 printfn "%s" colorString
 printRGB col
 printHSB col

printAll Color.Red "Red"
printAll Color.Black "Black"
printAll Color.White "White"
printAll Color.Gray "Gray"
printAll Color.BlanchedAlmond "BlanchedAlmond"

// Red
// Red: 255 Green: 0 Blue: 0
// Hue: 360.000000 Saturation: 1.000000 Brightness: 0.500000
// Black
// Red: 0 Green: 0 Blue: 0
// Hue: 0.000000 Saturation: 0.000000 Brightness: 0.000000
// White
// Red: 255 Green: 255 Blue: 255
// Hue: 0.000000 Saturation: 0.000000 Brightness: 1.000000
// Gray
// Red: 128 Green: 128 Blue: 128
// Hue: 0.000000 Saturation: 0.000000 Brightness: 0.501961
// BlanchedAlmond
// Red: 255 Green: 235 Blue: 205
// Hue: 36.000000 Saturation: 1.000000 Brightness: 0.901961

Partial Active Patterns#

Active patterns that do not always produce a value are called partial active patterns; they have a return value that is an option type. To define a partial active pattern, you use a wildcard character (_) at the end of the list of patterns inside the banana clips.

Computations 1

Mon, 01 Jan 0001 00:00:00 +0000

Computation expressions#

Computation expressions in F# provide a convenient syntax for writing computations that can be sequenced and combined using control flow constructs and bindings. Depending on the kind of computation expression, they can be thought of as a way to express monads, monoids, monad transformers, and applicative functors. However, unlike other languages (such as do-notation in Haskell), they are not tied to a single abstraction, and do not rely on macros or other forms of metaprogramming to accomplish a convenient and context-sensitive syntax.

Computations 2

Mon, 01 Jan 0001 00:00:00 +0000

Map#

Common Names: map, fmap, lift, Select

Common Operators: <$> <!>

What it does: Lifts a function into the elevated world

Signature: (a->b) -> E<a> -> E<b>.

Alternatively with the parameters reversed: E<a> -> (a->b) -> E<b>

Description “map” is the generic name for something that takes a function in the normal world and transforms it into a corresponding function in the elevated world.

An alternative interpretation of map is that it is a two parameter function that takes an elevated value E<a> and a normal function a->b, and returns a new elevated value E<b> generated by applying the function a->b to the internal elements of E<a>.

Async

Mon, 01 Jan 0001 00:00:00 +0000

Async expressions#

Async expressions provide one way of performing computations asynchronously, that is, without blocking execution of other work.

Asynchronous Binding by Using let!#

The effect of let! is to enable execution to continue on other computations or threads as the computation is being performed. After the right side of the let! binding returns, the rest of the async expression resumes execution.

// let just stores the result as an asynchronous operation.
let (result1 : Async<byte[]>) = stream.AsyncRead(bufferSize)
// let! completes the asynchronous operation and returns the data.
let! (result2 : byte[]) = stream.AsyncRead(bufferSize)

let! can only be used to await F# async computations Async<T> directly. You can await other kinds of asynchronous operations indirectly:

Task

Mon, 01 Jan 0001 00:00:00 +0000

Tasks expressions#

Asynchronous code is normally authored using async expressions. Using task expressions is preferred when interoperating extensively with .NET libraries that create or consume .NET tasks. Task expressions can also improve performance and the debugging experience. However, task expressions come with some limitations.

task { expression }

The task is started immediately after this code is executed and runs on the current thread until its first asynchronous operation is performed (for example, an asynchronous sleep, asynchronous I/O, or other primitive asynchronous operation). The type of the expression is Task<'T>, where 'T is the type returned by the expression when the return keyword is used.

Lazy

Mon, 01 Jan 0001 00:00:00 +0000

Lazy Expressions#

Lazy expressions are expressions that are not evaluated immediately, but are instead evaluated when the result is needed. This can help to improve the performance of your code.

let identifier = lazy ( expression )

Lazy expressions enable you to improve performance by restricting the execution of an expression to only those situations in which a result is needed.

To force the expressions to be performed, you call the method Force. Force causes the execution to be performed only one time. Subsequent calls to Force return the same result, but do not execute any code.

Namespace, Module & Import

Mon, 01 Jan 0001 00:00:00 +0000

Namespace#

A namespace lets you organize code into areas of related functionality by enabling you to attach a name to a grouping of F# program elements. Namespaces are typically top-level elements in F# files.

Namespaces cannot directly contain values and functions. Instead, values and functions must be included in modules, and modules are included in namespaces. Namespaces can contain types, modules.

namespace [rec] [parent-namespaces.]identifier

Modules#

A module is a grouping of F# code, such as values, types, and function values, in an F# program. Grouping code in modules helps keep related code together and helps avoid name conflicts in your program.

F# on My Notes

Overview

F##

Organizing F# Code#

Literals and Strings#

Functions

F# Function#

C.U.R.S.

Class#

Syntax#

Constructors#

Collections 1

Array#

Create array#

Copy#

Access#

Functions#

Multidimensional arrays#

Slicing#

Matrix & slicing#

Search#

Modify arrays#

Collections 2

List#

Creating & appending#

Properties#

Collections 3

Seq#

yield! keyword#

Functions#

Example#

Transforming#

Sorting, Comparing & Grouping#

Slice#

Pattern Matching

Pattern#

Constant Patterns#

Identifier Patterns#

Variable Patterns#

as Pattern#

Active Patterns

Active Patterns#

Syntax#

Examples#

Partial Active Patterns#

Computations 1

Computation expressions#

Computations 2

Map#

Async

Async expressions#

Asynchronous Binding by Using let!#

Task

Tasks expressions#

Lazy

Lazy Expressions#

Namespace, Module & Import

Namespace#

Modules#

F`#`#