Home

Lists

 

Fundamentals of Lists

 

Overview of Lists

A list is a group of constant values of the same type. The list if immutable, meaning that once the list is created, it cannot change (we will see that you can add new items to the list but then you get a new list, the original list stays "as is").

Introduction to Creating a List

To create a list, start with an opening square bracket "[" and end with a closing square bracket "]". Inside the brackets, create the members of the list. Each member ends with a semicolon. Here are examples:

// Numbers
[ 12; 22; 48; 115; 306; ];
// Characters
[ 'c'; 'd'; 'g'; 'j'; 'm'; ];
// Names
[ "Frank"; "James"; "Joshua"; "Mary"; ];

The semicolon on the last member is optional. On the other hand, you don't have to create all members on the same line. In fact, you can write the square brackets on their own lines and the members on a separate line after the opening square bracket. Here is an example:

[
"Frank"; "James"; "Joshua"; "Mary";
];

Although you don't have to indent, indentation makes the list easier to read:

[
    "Frank"; "James"; "Joshua"; "Mary";
];

Another alternative is to have each member of the list on its own line. Here is an example:

[
    "Frank";
    "James";
    "Joshua";
    "Mary";
];

If you decide to create each member on its own line, you can omit the semicolons. Here are examples:

[
    "Frank"
    "James"
    "Joshua"
    "Mary"
];

An Empty List

An empty list is one that doesn't have any item, but it is still considered a list. To create an empty list, use the square brackets but leave them empty. Here is an example:

[]

Naming a List

A list is a kind of variable. Although you can use it without naming it, if you plan to refer to it in different parts of your code, you should give it a name. To do this, declare a variable using the let keyword, followed by a name for the variable, and assign the list to it. Here is an example:

let numbers = [ 12; 22; 48; 115; 306 ]

Remember that the items can be separated from the square brackets by different lines:

let characters = [
    'c'; 'd'; 'g'; 'j'; 'm'
];

To store an empty in a variable, assign empty square brackets to it. Here is an example:

let numbers = []

Creating a Simple Range

A list is a series of arranged items. If you use the items that are known in advance and they are consecutive, you can specify only the beginning and end of the series. When creating the list, in the square brackets, type the starting item, followed by .., and followed by the ending item. It is a good idea to put a space before and after .. to make it easier to read. Here are examples:

// A range of numbers
[ 2 .. 8 ];
// A range of letters
[ 'h' .. 'q' ];

Creating a Range From a Loop

Instead of creating a range from known constant values, you can use a for loop that indicates only the begining and ending values. The basic formula is:

[ for VariableName in Range -> body ]

The VariableName can be any lowercase letter or any name. The Range is usually specified as Start Value .. End Value. The body of the loop is created after the -> sign. It can simply consist of the VariableName . Here is an example:

[ for variable in 1 .. 8 -> variable ]

This is equivalent to numbers from 1 to 8:

[1; 2; 3; 4; 5; 6; 7; 8]

Yielding an Item From a Loop

An alternative to use the -> operator is to use the do yield expression. Here is an example:

[ for variable in 1 .. 8 do yield variable ]

A Skip Range

When you create a range, you specify the starting and the ending values. When the range is processed, the compiler will add 1 to the first value to get the second value. Then it would add 1 to each subsequent value to get the next value, until that next value is immediately less than or equal to the ending value. Instead of adding 1 to each value to get the next, you may want to use another incrementing scheme. That type of range is created using the skip range operator representd by .. ..

The formula to create a skip range is:

Start .. Step .. End

The algorithm works as follows:

  • Start is the value by which to start
  • End is the value by which the count will stop
  • Then:
    • Step is first value added to Start to get the New value
    • The New value is compared to the End value. If the New value is lower than the End value + Step, Step is added again to the New value
    • Once the New value becomes higher than the End value, the operation stops

Here is an example:

[ 3 .. 2 .. 20 ]

In this case, the range would start at 3. The value 2 would be added to the first, 3, to get the next. Then 2 would be added to the new value, and so on, until the new number is immediately lower than the last number specified in the range:

Numbers: [ 3; 5; 7; 9; 11; 13; 15; 17; 20 ]

As a consequence, the End value is included in the result if it gets out of range when the step is added to the previous value.

Looping a List

 

For Looping to an End

Looping consists of going through a series of values from a starting point to an ending point. The formula to follow is:

for identifier = start [ to | downto ] end do
   body

The for, the to, and the do keywords are required. The downto keyword can be used in place of the do keyword in some cases we will see. The identifier is a name used to specify a local variable that will hold the current value as the series is being scanned. start represents the value by which to start counting and end is the value by which to stop. The body of the looping operation starts with the do keyword but is written on the next line. That body can contain any code you see fit. Here is an example that displays some numbers being counted:

for i = 1 to 5 do
    printfn "Number: %d" i

This would produce:

Number: 1
Number: 2
Number: 3
Number: 4
Number: 5
Press any key to continue . . .

The start and end values can also come from previously declared variables.

For Looping in a Range

It is possible to loop in a range of values. The formula to follow is:

for identifier in range do
   body

In this case, the range can consist of a starting and an ending values separated by two periods. Here is an example:

for i in 1 .. 5 do
    printfn "Number: %d" i;

This would produce the same result as above.

Looping While a Value Exists

Instead of counting from a starting value to a known end, you may want to execute a statement from a begining value but continue as long as a certain condition exists. This is done using the while keyword. The formula to follow is:

while Condition do
    body

The while and the do keywords are required. The Condition is something that needs to be checked. It could be a conditional operation or anything that can produce a true or false result. After the do keyword, create a body for the loop. Here is an example:

let mutable a = 1;

while a < 6 do
    printfn "Number: %d" a;
    a <- a + 1;

Creating Items From an Expression

Most of the time, you will create a looping range because you want the numbers to follow a certain pattern instead of simply incrementing. Here is an example:

[ for variable in 0 .. 15 -> variable * 5 ]

Although each member of a list must be a constant value, each value can be created from an expression. Here is an example:

[ for variable in 0 .. 15 do yield variable * 5 ]

Using a List

 

Introduction

To present a list of items, you can call the printf() or the printfn() function and use %A as the placeholder. If you had previously declared a variable for a list and had initialized it, you can specify its name as the placeholder of the printf() or the printfn() function. Here is an example:

let names = [ "Frank"; "James"; "Joshua"; "Mary" ];
printfn "%A" names;

This would produce:

["Frank"; "James"; "Joshua"; "Mary"]
Press any key to continue . . .

Instead for first declaring the variable, we saw that you can create a name-less list. In this case, you can provide that list directly in the placeholder. Here is an example:

printfn "%A" [ "Frank"; "James"; "Joshua"; "Mary" ];

You can also write the items on different lines. Here is an example:

printfn "%A" [
    "Frank"
    "James"
    "Joshua"
    "Mary"
];

This would produce:

["Frank"; "James"; "Joshua"; "Mary"]
Press any key to continue . . .

Either way, this means that you don't have to first declare a variable for a list. You can just create the list directly where it is needed.

In the same way, you can use %A to show the values created from a range. Here is an example:

let range = [3 .. 12 ]
 
printfn "Numbers: %A" range;

This would produce:

Numbers: [3; 4; 5; 6; 7; 8; 9; 10; 11; 12]
 
Press any key to continue . . .

You use the same technique for a skip-range. Here is an example:

let skipRange = [3 .. 2 .. 20 ]
 
printfn "Numbers: %A" skipRange;

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
Press any key to continue . . .

For Each Item in a List

To help you visit each member of a list, the F# language provides looping operation that uses the for keyword. The formula to follow is:

for identifier / pattern in list do
   body

The for, the in, and the do keywords are required. The identifier could be a variable name that will hold the value to be retrieved from the list. Here is an example:

for i in [ "Frank"; "James"; "Joshua"; "Mary" ] do
    printfn "Name: %s" i;

This would produce:

Name: Frank
Name: James
Name: Joshua
Name: Mary
Press any key to continue . . .

As Long As (while) it is not the End of the List

