Fundamentals of F# Arrays: Everything You Need to Know

Arrays are a fundamental data structure in many programming languages, and F# is no exception. F# provides robust support for arrays, offering a variety of powerful features and operations to manipulate and process array data efficiently. This article explores the fundamentals of F# arrays, covering everything you need to know to work effectively with this data structure.

Arrays in F# are fixed length, meaning that once an array is created, its size cannot be changed. Once you allocate an array with a specific length, you cannot add or remove elements from it. If you need a dynamic collection that can grow or shrink, you can consider using other data structures such as lists or sequences in F#.

Table of Contents

Creating Arrays

Let’s start by looking at how to create arrays in F#. There are multiple ways to initialize an array, depending on your specific requirements.

Creating an empty array

In F#, you can create an empty array using the Array.empty function. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let emptyArray: int[] = Array.empty

    // Output: [||]
    printfn "%A" emptyArray

    0 // Return exit code 0 to indicate successful execution

we create an empty array of type int. You can replace int with any other data type as per your requirements.

Creating an array with initial values

To create an array with initial values, you can use the array literal syntax [| … |]. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let arrayWithValues = [| 1; 2; 3; 4; 5 |]

    // Output: [|1; 2; 3; 4; 5|]
    printfn "%A" arrayWithValues

    0 // Return exit code 0 to indicate successful execution

In the above code, we create an array with initial values 1, 2, 3, 4, and 5.

Creating an array using the Array.create method

The Array.create method allows you to create an array of a specified length and initialize all its elements to a default value. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let length = 5

    let defaultValue = 0

    let createdArray = Array.create length defaultValue


    // Output: [|0; 0; 0; 0; 0|]
    printfn "%A" createdArray

    0 // Return exit code 0 to indicate successful execution

We create an array of length 5 with all elements initialized to 0. You can replace length and defaultValue with your desired values.

The Array.create method is useful when you need to preallocate an array with a specific length and want to set all the elements to a default value.

Creating an array using the Array.init method

In F#, you can create an array with custom values using the Array.init method. This method allows you to specify the length of the array and a function that determines the value of each element based on its index. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let length = 5

    let createdArray = Array.init length (fun index -> index * 2)

    // Output: [|0; 2; 4; 6; 8|]
    printfn "%A" createdArray

    0 // Return exit code 0 to indicate successful execution

In the above code, we create an array of length 5, and each element is calculated by multiplying its index by 2. The resulting array will contain the values 0, 2, 4, 6, and 8.

The provided function (fun index -> index * 2) takes the index as input and returns the calculated value for that index. You can customize the function to suit your specific requirements, allowing for dynamic initialization of array elements.

You can also use more complex functions or external data to determine the value of each element. Here’s an example where we use a list of names to create an array of uppercase versions of those names:

[<EntryPoint>]
let main(args: string[]): int =

    let names = ["Edward"; "Andisen"; "Sydney"; "Abel"]

    let createdArray = Array.init names.Length (fun index -> names.[index].ToUpper())

    // Output: [|"EDWARD"; "ANDISEN"; "SYDNEY"; "ABEL"|]
    printfn "%A" createdArray

    0 // Return exit code 0 to indicate successful execution

We create an array of the same length as the names list. Each element of the array is obtained by accessing the corresponding index in the names list and converting it to uppercase using the ToUpper() method.

By using the Array.init method, you can create arrays with custom values based on index calculations, external data, or any other logic you require.

Accessing Array Elements

Once you have an array, you’ll often need to access its individual elements. In F#, you can access elements using zero-based indexing. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let arr: int[] = [| 10; 20; 30; 40; 50 |]

    // Accessing the second element (20)
    let secondElement: int = arr.[1] 

    // Output: 20
    printfn "%d" secondElement

    0 // Return exit code 0 to indicate successful execution

Modifying Array Elements

You can modify individual array elements by assigning new values to their corresponding indices. Arrays are indexed starting from 0, so the first element is at index 0, the second element is at index 1, and so on. Here’s an example:

[<EntryPoint>]
let main(args: string[]): int =

    let arr: int[] = [| 10; 20; 30; 40; 50 |]

    // Modifying the element at index 1 to have the value 42
    arr.[1] <- 42 

    // Accessing the second element (20)
    let secondElement: int = arr.[1] 

    // Output: 42
    printfn "%d" secondElement

    0 // Return exit code 0 to indicate successful execution

Array Operations and Functions

F# provides a wide range of operations and functions to manipulate arrays efficiently. Let’s explore some of the most commonly used ones:

Length

The Array.length function returns the number of elements in the array:

[<EntryPoint>]
let main(args: string[]): int =

    let arr: int[] = [| 10; 20; 30; 40; 50 |]

    // length = 5
    let length: int = Array.length arr

    // Output: 5
    printfn "%d" length

    0 // Return exit code 0 to indicate successful execution

Iteration

You can iterate over all elements in an array using the Array.iter function. It applies a given function to each element:

[<EntryPoint>]
let main(args: string[]): int =

    let arr: int[] = [| 10; 20; 30; 40; 50 |]

    // Prints each element of the array
    Array.iter (fun x -> printfn "%d" x) arr 

    0 // Return exit code 0 to indicate successful execution

Map and Filter

F# provides Array.map and Array.filter functions for transforming and filtering array elements, respectively:

[<EntryPoint>]
let main(args: string[]): int =

    let arr = [| 1; 2; 3; 4; 5 |]

    // doubledArray = [|2; 4; 6; 8; 10|]
    let doubledArray = Array.map (fun x -> x * 2) arr 

    // Print the doubled array to the console
    printfn "%A" doubledArray

    // evenNumbers = [|2; 4|]
    let evenNumbers = Array.filter (fun x -> x % 2 = 0) arr 

    // Print the even numbers array to the console
    printfn "%A" evenNumbers

    0 // Return exit code 0 to indicate successful execution

Sorting

The Array.sort function sorts the elements of an array in ascending order, returning a new array:

[<EntryPoint>]
let main(args: string[]): int =

    let arr = [| 5; 1; 4; 2; 3 |]

    // sortedArray = [| 1; 2; 3; 4; 5 |]
    let sortedArray: int[] = Array.sort arr
    
    printfn "%A" sortedArray

    0 // Return exit code 0 to indicate successful execution

Conclusion

Arrays are a fundamental data structure in F# that allow you to store and manipulate collections of elements efficiently. In this article, we covered the basics of creating arrays, accessing and modifying elements, and explored some common operations and functions available for array manipulation in F#. With this knowledge, you’ll be well-equipped to work with arrays and harness their power in your F# programs.

Sources: