Monday, 11 April 2016

Arrays in F# – The Mutable collection

Arrays in F# are mutable data type. I started intentionally with this line because FSharp(F#) is a functional programming language and the paradigm of language promotes immutability. So Whenever there is a mutable type or value be careful with the usage. Let’s go back to main topic i.e. Arrays.

In this post we’ll see how to initialize, iterate, update and other manipulation that you can do with Arrays in FSharp(F#). In this post we’ll cover only one dimensional array. May be we can discuss 2D, 3D, and Jagged array in advanced array post of arrays in future.

Let’s have fun with playing around Arrays.

Static array initialization

In FSharp(F#) we initialize the array with following notations:

let fruits = [|"Apple"; "Orange"; "Grapes"|]

// or using every item in separate line without separator

let fruits = [|





Notice additional symbol | (pipe) used with square braces to declare the array. Also the separator is not , comma anymore but it’s ; semicolon. Array of integer sample and possible mistakes that can be done by a C# developer without getting any compile time error.

let arr = [| 1; 2; 3; 4 |]
Possible mistakes #1  
// most common mistakes done by developers with background of imperative language
let arr1 = [| 1, 2, 3|]
// this is an array of tuples with one element, so no error is displayed.
// the ',' separator is used to create tuples.
Possible mistakes #2 
// what if the | is not used in declaration
let arr2 = [1; 2; 3]
// this is also valid but this would be a list and it's "IMMUTABLE"

Initialization using sequence expressions

// Array of squares of positive integers from 1 to 10
let arr3 = [| for i in 1 .. 10 -> i * i |]
Output -  [|1; 4; 9; 16; 25; 36; 49; 64; 81; 100|]  

Initialization using Array module

Array.empty : creates a new array that does not contain any elements.

// Specify the type by using a type argument.
let array1 = Array.empty<int>
// Specify the type by using a type annotation.
let array2 : int array = Array.empty
// Even though array3 has a generic type,
// you can still use methods such as Length on it.
let array3 = Array.empty
printfn "Length of empty array: %d" array3.Length

Output - 0

Array.create : creates an array of a specified size and sets all the elements to provided values.

// creates an array of length 10, all elements initialized with default value -1
let arrayOfTenZeroes : int array = Array.create 10 -1
// create a bool array with default value as true
let primeFlaggedArr : bool array = Array.create 10 true

Note – In the end of this article we’ll solve the find prime number problem using Sieve of Eratosthenes.

Array.zeroCreate : creates an array, given a dimension and a function to generate the elements.

// create a bool array with default values(false)
let primeFlaggedArr : bool array = Array.zeroCreate 10

Array.init : creates an array, given a dimension and a function to generate the elements.

// Another way to create array of squares starting from 1 to 10
printfn "Array of squares: %A" (Array.init 10 (fun index -> index * index))

Accessing array elements

You can access array elements by using a dot operator (.) and brackets ([ and ]).

let fruits = [|
let firstFruit = fruits.[0]

Accessing range of values from array using sliced notation

// Accesses elements from 0 to 2.
// esses elements from the beginning of the array to 2.
// esses elements from 2 to the end of the array.

Few more honorable mentions or generally used functions are Array.get, Array.set and Array.length which are self-explanatory.

Replacing existing value using index

Arrays are mutable so you can replace any existing value by accessing it via index and assigning a new value with ‘<-‘ operator.

// Updating the value of an item in array using index
let fruits1 = [|
fruits1.[0] <- "Mango"
let print = 
    for (fruit) in fruits1 do
        printfn "%s" fruit


Output –

> PrintUpper [|"Apple"; "Orange"; "Grapes"|] ;;




Iterating through array elements

Let’s create a function that takes an array of string and convert the values to upper case.

let MakeUpper(arr : string array) =
    for i in 0 .. arr.Length - 1 do
        Array.set arr i (arr.[i].ToUpper())
        printfn "%s"  arr.[i]

In visual studio select the function and run it in F# interactive.

Output –

> MakeUpper [|"Apple"; "Orange"; "Grapes"|] ;;




With variant of for loop (foreach alike)

let PrintUpper(arr : string array) =
    for (fruit) in arr do
        printfn "%s"  (fruit.ToUpper())


Output –

> PrintUpper [|"Apple"; "Orange"; "Grapes"|] ;;




So now we are pretty much good to start with playing around array. Let’s try to solve few problems using array to get up to speed. As I discussed before we’ll be solving the finding prime number problem using Sieve of Eratosthenes. Here’s a function to which is based on theory given at source:

// print prime number in a series up to n 
let PrimeSeive(n : int) = 
    let sequence = [|1..n|]
    let isPrime = Array.create n true
    let maxSquareRoot : int = System.Convert.ToInt32(System.Math.Sqrt(float n))
    let candidate = 2;
    for i in candidate..maxSquareRoot do
        if isPrime.[i] then
            let mutable j = i * i
            while j < n - 1 do
                isPrime.[j] <- false
                j <- j + i
    for index in 0..n - 1 do
        if isPrime.[index] then
            printf "%d, " index


Output –

> PrimeSeive 100 ;;

0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 99, val it : unit = ()

Here’s the equivalent code in CSharp(C#)

public static void PrimeSeive(int n)


    bool[] isPrime = new bool[n + 1];

    int maxSquareRoot = (int)Math.Sqrt(n);


    int candidate = 2;


    // Additional loop to initialize the bool array with default value

    for (int ind = 0; ind < isPrime.Length; ind++)


        isPrime[ind] = true;



    for (int i = candidate; i < Math.Sqrt(n); i += 1)


        if (isPrime[i])

        for (int j = i * i; j < n; j = j += i)


            isPrime[j] = false;




    for (int k = 0; k < n; k++)






Although the given solution in F# is not the best and not recommended because we’re using much of mutable types like any other imperative language. I’m not sure you readers have notices but look at the F# snippet how beautiful it does look without any block defining braces. In next post we’ll solve the same problem with immutable types and without using mutable.

Here’s few exercises for you:

What would be the output of below code?

// Guess the output, Write your answer in the comments.
let guessOutput = 
        for i in [|9..7..30|] do
         printfn "%d" i

Happy Learning!!!!

Wednesday, 6 April 2016

string manipulations in F#

In previous posts we learned and got familiar with the theory and code of Functional programming language F#. The last post was mostly used operation of any language “The Print”. In this post we’ll use the mostly used type and literals in code i.e. String.
A string

String is an immutable data type in C# and F# is all about immutability. So you will not see much different between the C# string and F# string type. Means you’re already familiar with escape sequences\verbatim strings. Below is the list of supported escape sequences in F#:


Escape sequence





Carriage return






Quotation mark

\ "



Unicode character

\uXXXX or \UXXXXXXXX (where X indicates a hexadecimal digit)

The Verbatim string

Like in C# the verbatim string is ignore special character i.e. escape sequences. In F# it works with same symbol @ and special triple-quoted string.

// Using a verbatim string to represent xml node in string

let xmlFragment1 = @"<book author=""Milton, John"" title=""Paradise Lost"">"


// Using a triple-quoted string

let xmlFragment2 = """<book author="Milton, John" title="Paradise Lost">"""


Consider below examples:

let str1 = "Hello
let str2 = "Hello, \

The first Str1 is a string with new line character “Hello \n sir”. Linebreaks are actually produces the new line character in a string spanning across lines.

Str2 is a continuous string “Hello, Mam”. When a ‘\’ backslash character is the last character before the line breaks leading whitespaces are ignored and no line breaks will be considered.

String is array* of characters

Means you can access individual character with index like in an array*.

printfn "%c" str1.[1]

*The Array in F# will be covered in a dedicated post later.


The substring can be extracted from any string by supplying range in Index operator.

printfn "%s" (str1.[0..2]) // Substring from index 0 to 2
printfn "%s" (str2.[3..5]) // Substring from index 3 to 5

String as ByteArray (Ascii string)

// "abc" interpreted as a Unicode string.
let str1 : string = "abc"
// "abc" interpreted as an ASCII byte array. 
let bytearray : byte[] = "abc"B 

String operator

Just like C#, the ‘+’ operator concatenates two strings.

let string1 = "Hello, " + "world"

String Formatter

In the previous post we learned about the format specifiers. The all format specifiers can be used for string formatting. The equivalent of ‘String.Format’ in F# is ‘sprintf’

let formattedString = sprintf "The first letter of alphabet in %s is %c" "english" 'a'

Let’s run in F# interactive –

> formattedString;;

val it : string = "The first letter of alphabet in english is a"

The above are the basics of strings type in F#. Now let’s move to the interesting topic i.e. manipulation of strings. The string function are defined as module ‘Core.String’ under FSharp.Core namespace.

Library functions for string Manipulation

The list of function is available at above mentioned MSDN link. But here we’ll try to play a little with those function to understand what those functions actually do.

collect : (char -> string) -> string -> string

concat : string -> seq<string> -> string

exists : (char -> bool) -> string -> bool

forall : (char -> bool) -> string -> bool

init : int -> (int -> string) -> string

iter : (char -> unit) -> string -> unit

iteri : (int -> char -> unit) -> string -> unit

length : string -> int

map : (char -> char) -> string -> string

mapi : (int -> char -> char) -> string -> string

replicate : int -> string -> string


Builds a new string whose characters are the results of applying a specified function to each of the characters of the input string and concatenating the resulting strings.

let collectTesting inputS =

    String.collect (fun c -> sprintf "%c# " c) inputS


printfn "%s" (collectTesting "CFJ")

Output –

C# F# J#


Returns a new string made by concatenating the given strings with a separator.

let arr = [| "Sunday"; "Monday"; "Tuesday"; |]


let concatPlay = String.concat " comes after " arr

Output –

val concatPlay : string = "Sunday comes after Monday comes after Tuesday"


Tests if any character of the string satisfies the given predicate.

let containsUppercase string1 =
    if (String.exists (fun c -> System.Char.IsUpper(c)) string1) then
        printfn "The string \"%s\" contains uppercase characters." string1
        printfn "The string \"%s\" does not contain uppercase characters." string1
containsUppercase "Hello World!"
containsUppercase "no"


Output –

The string "Hello World!" contains uppercase characters.
The string "no" does not contain uppercase characters.


Tests if all characters in the string satisfy the given predicate.

let isValidName string1 =

    if (String.forall (fun c -> System.Char.IsLetter(c)) string1) then

        printfn "The string \"%s\" is a valid name." string1


        printfn "The string \"%s\" is not a valid name." string1

isValidName "Amit"

isValidName "Amit25"


Output –

The string "Amit" is a valid name.

The string "Amit25" is not a valid name.


Creates a new string whose characters are the results of applying a specified function to each index and concatenating the resulting strings.

let string1 = String.init 10 (fun i -> i.ToString())
printfn "%s" string1
let string2 = String.init 26 (fun i ->
    sprintf "%c" (char (i + int 'A')))
printfn "%s" string2


Output –



Applies a specified function to each character in a string.

let printCharacters sourceString =

    String.iter(fun c -> printfn "%c" c) sourceString

printCharacters "Happy New Year!!"

output –

















Similarly there are below function which takes lambda expressions(anonymous function) and applies on each character of given input.

map - Creates a new string whose characters are the results of applying a specified function to each of the characters of the input string.

iteri and mapi

iteri function applies a specified function to the index of each character in the string and the character itself and returns unit.

mapi function creates a new string whose characters are the results of applying a specified function to each character and index of the input string.


let enumerateCharacters inputString = 
    String.iteri (fun i c -> printfn "%d %c" i c) inputString
enumerateCharacters "TIME"
enumerateCharacters "SPACE"


Output –

Index       Unit

0       T
1       I
2       M
3       E
0       S
1       P
2       A
3       C
4       E


Returns a string by concatenating a specified number of instances of a string.

printfn "%s" <| String.replicate 10 "<>"

Output –



Returns the length of the string.

The sample included with each string library function are simplified as it’s a beginner level post. In upcoming posts we’ll see more complex examples with function piping, pattern matching etc.