Besides (or instead of) a for loop, you can use the while operator to visit each member of the list. As done for the for, if you decide (or want, or have) to use while, make sure you specify where and how to start the visit and where and how to end. You can first declare an integer variable and assign it the desired starting value. In the body of the while statement, visit each member of the list. If you are using an integer variable, you can incrementing it each time to move to the next value. Here is an example:

let mutable i = 0

let names = [ "Frank"; "James"; "Joshua"; "Mary" ]
while i < names.Length  do
    printfn "Name: %s" names.[i];
    i <- i + 1

A List in a List

In the lists we have created so far, we treated each item as a primitive type. In reality, each member of the list is considered a complete type and could be anything, including its own list. To make a list a member of another list, in the placeholder of the list, create the list just as we have done so far, using its own square brackets. If you decide to use this technique, all list items must be the same type of list but they can have different numbers of items. Here is an example:

let names = [ ["Joshua"; "Morrison"]; ["Frank"; "Aaron"; "Xaviera"]; ["James"; "Lalong"] ];
printfn "%A" names;

To make the code easier to read, you can type the individual list on their own lines. Here is an example:

let names =
    [
	["Joshua"; "Morrison"];
	["Frank"; "Aaron"; "Xaviera"];
	["James"; "Lalong"]
    ];

Operations on a List

 

Introduction

In the F# language, lists are represented by a module named List. The module is defined in the Microsoft.FSharp.Collections namespace. To provide some characteristics to a list, the Microsoft.FSharp.Collections namespace provides a generic union named List. This union is quipped with two constructors (operators) and various propertites.

An Empty List

We saw that, to create an empty list, you can assign empty square brackets [] to it. Alternatively, to let you create an empty list, the List module is equipped with a function named empty. Here is an example of calling it and getting its value:

let noTenant = List.empty;
 
printfn "Tenants: %A" noTenant

After creating a list and while using it, at any time, to let you find out whether the list has no item, the List union is equipped with a Boolean property named IsEmpty.

The Number of Items in a List

The number of items in a list is referred to as its length. To support it, the List union contains a property named Length.Its equivalent in the List module is the length() function. Its signature is:

List.length : 'T list -> int

As you can see, this function takes a list as argument and it returns an integer as the number of items in the list.

 

Getting an Item Based on Its Index

The items of a list are stored in a zero-based series. The first item occupies the 0 position. The second item occupied the 1 position, and so on. To let you get to an item based on its position+1 in the list, the List union is equipped with an indexed property named Item. Here is an example of using the property:

let numbers = [ 3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let sixth = numbers.Item(5)
printfn "6th Member: %d\n" sixth

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
6th Member: 13
 
Press any key to continue . . .

In the same way, you can access any member of the list based on its position. Make sure you provide an index that is less than or equal to the number of items - 1. If you provide a number beyond the number of items, you will get an error.

Introductory Operations on Lists

 

Checking Whether a List is Empty

We know that, to create an empty list, you can assign empty square brackets [] to it. Here is an example:

let numbers = []
 
printfn "Numbers: %A" numbers

This would produce:

Numbers: []
Press any key to continue . . .

To let you find out whether the list is empty, you can use the match operator with an option as []. If that option is valid, it means that the list of empty. The other option can be and underscore, which means that the list contains at least one item. Here are examples:

let numbers = []
let names = [ "Frank"; "James"; "Joshua"; "Mary" ]
 
match numbers with
| [] -> printfn "The list is empty"
| _ -> printfn "Numbers: %A" numbers
 
match names with
| [] -> printfn "There is no name in the list"
| _ -> printfn "Name: %A" names

This would produce:

The list is empty
Name: ["Frank"; "James"; "Joshua"; "Mary"]
Press any key to continue . . .

Attaching an Item to a List

As mentioned already, a list is immutable. As an alternative, you can add (a) new item(s) to the list but you would get a new, different list, that contains the original item(s) and the new one(s). To let you perform this operation, the List union is equipped with, or defines, an operator as ::. To use it, start with the let operator and a new name, assign the new value to it, followed by :: and the original list. Here is an example:

let names = [ "Frank"; "James"; "Joshua"; "Mary" ];
 
printfn "%A" names;
 
let additional = "Gabriel" :: names;
printfn "%A" additional;

This would produce:

["Frank"; "James"; "Joshua"; "Mary"]
["Gabriel"; "Frank"; "James"; "Joshua"; "Mary"]
Press any key to continue . . .

Keep in mind that the original list has not changed:

// Names
let names = [ "Frank"; "James"; "Joshua"; "Mary" ];
 
printfn "%A" names;
 
let additional = "Gabriel" :: names;
printfn "%A" additional;
 
printfn "%A" names;

This would produce:

["Frank"; "James"; "Joshua"; "Mary"]
["Gabriel"; "Frank"; "James"; "Joshua"; "Mary"]
["Frank"; "James"; "Joshua"; "Mary"]
Press any key to continue . . .

Concatenating Some Lists

Concatening two list consists of adding them. To perform this operation, use the @ operator in place of +. The lists must be compatible. Here is an example:

let parents  = [ "Frank"; "James"; "Joshua"; "Mary" ];
let students = [ "Hermine"; "Sebastien"; "Lester" ];
 
printfn "Parents:  %A" parents;
printfn "Students: %A" students;
 
printfn "\nFamilies: %A"  (parents @ students);

This would produce:

Parents:  ["Frank"; "James"; "Joshua"; "Mary"]
Students: ["Hermine"; "Sebastien"; "Lester"]
 
Families: ["Frank"; "James"; "Joshua"; "Mary"; "Hermine"; "Sebastien"; "Lester"]
 
Press any key to continue . . .

If you plan to use the result many times, you can store it in a variable. To do this, assign the concatenation to the variable. Here is an example:

let parents  = [ "Frank"; "James"; "Joshua"; "Mary" ];
let students = [ "Hermine"; "Sebastien"; "Lester" ];
let families = parents @ students;
 
printfn "Parents:  %A" parents;
printfn "Students: %A" students;
 
printfn "Families: %A" families;

As an alternative to the @ operator, the List module provides a function named append. Its signature is:

List.append : 'T list -> 'T list -> 'T list

This function takes two arguments that each is a list. The function returns a list. Here is an example of calling it:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
let fullTimeEmployeesPayrolls = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                                  Employee("5031-9259", EmploymentStatus.FullTime, 55000.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00);
                                  Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
let otherEmployeesPayrolls    = [ Employee("9270-8039", EmploymentStatus.PartTime, 15800.00); Employee("2807-4083", EmploymentStatus.Seasonal, 22400.00);
                                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00) ]
                                  
let payrollSummary = List.append fullTimeEmployeesPayrolls otherEmployeesPayrolls
 
printfn "Fixed Salaried Employee Payroll"
printfn "==================================="
printfn "           Weekly \tYearly"
printfn "Empl #      Time\tSalary"
printfn "-----------------------------------"
for payroll in payrollSummary do
    printfn "%s  %A\t%0.0f" payroll.EmployeeNumber payroll.EmploymentStatus (payroll.WeeklySalary())
printfn "===================================\n"

This would produce:

Fixed Salaried Employee Payroll
===================================
           Weekly       Yearly
Empl #      Time        Salary
-----------------------------------
9749-8075  FullTime     60000
2038-4051  FullTime     82000
5031-9259  FullTime     55000
7092-3094  FullTime     104000
2903-0481  FullTime     88500
5020-4681  FullTime     65200
9270-8039  PartTime     15800
2807-4083  Seasonal     22400
2405-8296  Seasonal     35400
2813-3044  PartTime     32500
===================================
 
Press any key to continue . . .

Lists and Functions

   

Creating Items From a Function

Although each member of a list must be a constant value, each value can be created from a function. In the square brackets, call the function every time you need a value. If the function pakes a parameters, make sure you pass the appropriate and necesary argument. Here is an example:

let multiply x = x * 2.27

let numbers = [ multiply 1.26; multiply 88.03; multiply 7.25; multiply 15.58 ]

for n in numbers do
    printfn "Number: %0.04f" n

This would produce:

Number: 2.8602
Number: 199.8281
Number: 16.4575
Number: 35.3666
Press any key to continue . . .

As an option, you can precede each function call with the yield keyword. Here is an example:

let multiply x = x * 2.27

let numbers = [ yield multiply 1.26; yield multiply 88.03; yield multiply 7.25; yield multiply 15.58 ]

for n in numbers do
    printfn "Number: %0.04f" n

To add the values to the list, you can create a for loop that uses a range and calls the function to which you pass each value of the range. Here is an example:

let add x = x + x
let numbers = [ for variable in 1 .. 8 -> add variable ]
 
printfn "Numbers: %A" numbers

Remember that you can use do yield instead of ->. Here is an example:

let add x = x + x
let numbers = [ for variable in 1 .. 8 do yield add variable ]
 
printfn "Numbers: %A" numbers

This would produce:

Numbers: [2; 4; 6; 8; 10; 12; 14; 16]
Press any key to continue . . .

Of course, you can have a more complicated function than that. You can also generate values from the method of a class.

Returning a List from a Function

You can create a function that returns a list. To do this, make sure the last assignment of the function is a list. Here is an example:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00]

In other words, when a function has finished its assignment, you can make sure its last statement is a list. Here is an example:

let specifyWeeklyTime() =
    let monday    =  8.50
    let tuesday   =  9.50
    let wednesday =  8.00
    let thursday  = 10.00
    let friday    =  9.00
    let saturday  =  0.00
    let sunday    =  0.00
    
    [ monday; tuesday; wednesday; thursday; friday; saturday; sunday; ]

In fact, a function can simply return a variable as long as that variable represents a list. Here is an example:

let specifyWeeklyTime() =
    let monday    =  8.50
    let tuesday   =  9.50
    let wednesday =  8.00
    let thursday  = 10.00
    let friday    =  9.00
    let saturday  =  0.00
    let sunday    =  0.00
    
    let times = [ monday; tuesday; wednesday; thursday; friday; saturday; sunday; ]
    times // The returned variable, a list

You can then use that returned value outside of the function. Here is an example:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00]
 
printfn "Weekly Time: %A" (specifyWeeklyTime())

You can also get the returned list and store it in a variable before using it. Here is an example:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00]
 
let times = specifyWeeklyTime()
printfn "Weekly Times: %A" times

This would produce:

Weekly Time: [8.5; 9.5; 8.0; 10.0; 9.0; 0.0; 0.0]
Press any key to continue . . .

Once you have a variable that holds a list, you can access each member of that list. Here is an example:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00]
 
let times = specifyWeeklyTime()
 
for time in times do
    printfn "Time: %0.02f" time

This would produce:

Time: 8.50
Time: 9.50
Time: 8.00
Time: 10.00
Time: 9.00
Time: 0.00
Time: 0.00
Press any key to continue . . .

Just like a function can return one list, it can return as many as you want. For example, you can create a function that returns a list of lists. Here is an example:

let specifyWeeklyTimes() =
    [ [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00];
      [ 6.00; 8.00; 9.00;  7.00; 8.00; 0.00; 0.00]; ]
 
printfn "Weekly Time: %A\n" (specifyWeeklyTimes())
 
let times = specifyWeeklyTimes()
 
for week in times do
    for time in week do
        printfn "Time: %0.02f" time

In the same way, you can return as many lists as you want.

A List as Parameter

A function can receive a parameter that is a list and treat it accordingly. Because F# is an inferred language, you can just pass the name of a parameter without a data type, and then use the parameter in the function as if that parameter were a list. Here is an example:

let displayWeeklyTimes(listOfTimes) =
    printfn "Weekly Time: %A" listOfTimes

Normally, at this time, the compiler doesn't know what type of parameter this is, and that parameter could be anything. When calling the function, pass a list as argument and the compiler will apply the appropriate rules based on the type of argument you passed. Here are examples:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00];
 
let displayWeeklyTimes(listOfTimes) =
    printfn "Weekly Time: %A" listOfTimes
 
displayWeeklyTimes(specifyWeeklyTime())
printfn "--------------------------------------------------"

This would produce:

Weekly Time: [8.5; 9.5; 8.0; 10.0; 9.0; 0.0; 0.0]
--------------------------------------------------
Press any key to continue . . .

As mentioned already, when creating a function that takes a list as parameter, you can just specify a name for the parameter. Since you know that the parameter is a list, in  the body of the function, treat the argument as a list, using all approriate rules of lists. For example, you can use a loop on the parameter. Here is an example:

let specifyWeeklyTime() =
    [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00];
 
let displayWeeklyTimes(listOfTimes) =
    printfn "Weekly Time: %A" listOfTimes
 
let times = specifyWeeklyTime()
 
let showWeeklyTimes(listOfTimes) =
    for time in listOfTimes do
        printfn "Time: %0.02f" time
 
displayWeeklyTimes(times)
printfn "--------------------------------------------------"
showWeeklyTimes(times)
printfn "--------------------------------------------------"

This would produce:

Weekly Time: [8.5; 9.5; 8.0; 10.0; 9.0; 0.0; 0.0]
--------------------------------------------------
Time: 8.50
Time: 9.50
Time: 8.00
Time: 10.00
Time: 9.00
Time: 0.00
Time: 0.00
--------------------------------------------------
Press any key to continue . . .

In the same way, you can pass a parameter that is a list of lists (or a list of lists of lists...) and process it appropriately.

Lists and Tuples

 

Creating a Range From a Tuple

Lists are very important in functional programming. To enhance the functionalities of lists, the F# language provides various built-in operators and functions.

Tuples provide the ability to create a range from two members of a tuple:

  • The tuple has to include two numeric or letter members
  • The first or left member has to be lower than the second or right member

When the .. operator is applied on both members, the result is a range that includes both values and the values between them. Here is an example:

let range(a, b) = 
    [a .. b];
 
let result = range(2, 8);
printfn "Values from a range: %A" result;

This would produce:

Values from a range: [2; 3; 4; 5; 6; 7; 8]
Press any key to continue . . .

You can also provide non-readable characters. In this case, the compiler would try to find their range. Here is an example:

let range(a, b) = 
    [a .. b];
 
let result = range('$', '*');
printfn "Values from a range: %A" result;

This would produce:

Values from a range: ['$'; '%'; '&'; '\''; '('; ')'; '*']
Press any key to continue . . .

Either way, if the compiler cannot find values between both members of the tuple, in which case it cannot create a range, the compiler would produce an empty range [].

Creating a Skip Range From a Tuple

A skip range is a technique of specifying the starting value of a range, the end value of a range, and the value to add to each value to get the next one. You can get such a skip-range from a tuple. Here is an example:

let range(a, b, c) = 
    [a .. b .. c];
 
let result = range(2, 3, 16);
printfn "Values from a skip-range: %A" result;

This would produce:

Values from a skip-range: [2; 5; 8; 11; 14]
Press any key to continue . . .

A List of Tuples

You can create a list where each element is a tuple. Here is an example:

let timesWorked = [("Monday", 8.00); ("Tuesday", 9.00); ("Wednesday", 8.50); ("Thursday", 8.00); ("Friday", 8.50)]

You can then access the elements. For example, you can use %A to represent the list. Here is an example:

let timesWorked = [("Monday", 8.00); ("Tuesday", 9.00); ("Wednesday", 8.50); ("Thursday", 8.00); ("Friday", 8.50)]

printfn "Times Worked: %A" timesWorked

This would produce:

Times Worked: [("Monday", 8.0); ("Tuesday", 9.0); ("Wednesday", 8.5); ("Thursday", 8.0); ("Friday", 8.5)]
Press any key to continue . . .

You can also use a for loop to access each tuple. Here is an example:

let timesWorked = [("Monday", 8.00); ("Tuesday", 9.00); ("Wednesday", 8.50); ("Thursday", 8.00); ("Friday", 8.50)]

for t in timesWorked do
    printfn "Time Worked: %A" t

This would produce:

Time Worked: ("Monday", 8.0)
Time Worked: ("Tuesday", 9.0)
Time Worked: ("Wednesday", 8.5)
Time Worked: ("Thursday", 8.0)
Time Worked: ("Friday", 8.5)
Press any key to continue . . .

You can also use any technique of your choice to decompose the tuples and access their individual values. Here is an example:

let timesWorked = [("Monday", 8.00); ("Tuesday", 9.00); ("Wednesday", 8.50); ("Thursday", 8.00); ("Friday", 8.50)]

printfn "Time Worked"
printfn "-----------------"
for t in timesWorked do
    let a, b = t
    printfn "%s: %0.02f" a b
printfn "================="

This would produce:

Time Worked
-----------------
Monday: 8.00
Tuesday: 9.00
Wednesday: 8.50
Thursday: 8.00
Friday: 8.50
=================
Press any key to continue . . .

A Tuple of Lists

You can have a tuple whose elements are lists each. Here is an example:

let timesWorked = ([8.00; 9.00; 8.50; 8.00; 8.50], [8.50; 9.50; 8.00; 10.00; 9.00])

printfn "Work for 2 weeks: %A" timesWorked

This would produce:

Work for 2 weeks: ([8.0; 9.0; 8.5; 8.0; 8.5], [8.5; 9.5; 8.0; 10.0; 9.0])
Press any key to continue . . .

You can then decompose the tuple to get each list. Here is an example:

let timesWorked = ([8.00; 9.00; 8.50; 8.00; 8.50], [8.50; 9.50; 8.00; 10.00; 9.00])

let a, b = timesWorked
printfn "Work 1 time worked: %A" a
printfn "Work 2 time worked: %A" b

This would produce:

Work 1 time worked: [8.0; 9.0; 8.5; 8.0; 8.5]
Work 2 time worked: [8.5; 9.5; 8.0; 10.0; 9.0]
Press any key to continue . . .

To access the individual elements of each list, you have various options. You can use a for loop to visit each element of the list. Here are examples:

let timesWorked = ([8.00; 9.00; 8.50; 8.00; 8.50], [8.50; 9.50; 8.00; 10.00; 9.00])

let (a, b) = timesWorked

printfn "Work 1 time worked"
for t in a do
    printfn "%0.02f" t

printfn "Work 2 time worked"
for t in b do
    printfn "%0.02f" t

This would produce:

Work 1 time worked
8.00
9.00
8.50
8.00
8.50
Work 2 time worked
8.50
9.50
8.00
10.00
9.00
Press any key to continue . . .
public void SymmetricExceptWith(IEnumerable<T> other);

You can also store each list in a (temporary) variable. Here are examples:

let timesWorked = ([8.00; 9.00; 8.50; 8.00; 8.50], [8.50; 9.50; 8.00; 10.00; 9.00])

let (a, b) = timesWorked

let week1 = [for t in a do yield t]
let week2 = [for t in b do yield t]

printfn "Work 1 time worked: %A" week1
printfn "Work 2 time worked: %A" week2

This would produce:

Work 1 time worked: [8.0; 9.0; 8.5; 8.0; 8.5]
Work 2 time worked: [8.5; 9.5; 8.0; 10.0; 9.0]
Press any key to continue . . .

Once you have each list, you can use it using any of the techniques and features of an F# list.

Lists and Records

   

A List of Records

The members of a list can come from a record. You can first define a record, create objects from it, and use them as members of a list. Here is an example:

type OccupancyStatus =
| Other       = 0
| Available   = 1
| Occupied    = 2
| NeedsRepair = 3
 
type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }
 
let a399475 = { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
let a508293 = { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
let a729397 = { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }

Instead of first creating the objects, you can add them directly in the list. Here is an example:

let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
 ]

After doing this, you can access each member of the list as an individual record. Here is an example:

type OccupancyStatus =
| Other       = 0
| Available   = 1
| Occupied    = 2
| NeedsRepair = 3
 
type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }
 
let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   } ]
 
for apart in apartments do
    printfn "Apartment Record: %A" apart

This would produce:

Apartment Record: {UnitNumber = "102";
 Bedrooms = 1;
 Bathrooms = 1.0;
 SecurityDeposit = 500;
 MonthlyRate = 950;
 Status = NeedsRepair;}
Apartment Record: {UnitNumber = "103";
 Bedrooms = 1;
 Bathrooms = 1.0;
 SecurityDeposit = 500;
 MonthlyRate = 925;
 Status = Available;}
Apartment Record: {UnitNumber = "104";
 Bedrooms = 3;
 Bathrooms = 2.0;
 SecurityDeposit = 850;
 MonthlyRate = 1350;
 Status = Occupied;}
Apartment Record: {UnitNumber = "105";
 Bedrooms = 2;
 Bathrooms = 1.0;
 SecurityDeposit = 550;
 MonthlyRate = 1150;
 Status = Available;}
Press any key to continue . . .

Or you can access each member of the record from the variable of the list. Here is an example:

type OccupancyStatus =
| Other       = 0
| Available   = 1
| Occupied    = 2
| NeedsRepair = 3
 
type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }
 
let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   } ]
 
printfn "====================================================="
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in apartments do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"

This would produce:

=====================================================
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
101     2       2.00    1150    650     Available
102     1       1.00    950     500     NeedsRepair
103     1       1.00    925     500     Available
104     3       2.00    1350    850     Occupied
105     2       1.00    1150    550     Available
-----------------------------------------------------
Press any key to continue . . .
 
   

Lists and Classes

 

Objects as Members of a List

The members of a list can be anything, as long as all of them are of the same type. This means that you can use the basis for members of a list. Of course you must have a class. You can use one of the classes of the .NET Framework or you can create your own class. You can then create objects of your chosen class and use those objects as members of a list. Here is an example:

type Employee(emplNbr, salary, monday, tuesday, wednesday, thursday, friday, saturday, sunday) =
    member val EmployeeNumber = emplNbr with get, set
    member val HourlySalary = salary with get, set
    member this.CalculateWeeklyTime() =
        monday + tuesday + wednesday + thursday + friday + saturday + sunday
    member this.CalculateWeeklySalary() =
        salary * this.CalculateWeeklyTime()
 
let empl1 = Employee("2080-4813", 22.25, 8.50, 9.50, 8.00, 10.00,  9.00, 0.00, 0.00)
let empl2 = Employee("4029-3940", 26.88, 8.00, 8.00, 8.00,  8.00,  8.00, 0.00, 0.00)
let empl3 = Employee("8485-2082", 15.55, 6.50, 7.00, 8.00,  6.00,  7.00, 0.00, 0.00)
let empl4 = Employee("3924-8816", 34.52, 9.00, 8.50, 9.50,  9.50, 10.00, 0.00, 0.00)
let empl5 = Employee("1831-2039", 25.55, 8.00, 6.50, 6.00,  6.00,  7.50, 0.00, 0.00)
 
let employeesPayrolls = [ empl1; empl2; empl3; empl4; empl5 ];

Instead of first declaring individual variables, you can create the objects directly in the list. Here is an example:

let employeesPayrolls = [
    Employee("2080-4813", 22.25, 8.50, 9.50, 8.00, 10.00,  9.00, 0.00, 0.00)
    Employee("4029-3940", 26.88, 8.00, 8.00, 8.00,  8.00,  8.00, 0.00, 0.00)
    Employee("8485-2082", 15.55, 6.50, 7.00, 8.00,  6.00,  7.00, 0.00, 0.00)
    Employee("3924-8816", 34.52, 9.00, 8.50, 9.50,  9.50, 10.00, 0.00, 0.00)
    Employee("1831-2039", 25.55, 8.00, 6.50, 6.00,  6.00,  7.50, 0.00, 0.00) ];

Either way, you can access the members of the class and use them as you see fit. Here is an example:

type Employee(emplNbr, salary, monday, tuesday, wednesday, thursday, friday, saturday, sunday) =
    member val EmployeeNumber = emplNbr with get, set
    member val HourlySalary = salary with get, set
    member this.CalculateWeeklyTime() =
        monday + tuesday + wednesday + thursday + friday + saturday + sunday
    member this.CalculateWeeklySalary() = salary * this.CalculateWeeklyTime()
 
let empl1 = Employee("2080-4813", 22.25, 8.50, 9.50, 8.00, 10.00,  9.00, 0.00, 0.00)
let empl2 = Employee("4029-3940", 26.88, 8.00, 8.00, 8.00,  8.00,  8.00, 0.00, 0.00)
let empl3 = Employee("8485-2082", 15.55, 6.50, 7.00, 8.00,  6.00,  7.00, 0.00, 0.00)
let empl4 = Employee("3924-8816", 34.52, 9.00, 8.50, 9.50,  9.50, 10.00, 0.00, 0.00)
let empl5 = Employee("1831-2039", 25.55, 8.00, 6.50, 6.00,  6.00,  7.50, 0.00, 0.00)
 
let employeesPayrolls = [ empl1; empl2; empl3; empl4; empl5 ];
printfn "Employee Payroll Summary"
printfn "===================================================="
printfn "Empl #\t\tSalary\tWeekly Time\tWeekly Salary"
printfn "----------------------------------------------------"
for empl in employeesPayrolls do
    printfn "%s\t%0.02f\t%0.02f\t\t%0.02F" empl.EmployeeNumber empl.HourlySalary (empl.CalculateWeeklyTime()) (empl.CalculateWeeklySalary())
printfn "===================================================="

This would produce:

Employee Payroll Summary
====================================================
Empl #          Salary  Weekly Time     Weekly Salary
----------------------------------------------------
2080-4813       22.25   45.00           1001.25
4029-3940       26.88   40.00           1075.20
8485-2082       15.55   34.50           536.48
3924-8816       34.52   46.50           1605.18
1831-2039       25.55   34.00           868.70
====================================================
Press any key to continue . . .

As mentioned already, all the members of a list must be of the same type. You can use objects of different classes in a list. The main rule is that the classes must share a common ancestry.

In the same way, you can create many lists using a class, or you can create different lists using classes of your choice. Here are examples:

type Employee(emplNbr, salary) =
    member this.EmployeeNumber = emplNbr
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
type Salaried(emplNbr, salary, monday, tuesday, wednesday, thursday, friday, saturday, sunday) =
    inherit Employee(emplNbr, salary)
    member val HourlySalary = salary with get, set
    override this.WeeklyTime() =
        monday + tuesday + wednesday + thursday + friday + saturday + sunday
    override this.WeeklySalary() = salary * this.WeeklyTime()
 
let employeesPayrolls = [ Employee("9749-8075", 60000.00); Employee("2038-4051", 82000.00) ]
let salariedPayrolls  = [
      Salaried("2080-4813", 22.25, 8.50, 9.50, 8.00, 10.00,  9.00, 0.00, 0.00)
      Salaried("4029-3940", 26.88, 8.00, 8.00, 8.00,  8.00,  8.00, 0.00, 0.00)
      Salaried("8485-2082", 15.55, 6.50, 7.00, 8.00,  6.00,  7.00, 0.00, 0.00)
      Salaried("3924-8816", 34.52, 9.00, 8.50, 9.50,  9.50, 10.00, 0.00, 0.00)
      Salaried("1831-2039", 25.55, 8.00, 6.50, 6.00,  6.00,  7.50, 0.00, 0.00) ];
      
printfn "Fixed Salaried Employee Payroll"
printfn "===================================================="
printfn "           Weekly"
printfn "Empl #      Time    Yearly Salary"
printfn "----------------------------------------------------"
for empls in employeesPayrolls do
    printfn "%s    %0.0f       %0.0f" empls.EmployeeNumber (empls.WeeklyTime()) (empls.WeeklySalary())
printfn "====================================================\n"
 
printfn "Employee Payroll Summary"
printfn "===================================================="
printfn "Empl #\t\tSalary\tWeekly Time\tWeekly Salary"
printfn "----------------------------------------------------"
for empls in salariedPayrolls do
    printfn "%s\t%0.02f\t%0.02f\t\t%0.02F" empls.EmployeeNumber empls.HourlySalary (empls.WeeklyTime()) (empls.WeeklySalary())
printfn "===================================================="

This would produce:

Fixed Salaried Employee Payroll
====================================================
           Weekly
Empl #      Time    Yearly Salary
----------------------------------------------------
9749-8075    40       60000
2038-4051    40       82000
====================================================
 
Employee Payroll Summary
====================================================
Empl #          Salary  Weekly Time     Weekly Salary
----------------------------------------------------
2080-4813       22.25   45.00           1001.25
4029-3940       26.88   40.00           1075.20
8485-2082       15.55   34.50           536.48
3924-8816       34.52   46.50           1605.18
1831-2039       25.55   34.00           868.70
====================================================
Press any key to continue . . .

In the same way, you can create a list in a list (or a list in a list in a list...) or a list of lists (or a list of lists of lists...). Here is an example:

let employeesPayrolls = [
    [ Employee("9749-8075", 60000.00); Employee("2038-4051", 82000.00) ]
    [
        Salaried("2080-4813", 22.25, 8.50, 9.50, 8.00, 10.00,  9.00, 0.00, 0.00)
        Salaried("4029-3940", 26.88, 8.00, 8.00, 8.00,  8.00,  8.00, 0.00, 0.00)
        Salaried("8485-2082", 15.55, 6.50, 7.00, 8.00,  6.00,  7.00, 0.00, 0.00)
        Salaried("3924-8816", 34.52, 9.00, 8.50, 9.50,  9.50, 10.00, 0.00, 0.00)
        Salaried("1831-2039", 25.55, 8.00, 6.50, 6.00,  6.00,  7.50, 0.00, 0.00)
    ]
];

A List as a Property

A property of a class can be created from a list. We already know that a list can be passed to a function. This means that a parameter passed to the constructor of a class can represent a list. You can then use that parameter and assign it to a property. Here are examples:

type EmployeePayroll(emplNbr, name, salary, times) =
    member val EmployeeNumber = emplNbr with get, set
    member val FullName = name with get, set
    member val HourlySalary = salary with get, set
    member val WeeklyTimes = times with get, set

Once again, from these properties, the compiler doesn't know the data type of each parameter and a parameter can be anything. This also means that the compiler doesn't know whether a parameter is a list or not. When creating an object from the class, you can pass a list in the placeholder of an argument. Here are examples:

let ep = EmployeePayroll("2080-4813", [ "James"; "Roland"; "Alexanders" ], 22.25, [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00 ])

From that object, the compiler can infer the appropriate type of each parameter. You can then use each property as you see fit. Here are examples:

type EmployeePayroll(emplNbr, name, salary, times) =
    member val EmployeeNumber = emplNbr with get, set
    member val FullName = name with get, set
    member val HourlySalary = salary with get, set
    member val WeeklyTimes = times with get, set
 
let ep = EmployeePayroll("2080-4813", [ "James"; "Roland"; "Alexanders" ], 22.25, [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00 ])
 
printfn "Employee Payroll Summary"
printfn "----------------------------------------------------"
printfn "Employee #:    %s" ep.EmployeeNumber
printfn "Full Name:     %A" ep.FullName
printfn "Hourly Salary: %0.02F" ep.HourlySalary
printfn "Time Worked:   %A" ep.WeeklyTimes
printfn "----------------------------------------------------"

This would produce:

Employee Payroll Summary
----------------------------------------------------
Employee #:    2080-4813
Full Name:     ["James"; "Roland"; "Alexanders"]
Hourly Salary: 22.25
Time Worked:   [8.5; 9.5; 8.0; 10.0; 9.0; 0.0; 0.0]
----------------------------------------------------
Press any key to continue . . .

Remember that you can use a loop to access each member of a list. In the same way, once you have the value of a listed property, treat it as such. Here are examples:

type EmployeePayroll(emplNbr, name, salary, times) =
    member val EmployeeNumber = emplNbr with get, set
    member val FullName = name with get, set
    member val HourlySalary = salary with get, set
    member val WeeklyTimes = times with get, set
 
let ep = EmployeePayroll("2080-4813", [ "James"; "Roland"; "Alexanders" ], 22.25, [ 8.50; 9.50; 8.00; 10.00; 9.00; 0.00; 0.00])
 
printfn "Employee Payroll Summary"
printfn "----------------------------------------------------"
printfn "Employee #:    %s" ep.EmployeeNumber
printf "Full Name:     "
for name in ep.FullName do
    printf "%s " name
printfn "\nHourly Salary: %0.02F" ep.HourlySalary
printf "Time Worked:   "
for time in ep.WeeklyTimes do
    printf "%0.02f " time
printfn "\n----------------------------------------------------"

This would produce:

Employee Payroll Summary
----------------------------------------------------
Employee #:    2080-4813
Full Name:     James Roland Alexanders
Hourly Salary: 22.25
Time Worked:   8.50 9.50 8.00 10.00 9.00 0.00 0.00
----------------------------------------------------
Press any key to continue . . .

Operations on a List

 

Getting an Item Based on Its Index

As an alternative to the List.Item property, the List module is equipped with a static member function named nth. Its syntax is:

List.nth : 'T list -> int -> 'T

This function takes two arguments: a list variable and the index + 1 of the member you want to access. Here is an example of calling it:

let numbers = [3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let sixth = List.nth numbers 5
printfn "6th Member: %d\n" sixth

Remember that the first item is located at index 0. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
let employeesPayrolls = [ Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                          Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
let payroll = List.tail employeesPayrolls
 
printfn "Fixed Salaried Employee Payroll"
printfn "==================================="
printfn "           Weekly \tYearly"
printfn "Empl #      Time\tSalary"
printfn "-----------------------------------"
for i = 0 to employeesPayrolls.Length - 1 do
    printfn "%s  %A\t%0.0f" (List.nth employeesPayrolls i).EmployeeNumber (List.nth employeesPayrolls i).EmploymentStatus ((List.nth employeesPayrolls i).WeeklySalary())
printfn "===================================\n"

This would produce:

Fixed Salaried Employee Payroll
===================================
           Weekly       Yearly
Empl #      Time        Salary
-----------------------------------
2405-8296  Seasonal     35400
2813-3044  PartTime     32500
2903-0481  FullTime     88500
5020-4681  FullTime     65200
===================================
 
Press any key to continue . . .

Iterating Through a List

Iterating through a list consists of executing a function on each member of the list. One of the List functions used to perform this operation is called iter. Its signature is:

List.iter : ('T -> unit) -> 'T list -> unit

This function takes two arguments. The first is a function to use on each element. The second argument is a list. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                  Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
printfn "Fixed Salaried Employee Payroll"
printfn "==================================="
printfn "           Employment   \tYearly"
printfn "Empl #      Status\tSalary"
printfn "-----------------------------------"
 
List.iter (fun (empl : Employee) -> printfn "%s  %A\t%0.0f" empl.EmployeeNumber empl.EmploymentStatus empl.YearlySalary) employees

This would produce:

Fixed Salaried Employee Payroll
===================================
           Employment   Yearly
Empl #      Status      Salary
-----------------------------------
9749-8075  FullTime     60000
2038-4051  FullTime     82000
2405-8296  Seasonal     35400
2813-3044  PartTime     32500
2903-0481  FullTime     88500
5020-4681  FullTime     65200
Press any key to continue . . .

The First Member of a List

To let you get the first member of a list, the List union provides a property named Head. Here is an example of using this property:

let numbers = [3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let first = numbers.Head;
printfn "First Member: %d\n" first

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
First Member: 3
 
Press any key to continue . . .

To support this, the List module is equipped with a function named head. Its signature is:

List.head : 'T list -> 'T

Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
let employeesPayrolls = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                          Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00); ]
 
let payroll = List.head employeesPayrolls
 
printfn "Employee Payroll"
printfn "==================================="
printfn "Employee #:    %s" payroll.EmployeeNumber
printfn "Status:        %A" payroll.EmploymentStatus
printfn "Yearly Salary: %0.0f" (payroll.WeeklySalary())
printfn "===================================\n"

This would produce:

Employee Payroll
===================================
Employee #:    9749-8075
Status:        FullTime
Yearly Salary: 60000
===================================
 
Press any key to continue . . .

The Tail of a List

To let you get the list without the first item, the List union provides a property named Tail. Here is an example of using it:

let numbers = [3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let freeOne = numbers.Tail
printfn "List without first member: %A\n" freeOne

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
List without first member: [5; 7; 9; 11; 13; 15; 17; 19]
 
Press any key to continue . . .

To support the tail of a list, the List module has a function named tail. Its signature is:

List.tail : 'T list -> 'T list

Remember that the tail in this case is the list of items from the argument but without the first element. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
let employeesPayrolls = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                                  Employee("5031-9259", EmploymentStatus.FullTime, 55000.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00);
                                  Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
let payroll = List.tail employeesPayrolls
 
printfn "Fixed Salaried Employee Payroll"
printfn "==================================="
printfn "           Weekly \tYearly"
printfn "Empl #      Time\tSalary"
printfn "-----------------------------------"
for pay in employeesPayrolls do
    printfn "%s  %A\t%0.0f" pay.EmployeeNumber pay.EmploymentStatus (pay.WeeklySalary())
printfn "===================================\n"

This would produce:

Fixed Salaried Employee Payroll
===================================
           Weekly       Yearly
Empl #      Time        Salary
-----------------------------------
9749-8075  FullTime     60000
2038-4051  FullTime     82000
5031-9259  FullTime     55000
7092-3094  FullTime     104000
2903-0481  FullTime     88500
5020-4681  FullTime     65200
===================================
 
Press any key to continue . . .

The Last Member of a List

To get the last member of a list, you can call the List.Item property and pass the Length property - 1. Here is an example:

let numbers = [3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let last = numbers.Item(numbers.Length - 1);
printfn "Last Member: %d\n" last

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
Last Member: 19
 
Press any key to continue . . .

Replacing the First Member of a List

The List union is equipped with a static method used to create a new list by specifying the first member of your choice and existing members from another list. The method is called Cons. Its signature is:

static member List.Cons : 'T * 'T list -> 'T list

This method takes two arguments and returns a list. The first argument is the value that will be used as the first in the new list. The second argument is the list to which the first argument will be added. Here is an example of calling it:

let numbers = [3 .. 2 .. 20 ]
printfn "Numbers: %A\n" numbers
 
let additional = List.Cons(228, numbers.Tail)
printfn "Numbers: %A\n" additional

This would produce:

Numbers: [3; 5; 7; 9; 11; 13; 15; 17; 19]
 
Numbers: [228; 5; 7; 9; 11; 13; 15; 17; 19]
 
Press any key to continue . . .

If an Element Exists in a List

To let you find out whether a certain element exists in a list, the List module is equipped with a method named exists. Its signature is:

List.exists : ('T -> bool) -> 'T list -> bool

Here is an example of calling this method:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member WeeklyTime : unit -> double
    default this.WeeklyTime() = 40.00
    abstract member WeeklySalary : unit -> double
    default this.WeeklySalary() = salary
 
let employeesPayrolls = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                          Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                          Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
let exists nbr list : bool = List.exists (fun (empl : Employee) -> empl.EmployeeNumber = nbr) list
 
let result = exists "2405-8296" employeesPayrolls
printfn "The employee exists: %b" result

This would produce:

The employee exists: true
Press any key to continue . . .

In our example, we defined a function. As an alternative, we could simply have provided the arguments when calling the List.exists() method:

let res = List.exists (fun (empl : Employee) -> empl.EmployeeNumber = "2405-8296") employeesPayrolls

To let you compare elements from two different lists by their corresponding positions, the List module provides a function named exists2. Its signature is:

List.exists2 : ('T1 -> 'T2 -> bool) -> 'T1 list -> 'T2 list -> bool

Applying a Condition to all Items

To let you apply a certain condition to all elements of a list, the List module is equipped with a function named forAll. Its signature is:

List.forall : ('T -> bool) -> 'T list -> bool

This function takes two arguments. The first arguments is a Boolean function to apply to apply to the second argument. If at list one item of the list responds to the condition in the first argument, the function returns true. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 55000.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); ]
 
let areFullTimers = List.forall (fun (empl : Employee) -> empl.EmploymentStatus = EmploymentStatus.FullTime) employees;
 
printfn "Are all employees full-times? %b" areFullTimers

This would produce:

Are all employees full-times? true
Press any key to continue . . .

Here is another example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 55000.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                  Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00);
                  Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
let areFullTimers = List.forall (fun (empl : Employee) -> empl.EmploymentStatus = EmploymentStatus.FullTime) employees;
 
if areFullTimers = true then
    printfn "Are all employees full-times? Yes"
else
    printfn "Are all employees full-times? No"

This would produce:

Are all employees full-times? No
Press any key to continue . . .

Finding an Item in a List

To assist you with finding an item in a list, the List module provides a function named find. Its signature is:

List.find : ('T -> bool) -> 'T list -> 'T

Here are examples:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000); Employee("2038-4051", EmploymentStatus.FullTime, 82000);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400); Employee("2813-3044", EmploymentStatus.PartTime, 25500);
                  Employee("5031-9259", EmploymentStatus.FullTime, 25500); Employee("7092-3094", EmploymentStatus.FullTime, 104000); ]
 
let found = List.find (fun (empl : Employee) -> empl.EmployeeNumber = "2405-8296") employees
 
printfn "Employee Record"
printfn "==================================="
printfn "Employee #:    %s" found.EmployeeNumber
printfn "Status:        %A" found.EmploymentStatus
printfn "Yearly Salary: %i" found.YearlySalary
printfn "-----------------------------------"

This would produce:

Employee Record
===================================
Employee #:    2405-8296
Status:        Seasonal
Yearly Salary: 35400
-----------------------------------
Press any key to continue . . .

Picking an Item from a List

Picking an item from a list consists of applying a condition to it and selecting the first item that responds to that condition. To support this operation, the List module is equipped with a function named pick. Its signature is:

List.pick : ('T -> 'U option) -> 'T list -> 'U

This function takes two arguments. The first argument requires a matching condition and the second is the list that holds the items. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2928-7947", EmploymentStatus.PartTime, 30700.00);
                  Employee("2038-4051", EmploymentStatus.FullTime, 82000.00); Employee("5503-0485", EmploymentStatus.PartTime, 39580.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 15700.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 25500.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); ]
 
let picker = List.pick (fun (empl : Employee) -> 
    match empl.EmploymentStatus with
    | EmploymentStatus.PartTime -> Some(empl)
    | _ -> None) employees
 
printfn "Employee Record"
printfn "==================================="
printfn "Employee #:    %s" picker.EmployeeNumber
printfn "Status:        %A" picker.EmploymentStatus
printfn "Yearly Salary: %0.0f" picker.YearlySalary
printfn "-----------------------------------"

This would produce:

Employee Record
===================================
Employee #:    2928-7947
Status:        PartTime
Yearly Salary: 30700
-----------------------------------
Press any key to continue . . .

Sub-Lists

 

Filtering by Some Items

A sub-list is a list derived from an existing list. To create a sub-list, you have many options.

To select some items from a list, you can apply a criterion that would filter some items, put them in a new list, and return that list. To support this operation, the List module provides a function named filter. Its signature is:

List.filter : ('T -> bool) -> 'T list -> 'T list

This function takes a function and a list as arguments. The internal function applies a condition to each item of the list. Every item that responds to the condition is put in a new list. At the end, that list is returned from the List.filter() function. Here is an example:

type OccupancyStatus =
| Other
| Available
| Occupied
| NeedsRepair

type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }

let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "106"; Bedrooms = 3; Bathrooms = 1.50; SecurityDeposit = 950; MonthlyRate = 1425; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "107"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "108"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Occupied    }
 ]

let ready = List.filter (fun (apart : Apartment) -> apart.Status = OccupancyStatus.Available) apartments

printfn "====================================================="
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in ready do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"

This would produce:

=====================================================
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
101     2       2.00    1150    650     Available
103     1       1.00    925     500     Available
105     2       1.00    1150    550     Available
-----------------------------------------------------
Press any key to continue . . .

Choosing a Sub-List

Choosing a sub-list consists of applying a criterion to an existing list. The elements that respond to the condition would be selected and added to the new list. To assist you with this, the List module is equipped with a function named choose. Its signature is:

List.choose : ('T -> 'U option) -> 'T list -> 'U list

This function takes two arguments. The first is a function that includes a matching conditional statement. The second argument is the list on which the condition will be applied. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    abstract member YearlySalary : unit -> double
    default this.YearlySalary() = salary
 
let employeesPayrolls = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                          Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                          Employee("2903-0481", EmploymentStatus.FullTime, 88500.00); Employee("5020-4681", EmploymentStatus.FullTime, 65200.00); ]
 
let choose = List.choose (fun (empl : Employee) -> 
    match empl.EmploymentStatus with
    | EmploymentStatus.FullTime -> Some(empl)
    | _ -> None) employeesPayrolls
 
printfn "Employees Salary Summary"
printfn "=============================="
printfn "           \tYearly"
printfn "Empl #     \tSalary"
printfn "------------------------------"
for i = 0 to choose.Length - 1 do
    printfn "%s  \t%0.0f" (List.nth choose i).EmployeeNumber ((List.nth choose i).YearlySalary())
printfn "==============================\n"

This would produce:

Employees Salary Summary
==============================
                Yearly
Empl #          Salary
------------------------------
9749-8075       60000
2038-4051       82000
2903-0481       88500
5020-4681       65200
==============================
 
Press any key to continue . . .

Mapping Some Elements

Mapping elements consists of applying a condition on each element of a list to select only the items that follow that condition to produce a new derived list. To let you perform this operation, the List module provides a function named map. Its signature is:

List.map : ('T -> 'U) -> 'T list -> 'U list

Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime,  82000.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime,  15700.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 25500.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); ]
 
let mapped = List.map (fun (empl : Employee) -> empl.YearlySalary) employees
printfn "Salaries: %A" mapped;

This would produce:

Salaries: [60000.0; 82000.0; 35400.0; 15700.0; 25500.0; 104000.0]
ress any key to continue . . .

Partitioning a List

Particitioning a list consists of creating two lists derived from an existing one. To do this, you apply a condition to an existing list. The items that respond to the condition are put in a new list. The items that don't respond to the condition are put in another new list. To support this ├┤peration, the List module provides a function named partition. Its signature is:

List.partition : ('T -> bool) -> 'T list -> 'T list * 'T list

This function takes a function and a list as arguments. The function argument applies a condition to all members of the list. The function returns two lists. You can get the return value as two values or as a pair. Here is an example:

type OccupancyStatus =
| Other
| Available
| Occupied
| NeedsRepair

type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }

let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "106"; Bedrooms = 3; Bathrooms = 1.50; SecurityDeposit = 950; MonthlyRate = 1425; Status = OccupancyStatus.NeedsRepair   }
    { UnitNumber = "107"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "108"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Occupied   }
 ]

let (ready, not) = List.partition (fun (apart : Apartment) -> apart.Status = OccupancyStatus.Available) apartments

printfn "====================================================="
printfn "Available Apartments"
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in ready do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"
printfn "====================================================="
printfn "Apartments not Available"
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in not do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"

This would produce:

=====================================================
Available Apartments
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
101     2       2.00    1150    650     Available
103     1       1.00    925     500     Available
105     2       1.00    1150    550     Available
-----------------------------------------------------
=====================================================
Apartments not Available
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
102     1       1.00    950     500     NeedsRepair
104     3       2.00    1350    850     Occupied
106     3       1.50    1425    950     NeedsRepair
107     1       1.00    950     500     Occupied
108     2       1.00    1150    550     Occupied
-----------------------------------------------------
Press any key to continue . . .

Notice that the List.partition() function returns a tuple pair whose two elements are a list each. If one of both tuple members holds a list whose members can be segmented based on certain criterion, you can call the function on that member to get another tuple with sub-lists. Here is an example:

type OccupancyStatus =
| Other
| Available
| Occupied
| NeedsRepair

type Apartment = {
    UnitNumber      : string
    Bedrooms        : int
    Bathrooms       : float
    SecurityDeposit : int
    MonthlyRate     : int
    Status          : OccupancyStatus }

let apartments = [
    { UnitNumber = "101"; Bedrooms = 2; Bathrooms = 2.00; SecurityDeposit = 650; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "102"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.NeedsRepair }
    { UnitNumber = "103"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  925; Status = OccupancyStatus.Available   }
    { UnitNumber = "104"; Bedrooms = 3; Bathrooms = 2.00; SecurityDeposit = 850; MonthlyRate = 1350; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "105"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Available   }
    { UnitNumber = "106"; Bedrooms = 3; Bathrooms = 1.50; SecurityDeposit = 950; MonthlyRate = 1425; Status = OccupancyStatus.NeedsRepair   }
    { UnitNumber = "107"; Bedrooms = 1; Bathrooms = 1.00; SecurityDeposit = 500; MonthlyRate =  950; Status = OccupancyStatus.Occupied    }
    { UnitNumber = "108"; Bedrooms = 2; Bathrooms = 1.00; SecurityDeposit = 550; MonthlyRate = 1150; Status = OccupancyStatus.Occupied   }
 ]

//let (ready, not) = List.partition (fun (apart : Apartment) -> apart.Status = OccupancyStatus.Available) apartments
let (notAvailable, available) = List.partition (fun (apart : Apartment) -> apart.Status <> OccupancyStatus.Available) apartments
let (occupied, needsRepair) = List.partition (fun (apart : Apartment) -> apart.Status = OccupancyStatus.Occupied) notAvailable

printfn "====================================================="
printfn "Available Apartments"
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in available do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"
printfn "Occupied Apartments"
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in occupied do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"
printfn "Apartments that need repair"
printfn "\t\t\tMonthly"
printfn "Unit # Beds\tBaths\tRent\tDeposit Status"
printfn "-----------------------------------------------------"
for apart in needsRepair do
    printfn "%s\t%i\t%.2f\t%d\t%d\t%A" apart.UnitNumber apart.Bedrooms apart.Bathrooms apart.MonthlyRate apart.SecurityDeposit apart.Status
printfn "-----------------------------------------------------"

This would produce:

=====================================================
Available Apartments
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
101     2       2.00    1150    650     Available
103     1       1.00    925     500     Available
105     2       1.00    1150    550     Available
-----------------------------------------------------
Occupied Apartments
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
104     3       2.00    1350    850     Occupied
107     1       1.00    950     500     Occupied
108     2       1.00    1150    550     Occupied
-----------------------------------------------------
Apartments that need repair
                        Monthly
Unit # Beds     Baths   Rent    Deposit Status
-----------------------------------------------------
102     1       1.00    950     500     NeedsRepair
106     3       1.50    1425    950     NeedsRepair
-----------------------------------------------------
Press any key to continue . . .

Numeric Operations on Elements

 

The Sum of Values of a List

If you have a list made of numeric values, to let you get the sum of those values, the List module provides a function named sum. Its syntax is:

List.sum : ^T list -> ^T (requires ^T with static member (+) and ^T with static member Zero)

Here are examples:

let timesWorked = ([8.00; 9.00; 8.50; 8.00; 8.50], [8.50; 9.50; 8.00; 10.00; 9.00])

let (a, b) = timesWorked

let week1 = [for t in a do yield t]
let week2 = [for t in b do yield t]

printfn "Work 1 time worked: %A\tTotal: %0.02f" week1 (List.sum week1)
printfn "Work 2 time worked: %A\tTotal: %0.02f" week2 (List.sum week2)

This would produce:

Work 1 time worked: [8.0; 9.0; 8.5; 8.0; 8.5]   Total: 42.00
Work 2 time worked: [8.5; 9.5; 8.0; 10.0; 9.0]  Total: 45.00
Press any key to continue . . .

The Average of a List

The List module supports various arithmetic operations on a list if the elements on that list are numbers.

The List.average() function is used to calculate the average of numbers. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 25500.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 25500.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); ]
 
let salaries = [ for empl in employees -> empl.YearlySalary ]
let avgSalary = List.average salaries
printfn "Salaries: %A" salaries;
printfn "Average Salary: %0.0f" avgSalary;

This would produce:

Salaries: [60000.0; 82000.0; 35400.0; 25500.0; 25500.0; 104000.0]
Average Salary: 55400
Press any key to continue . . .

Sorting Items

 

Introduction

Sorting the items of a list consists of re-arranging them in order. If the items are of a primitive type, you can arrange them in alphabetical, numerical, or chronological order. If the items are based on a class, you must implement the IComparable interface that is equipped with a method named CompareTo.

To let you arrange the items of a list, the List module is equipped with a function named sort. Its signature is:

List.sort : 'T list -> 'T list

Here is an example:

open System;
 
type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
    interface IComparable with
        member this.CompareTo(obj : Object) =
            match obj with
            | :? Employee as empl -> compare this.YearlySalary empl.YearlySalary
            | _ -> 0
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00); Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00); Employee("2813-3044", EmploymentStatus.PartTime, 32500.00);
                  Employee("5031-9259", EmploymentStatus.FullTime, 55000.00); Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); ]
 
let sorted = List.sort employees
 
printfn "Employees Salary Summary"
printfn "==================================="
printfn "           Employment \tYearly"
printfn "Empl #      Status\tSalary"
printfn "-----------------------------------"
List.iter (fun (empl : Employee) -> printfn "%s  %A\t%0.0f" empl.EmployeeNumber empl.EmploymentStatus empl.YearlySalary) sorted

Sorting Items By a Condition

The List.sort() function is used to simply arrange all records of a list. If you want to apply a condition by which to sort records, you can use the sortBy() function of the List module. Its signature is:

List.sortBy : ('T -> 'Key) -> 'T list -> 'T list

This function takes two arguments. The first arguments specifies a condition by which to sort. Only the items that respond to the condition are sorted. The other items in their original positions. Here is an example:

type EmploymentStatus =
    | Unknown  = 0
    | FullTime = 1
    | PartTime = 2
    | Intern   = 3
    | Seasonal = 4
     
type Employee(emplNbr, status, salary) =
    member this.EmployeeNumber = emplNbr
    member this.EmploymentStatus : EmploymentStatus = status
    member this.YearlySalary = salary
 
let employees = [ Employee("9749-8075", EmploymentStatus.FullTime, 60000.00);  Employee("2038-4051", EmploymentStatus.FullTime, 82000.00);
                  Employee("7092-3094", EmploymentStatus.FullTime, 104000.00); Employee("2813-3044", EmploymentStatus.PartTime, 25500.00);
                  Employee("2405-8296", EmploymentStatus.Seasonal, 35400.00);  Employee("5031-9259", EmploymentStatus.FullTime, 18500.00);  ]
 
let sorted = List.sortBy (fun (empl : Employee) -> empl.YearlySalary >= 60000.00) employees
 
printfn "Employees Records - Before Sorting"
printfn "==================================="
printfn "           Employment \tYearly"
printfn "Empl #      Status\tSalary"
printfn "-----------------------------------"
List.iter (fun (empl : Employee) -> printfn "%s  %A\t%0.0f" empl.EmployeeNumber empl.EmploymentStatus empl.YearlySalary) employees
printfn "-----------------------------------"
 
printfn "Employees Records - Sorting Employees Whose Salary is >= 60,000"
printfn "==================================="
printfn "           Employment \tYearly"
printfn "Empl #      Status\tSalary"
printfn "-----------------------------------"
List.iter (fun (empl : Employee) -> printfn "%s  %A\t%0.0f" empl.EmployeeNumber empl.EmploymentStatus empl.YearlySalary) sorted
printfn "-----------------------------------"

This would produce

Employees Records - Before Sorting
===================================
           Employment   Yearly
Empl #      Status      Salary
-----------------------------------
9749-8075  FullTime     60000
2038-4051  FullTime     82000
7092-3094  FullTime     104000
2813-3044  PartTime     25500
2405-8296  Seasonal     35400
5031-9259  FullTime     18500
-----------------------------------
Employees Records - Sorting Employees Whose Salary is >= 60,000
===================================
           Employment   Yearly
Empl #      Status      Salary
-----------------------------------
2813-3044  PartTime     25500
2405-8296  Seasonal     35400
5031-9259  FullTime     18500
9749-8075  FullTime     60000
2038-4051  FullTime     82000
7092-3094  FullTime     104000
-----------------------------------
Press any key to continue . . .
 
 
   
 

Previous Copyright © 2014-2015 FunctionX Next