Fundamentals of Values

Introduction to Variables

A variable is a section of the computer memory used to temporarily hold a value.

Declaring a Variable

Reserving a portion of memory is referred to as declaring a variable. There are rules you must follow.

To declare a variable, use an operator named let. Based on this, declaring a variable in F# is also referred to as "let binding".

Follow the let keyword by a name for the variable and assign a value to it using the assignment operator "=". The formula to follow is:

let variable-name = Value

Here is an example:

let x = 16

Although we declared and initialized the variable in one line, if you want, you can put the initialization on another line. If you decide to do this, the code on the next line must be indented. Here is an example:

let x =
16

The Presence of a Semicolon

When you write an F# statement as done above, you can end it with a semicolon. The above declaration can also be written as follows:

let x = 16;

In this case, and for such a statement in F#, the semicolon is optional. Remember that if a statement continues on the next line, you must indent that next line, including its semicolon if any. Here is an example:

let x =
16;

Letting Many Declarations

Instead of declaring one variable, you may want to declare many variables. To do this, you can declare each variable on its line, using its own let keyword and its own initialization. Here are examples:

let x = 16
let y = 24
let z = 58

As an alternative, you can use one let keyword and list the variables separated by commas with the group followed by the assignment operator "=". After the assignment, give the list of values for each variable in the order they appear in the initialization. Here is an example:

let x, y, z = 16, 24, 58 // x = 16; y = 24; z = 58;

The variables don't have to be of the same type. Here is an example:

let x, y, z = 16, "John", 'M';

Remember that if the line of initialization is too long, you can continue it on the next line but remember to indent the code on the next line. Here is an example:

let x, y, z =
16, "John", 'M';

Names in F#

The name of a variable must follow some rules:

• The F# language uses some words, called keywords, for its own use. Therefore, when giving a name to a variable, avoid using those keywords for your variables. The keywords to avoid for variables names are as follows:  array do downto for in let to while fun function mutable ref yield inline abstract and as assert base begin class default delegate do (Function) done downcast elif else end (class) end (if) exception extern false finally for if ignore inherit interface internal lazy match member module namespace new not null of open or override private public rec static struct then true try type unit upcast use val void when with
Also avoid using the following words when naming anything:  asr atomic break checked component const constraint constructor continue eager event external fixed functor include land lor lsl lsr lxor method mixin mod object parallel process protected pure sealed sig tailcall trait virtual volatile
• The name of a variable must be in one word. You have many options:
• You can create a name that uses only one word. In this case, all letters in the name should be in lowercase. Here are examples:
let age = 21
let salary = 36880
let category = 5
• You can create a name made of many words. In this case, the first word should be in lowercase. The first letter of each subsequent word should be in uppercase. Here are examples:
let memberCategory = 5
let numberOfPages = 488
• You can create a name that includes digits. In this case, the first character in the name can be an underscore or a letter. The other characters in the cam be letters, digits, and/or underscores in the order of your choice. Here are examples:
let _number = 38
let _dc101 = 202
let _metroDowntown10 = 20910
• A name must not include spaces
• A name must not include special characters. The only special character allowed in a name is the underscore
• F# is case sensitive. This means that in, In, iN, and IN are four different words. Therefore, when using the name of a variable in your application, remember how you had created it when declaring the variable

Introduction to User-Based Issues

Introduction to Printing a Value to the Screen

Probably the most iportant aspect of a program for a user is the value, or the values, that the program displays. To make this possible, the F# language provides a display a function named printf. The most fundamental value you can display in an application is a string. To do that, type printf followed by the value between double-quotes. Here is an example:

printf "Hello from F#"

Building the Project

For you, as a programmer, your primary role is to create a project and make it work. Of course, you also have to test it and deal with other types of problems related to your product. After starting a project, while you are working on it, you must build it to verify whether everything is alright. To assist you in building a project, the F# language comes with an internal program named a compiler (actually, it is more complex than that we will not care about that for now). To start the building process, if you are working in Microsoft Visual Studio, on the main menu, you can click Build and click Build Solution. If everything in your program is, or seems, alright, nothing bad will happen. If there is a problem in your program, an error will display.

Executing the Application

In order to see the results of your project, your users must execute your application. Before getting there, you also must execute your project to see that it looks like. When you have built your project and there is no error, the compiler creates an application, named an executable, in the final folder of your project ("Drive Letter:\Users\user-name\source\repos\project-folder\project-name\project-name\bin\Debug\net7.0"). You can access the application in that folder. Instead of going all this, Microsoft Visual Studio allows you to build you project and immediately execute it, right in Microsoft Visual Studio. To do this, on the main menu of Microsoft Visual Studio, click Debug and click Start Without Debugging.

One of the characteristics of the printf function is that, when it has displayed its value, it keeps the caret at the end of that value, on the same line. This means that the next operation would execute on that same line. In some cases, you will want to move the carret to the line so that the next operation would excute on that next line. To make this possible, the F# language provides a function named printfn. It mostly works like the printf function. That is, add the desired double-quoted value after printfn. Here is an example:

printfn "Hello from F#" Practical Learning: Starting a Project

1. Start Microsoft Visual Studio
2. In the Visual Studio 2022 dialog box, under Get Started, click Create a New Project 3. In the Create a New Project dialog box, in the top combo box, select either All Languages or F#
4. In the large list on the right side of the dialog box, and click Console App (it should be selected already) 5. Click Next
6. Change the suggested name to Exercise1
Accept or change the Location 7. Click Next
8. In the Framework combo box, select the latest version (.NET 7.0 (Standard Term Support)) 9. Click Create
10. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

Displaying a Value In Print

The primary job of an application is to display values, and there are many types of those values. You can start by declaring a variable and initializing it. To let you display a value using printf and/or printfn, these functions have a pre-procesor represented by the character %. It must be followed by a format, which is represented by a character or many symbols, depending on the type of value. The % and its subsequent character(s) must be included in the double-quotes of a printf and/or printfn, these function. After those quotes, add the name of the variable. Practical Learning: Creating a string

1. Type the following line:
let message = "Welcome to the wonderful world of functional programming!";
2. Press Enter to move the caret to the next line
let message = "Welcome to the wonderful world of functional programming!";

printfn "%s" message;
4. To execute and see the result, on the main menu, click Debug -> Start Without Debugging
5. Press Enter to close the window and return to Microsoft Visual Studio
6. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

Introduction to Data Types

Fundamentals

When you declare (or bind) a variable and assign a value to it, if you don't explicitly indicate its type, the compiler implicitly determines the variable's type. Still, F# supports different types of values.

Storing a Value in Bits

When you declare a variable, the compiler must put, or store, that value in the computer memory. To make this possible, the computer memory organizes its storage area is locations that resemble small houses or cells. Each of these small cells can hold only one small piece of information or data. This small piece can be only either 0 or 1. As a matter of fact, it is called a bit. This means that a bit can have a value of either 0 or 1.

A regular application uses different variables. Each variable has its own value. As variables are different, each variable must use or occupy its own area in the computer memory; also, variables use different values, and different types of values. Therefore, two different variables may require different amounts of storage in the computer memory. This means that one variable may require a certain number of bits while another variable uses a different number of bits fewer bits or more bits).

The size of the memory area that a variable requires depends on its type of value. This means that the number of bits that a variable needs depends on its type.

An Inferred Language

F# is an inferred language. This means that, when declaring a variable, you don't have to specify its data type but you must initialize it. When you do this, the compiler will "infer" the data type; that is, the compiler will decide about the appropriate type to apply to the variable.

As a result, you can omit specifying the data type of a variable and let the compiler take care of it, or you can specify it. If you decide to specify the data type of a variable, follow its name with a colon and the data type. The formula to follow is:

let variable-name : data-type

Introduction to Strings

Introduction

A string is a group of characters or symbols considered as one entity. To create a string, include its value in double-quotes.

A Type for Strings

A string is represented by a data type named string. Therefore, when declaring a variable, if you want to indicate that it is a string, use the string data type. Here is an example:

let message : string = "Welcome to the wonderful world of functional programming!"

When declaring a string variable, you can initialize it with an empty space, a character, a symbol, a word, or a group of words. The value given to a string must be included in double-quotes.

Displaying the Value of a String

To display the value of a string variable, somewhere in the double-quotes of a printf or printfn function, type %s as the placeholder of the variable. Of course type the name of the variable after the double-quotes. Here is an example:

let message = "Welcome to the wonderful world of functional programming!"

printfn "%s"  message Practical Learning: Creating and Using Strings

1. Type the following lines of code:
let category = "1";
let gender = "M";
let employee = "Garçon Hérand";

printfn "Great Corporation";
printfn "Employee: %s" employee;
printfn "Gender:   %s" gender;
printfn "Status:   %s" category;
2. To execute and see the result, on the main menu, click Debug -> Start Without Debugging
Great Corporation
Employee: Garçon Hérand
Gender    M
Status:   1

Press any key to close this window . . .
3. Press Enter to close the window and return to Microsoft Visual Studio
4. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

Introductory Operations on Strings

Sectioning a String

If you have a long string that you want to span on more than one line, cut its sections with a back slash each (although the second line in the following example is indented, you don't have to indent it). Here is an example:

let message = "Welcome to the wonderful world \
of functional programming!"

printfn "%s" message

There are many other issues related to strings. We cannot review them now.

Concatenation

String concatenation consists of adding one string to another. This is done using the addition operation. Here is an example:

let userName = "pjacobson"
let emailDomain = "@yonson.com"

printfn "Employee Email: %s" emailAddress

This would produce:

Employee Email: pjacobson@yonson.com

In the same way, you can use as many addition operators as necessary to concatenatte strings. Practical Learning: Concatenating Strings

1. Type the following lines of code:
let firstName = "Philippe"
let lastName = "Jacobson"
let fullName = firstName + " " + lastName

printfn "Employee Name: %s" fullName
2. To execute and see the result, on the main menu, click Debug -> Start Without Debugging
Employee Name: Philippe Jacobson

Press any key to close this window . . .
3. Press Enter to close the window and return to Microsoft Visual Studio
4. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

String Interpolation

String interpolation consists of adding placeholders in a string so that those placeholders represent some values. To create string interpolation, start the string with the $symbol. Inside the double-quotes of the string, include the name of a variable whose value you will want to represent or display. That name must be included between { and } Here is an example: let firstName = "Michael"; let lastName = "Carlock"; let employeeName =$"Full Name: {firstName} {lastName}"

printfn "%s" employeeName

This would produce:

Full Name: Michael Carlock

Press any key to close this window . . .

Characters

Introduction

A character is a letter (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, or Z), a digit (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), or a symbol that can be visually represented and recognized by the computer. Examples of symbols are:  ~ ! @ # \$ % ^ & * ( ) - _ = + [  ]  \ | ; : ' < ? . / , > "

To use a value that represents a character, declare a variable and initialize with a letter, a digit, or a symbol in single-quotes. Here is an example:

let gender = 'F';

Displaying a Character

To display the value, in the double-quotes of printf or printfn, use %c as the placeholder of the variable. Here is an example:

let gender = 'F';

printf "Student Gender: ";
printfn "%c" gender;

This would produce:

Student Gender: M

The Type of a Character

When declaring the variable, to indicate that it is a character, use the char keyword. Here is an example:

let gender : char = 'F'

printf "Student Gender: "
printfn "%c" gender

Escape Sequences

An escape sequence is a special character that displays non-visibly. For example, you can use this type of character to indicate the end of a line; that is, to ask the program to continue on the next line. An escape sequence is represented by a backslash character, \, followed by another character or symbol. For example, the escape sequence that moves to the next line is \n.

An escape sequence can be included in the quotes of printf or printfn. The escape sequences are:

 Escape Sequence Name Description \b Backspace Takes the cursor back \t Horizontal Tab Takes the cursor to the next tab stop \n New line Takes the cursor to the beginning of the next line \r Carriage return Causes a carriage return \" Double Quote Displays a quotation mark (") \' Apostrophe Displays an apostrophe (') \\ Backslash Displays a backslash (\) \0 Null Displays a null character \uXXXX Unicode Character Used to display the equivalent representation of a symbol given in hexadecimal format \UXXXXXXXX Unicode Character Used to display the equivalent representation of a symbol given in hexadecimal format

Here is an example:

let gender : char = 'M';

printf "Student Gender: ";
printfn "%c\n" gender;

A String, Verbatim

Consider the following string:

let filePath = "C:\ne -> Neon\ti -> Titanium\be -> Beryllium\v -> Vanadium"

printfn "File Path: %s" filePath

This would produce:

File Path: C:
e -> Neon       i -> Titaniue -> Berylliumâ™‚ -> Vanadium

Press any key to close this window . . .

As we have seen in previous sections and we will see in future sections, you can include some operators in a string to perform local operations (operations inside a string). The compiler will refer to the symbols you include in a string in order to perform the desired operation(s). In some cases, you will want the compiler to ignore the operators in a string and consider the string "as is", as if those symbols are part of the string and should not be processed as operators. Such a string is referred to as "verbatim".

To create a verbatim string, start it with the @ symbol. Here is an example:

let filePath = @"C:\ne -> Neon\ti -> Titanium\be -> Beryllium\v -> Vanadium"

printfn "File Path: %s" filePath

This would produce:

File Path: C:\ne -> Neon\ti -> Titanium\be -> Beryllium\v -> Vanadium

Press any key to close this window . . .

A String with Triple Quotation

A string can be included in another string. To make this happen, you want the included string to have its own double-quotes. To do this, create each inside double-quote with the \" escape sequence. Here are examples:

let chemistry = "H: \"Hydrogen\"\nHe: \"Helium\"\nLi: \"Lithium\"\nBe: \"Beryllium\""

printfn "Chemistry\n%s" chemistry

This would produce:

Chemistry
H: "Hydrogen"
He: "Helium"
Li: "Lithium"
Be: "Beryllium"

On the other hand, if you precede a string value with the @ sign, all escape sequences in the string would be ignored, except for the double-quotes. If you want the double-quotes to be ignored, start and end the string with three double-quotes. In this case, each included double-quote doesn't need to be created a \" escape sequence. Here is an example:

let filePath = """C:\ne -> Neon\ti -> Titanium\be -> Beryllium\v -> Vanadium"""

printfn "File Path: %s" filePath

This would produce:

File Path: C:\ne -> Neon\ti -> Titanium\be -> Beryllium\v -> Vanadium

Press any key to close this window . . .

Introduction to Integral Values

Introduction to Bytes

A byte is a combination of 8 bits. As a result, this combination of 8 bits, referred to as a byte, can be used for a variable that needs a small number, in the area of 256.

A Signed Byte

A number is referred to as signed if it can hold a negative of a positive value in the 256 range. If you divide this number in half and consider its negative and positive side, you get values from -128 to 127. As a result, a variable for a byte can hold a number between -128 to 127.

Because you can declare a variable without specifying its type, to indicate that you want the variable to store its value in a computer memory equivalent to a byte, when initializing the variable, add y to its value.

A variable is referred to as signed if it can hold a negative or a positive number. If the number is positive, you can start it with a + sign. Here is an example:

let age = 14y

Actually, the + symbol is optional. This means that if you don't use it, the compiler will automatically consider that the number is positive. On the other hand, if the number is negative, you must start it with a - sign. Here is an example:

let temperature = -104y

Presenting the Value of an Integral Variable

To represent the value of a signed byte variable, use either %d or %i in the double-quotes of the printf or printfn. Here is an example:

let roomTemperature = -88y;

printfn "When we entered, the room temperature was %d" roomTemperature;

This would produce:

When we entered, the room temperature was -88

A Signed Byte Type

As seen already, a variable is referred to as signed if it can hold a number between -127 and 128. The data type of such a variable is named sbyte.Therefore, when declaring a variable for a small signed number, if you want to specify its type, use that keyword. Practical Learning: Introducing Numbers

1. Type the following lines of code:
let number = 0xFE;

printfn "Number: %d" number;
2. To execute and see the result, on the main menu, click Debug -> Start Without Debugging
Number: 254

Press any key to close this window . . .
3. Press Enter to close the window and return to Microsoft Visual Studio
4. Click inside the Code Editor. Press Ctrl + A to select everything. Type the following code:
let roomTemperature : sbyte = -88y;

printfn "When we entered, the room temperature was  %d" roomTemperature;
5. To execute and see the result, on the main menu, click Debug -> Start Without Debugging
6. Press Enter to close the window and return to Microsoft Visual Studio
7. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

A Byte

Introduction

A number is referred to as unsigned if it doesn' have a sign. As see in our introduction to integral types, a number that doesn't have a signed is automatically considered positive. In fact, in application development, when a variable is said to be unsigned, it means it always holds a positive number.

The Byte Type

We saw that you may want to use a variable whose value can fit in 8 bits, equivalent to a byte. In some cases, you want the value of that variable to also be positive. Such a value must be between 0 and 255. Indicate this, when declaring the variable and initialing it, add uy to its value. Here is an example:

let age:byte = 14uy;

Make initializing the variable, make sure you don't use a value that is higher than 255; you would receive an error.

The Byte Data Type

To let you specify the data type of an unsigned variable that must hold small numbers that can fit in 8 bits, the F# language provides the byte keyword. You can apply to when declaring the variable. Here is an example:

let age :byte = 14uy

As seen with signed integers, to display a signed variable, in the double-quotes of printf or of printfn, use %d or %i. Here is an example:

let age:byte = 14uy;

printf "Student Age: "
printfn "%d" age

Short Integers

Introduction

A short integer is number that can fit in 2 bytes, which is equivalent to 2 * 8 bits = 16 bits.

A Signed Short Integer

A number is referred to as a signed short integer it can be a negative or a positive number that can fit in 16 bits. This means that the number is between -32768 to 32767. Here is an example of declaring such a variable:

let schoolEffective = 1400

When declaring and initialing the variable, to indicate that you it to hold a value equivalent to a signed short integer, end its number with s. Here is an example:

let schoolEffective = 2247s

A Signed Short Type

To support signed short integers, the F# language provides the int16 keyword. You can use it to specify the data type of the variable.

As seen above, to represent a signed short variable in the double-quotes of printf of printfn, use %d or %i. Here is an example:

let schoolEffective = 1400s

printfn "School Effective: %d" schoolEffective

This would produce:

School Effective: 1400

Press any key to close this window . . . Practical Learning: Introducing Short Integers

1. Type the following lines of code:
let numberOfPages : int16 = 842s
let temperature : int16 = -1544s

printfn "Number of Pages of the book: %d" numberOfPages
printfn "Temperature to reach during the experiment: %d degrees\n" temperature
2. To execute and see the result, on the main menu, click Debug -> Start Without Debugging:
Number of Pages of the book: 842
Temperature to reach during the experiment: -1544 degrees

Press any key to close this window . . .
3. Press Enter to close the window and return to Microsoft Visual Studio
4. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

Unsigned Short Integers

If a variable must hold positive and relatively small numbers, it is referred to as an unsigned short integer. To use such a variable, when initializing it, add a us suffix to its value. Here are examples:

let numberOfTracks = 16us
let musicCategory = 2us

printfn "This music album contains %d tracks" numberOfTracks
printfn "Music Category: %d" musicCategory

This would produce:

This music album contains 16 tracks
Music Category: 2

Press any key to close this window . . .

An unsigned short integer can hold numbers that range from 0 to 65535 and therefore can fit in 16 bits. If you want to indicate the data type of the variable, use uint16. Here are examples:

let numberOfTracks:uint16 = 16us
let musicCategory:uint16 = 2us

printfn "This music album contains %d tracks" numberOfTracks
printfn "Music Category: %d" musicCategory

Integers

Introduction

An integer is a natural number. By default, the number can fit in 32 bits, which means it can use 32 / 8 = 4 bytes.

Signed Integers

A natural number is said to be signed if it can be negative or positive. Such a number is between 2,147,483,648 and 2,147,484,647. When declaring a variable and intializing it with a natural number, the compilter automatically considers that you can want to use 32 bits to store the number, regardless of the value you assign to the variable. Here are two examples of such variables:

let coordX = 12
let coordY = 8

As seen with the other integers, to display the value of an integral variable, in the double-quotes of printf of printfn, use %d or %i. Here is an example:

let coordX = 12
let coordY = 8

printfn "Cartesian Coordinate System: P(%d, %d)" coordX coordY

When executed, the program would produce:

Cartesian Coordinate System: P(12, 8)

An Integral Type

Remember that, when declaring a variable that will hold a natural number, simply assign the desired number to it and the compiler will consider it a number targetting 32 bits. To explicitly indicate it to the compiler, you can add l to the value of the variable. Here is an example:

let number = 183058l

printfn "Number: %i" number

To support natural numbers, the F# language provides a data type named int. You can apply it to a variable.

Unsigned Integers

An unsigned integer is a positive number between 0 to 4,294,967,295. When declaring a variable, to indicate that you want it to hold only positive integers, add u or ul to its value. Here are examples:

let dayOfBirth = 8u;
let monthOfBirth  = 11u
let yearOfBirth = 1996u

To support unsigned integers, the F# language provides the uint32 data type. Here are examples:

let dayOfBirth : uint32 = 8u
let monthOfBirth : uint32 = 11u
let yearOfBirth : uint32 = 1996u

printfn "Red Oak High School";
printfn "Student Date of Birth: %d/%d/%d" monthOfBirth dayOfBirth yearOfBirth;

This would produce:

Red Oak High School
Student Date of Birth: 11/8/1996

Press any key to close this window . . .

Long Integers

Introduction

A long integer is a very large natural number. It can fit in 64 bits.

A Signed Long Integer

A signed long integer is a natural number that can be very low or very large. Here is an example:

let population = 72394475;

printfn "Country Population: %d" population;

This would produce:

Country Population: 72394475

Press any key to close this window . . .

When initializing the variable, to indicate that it represents a long integer, add L to its value. Here is an example:

let population = 72394475L

printfn "Country Population: %d" population

When initialing a variable, to indicate that you want it to hold signed long integers, add L to its value. To let you specify the data type of the variable, the F# language provides the int64 keyword. Here is an example:

let population : int64 = 72394475L

Unsigned Long Integers

An unsigned long integer is a very large positive number. To support those types of values, the F# language provides the uint64 data type. When initializing the variable, you can add UL to its value.

A Big Integer

If you want your variable to hold a value that requires more than 64 bit, the F# language provides the bigint data type. When initializing the variable, you can add I to its value.

Native Pointer Integers

Native Integers

You can declare a variable that will hold values as a native integer. When initializing the variable, add an n suffix to its value. To display its value, use %d. Here is an example:

let number : nativeint = 16n;

printfn "Number = %d" number;

This would produce:

Number = 16

Press any key to close this window . . .

Unsigned Native Integers

To declare a variable for an unsigned native integer, when initializing the variable, add a un suffix to its value. To display its value, use %d. Here is an example:

let number : unativeint = 16un

printfn "Number = %d" number

Options on Integers

Instead of a natural number, you can also initialize an integral variable with a hexadecimal value. To do this, when initialing the variable, start its value with 0x and add a combination of 0, 1, 2, 3, 4, 5, 6, a (or A), b (or B), c (or C), d (or D), e (or E), and f (or F). Here is an example:

let number = 0xF0488EA;

printfn "Number: %d" number;

This would produce:

Number: 251955434

Press any key to close this window . . .

If you want to control the amount of memory area that the variable will use, the combination of those digits and/or characters must produce a value appropriate for the type you want. For example, if the value is for a byte, make sure the combination must produce a value equivalent to, or less than, 255. Here is an example:

let number = 0xFE

printfn "Number: %d" number

This would produce:

Number: 254

Press any key to close this window . . .

Octal Numbers

If you want, you can represent a number as octal. To do this, start the number with 0o, then add a combination of 0, 1, 2, 3, 4, 5, 6, and/or 7 digits in your desired order. Here is an example:

let number = 0o2027146

printfn "Number: %d" number

This would produce:

Number: 66662

Press any key to close this window . . .

Binary Numbers

If you want, you can represent a number as binary. You start the number with 0b. After that, add a combination of 0s and 1s in the order of your choice. Here is an example:

let number = 0b1110111011

printfn "Number: %d" number

This would produce:

Number: 955

Press any key to close this window . . .

Consider Thousands

When declaring a variable, if its value is in the thousands, you can segments from the right side with underscores. Here are examples:

let nbr1 = -38y
let nbr2 = +5_252s
let nbr3 = -846_084_325
let nbr4 = 69_249_484
let number1 = 0xFE_a8
let number2 = 0xfe_Bb_6C

printfn "Number: %i" nbr1
printfn "Number: %i" nbr2
printfn "Number: %i" nbr3
printfn "Number: %i" nbr4

printfn "Number: %i" number1
printfn "Number: %i" number2

This would produce:

Number: -38
Number: 5252
Number: -846084325
Number: 69249484
Number: 65192
Number: 4111212

Press any key to close this window . . . Practical Learning: Introducing Numbers

1. Type the following lines of code:
2. Press Enter to close the window and return to Microsoft Visual Studio
3. Click inside the Code Editor. Press Ctrl + A to select everything. Press Delete to clear the content of the Code Editor

Real Numbers

Introduction

A real number is a number that displays a decimal part. This means that the number can be made of two sections separated by a symbol that is referred to as the Decimal Separator or Decimal Symbol. This symbol is different by language, country, group of languages, or group of countries. In US English, this symbol is the period(.).

On both sides of the Decimal Symbol, digits are used to specify the value of the number. The number of digits on the right side of the symbol determines the precision of the number.

Floating-Point Numbers

F# supports floating-point numbers that range from Â±1.5 â€” 10âˆ’45 to Â±3.4 â€” 1038 with a precision of 7 digits that can fit in 32 bits. To declare such a variable, add f or F to its value. Here is an example:

let distance = 12f;

To indicate the data type of the variable, you can use either the single or the float32 data type. Here is an example:

let distance : single = 12f;

Double-Precision Numbers

When a variable is larger than the single type can handle and requires more precision, you should declare it using either the float or the double keyword. Here is an example:

let number = 62834.9023;

A variable declared as double stores very large numbers ranging from ±5.0 x 10−324 to Â±1.7 x 10308 with a precision of 15 or 16 digits.

Displaying a Floating Number

To display the value of variable that holds a floating-point number, add the f character after the % format in the double-quotes of printf or printfn. Here is an example:

let number = 62834.968273;

printfn "Number: %f" number;

This would produce:

umber: 62834.968273

Press any key to close this window . . .

Formatting a Floating Number

As seen in our introduction, a floating-point number has two parts, one on each side of the decimal separator. The part on the right side of the decimal separator can have many digits. In some cases, you may want to limit the number of digits after the decimal separator. To do this, between the % symbol and f, type 0. and the desired number of digits. Here is an example:

let number = 62834.968273;

printfn "Number: %0.3f" number;

This would produce:

Number: 62834.968

Press any key to close this window . . .

Actually, you can omit the 0 and use the period directly after the % symbol. Here is an example:

let number = 62834.92682736;

printfn "Number: %.5f" number;

This would produce:

Number: 62834.92682

Press any key to close this window . . .

Controlling the Space of a Floating Number

When you display the value of a variable that holds a floating-point number, you can specify the amount of space to leave between the number of the last character on its left. To do that, before the period of the % and f symbols, type the deside number. Here is an example:

let number = 62834.968273

printfn "Number: %0.3f" number

printfn "Number: %16.3f" number

This would produce:

Number: 62834.968
Number:        62834.968

Press any key to close this window . . .

Decimals

The decimal data type can be used to declare a variable that would hold significantly large values. You declare such a variable using the decimal keyword. The values stored in a decimal variable can range from Â±1.0 â€” 10−28 to Â±7.9 â€” 1028 with a precision of 28 to 29 digits.

After declaring a decimal variable, you can initialize it with a natural number. To indicate that the variable holds a decimal value, when initializing it, add an M suffix to its value. Here is an example:

let hourlySalary: decimal = 24.25M;

printfn "Hourly Salary = %f" hourlySalary;

This would produce:

Hourly Salary = 24

Press any key to close this window . . .

As seen in previous sections and this one, when declaring and initializing a real variable, the suffix you give to its assigned value indicates to the compiler the actual type of value and the type of memory that would be allocated for the variable.

The Infinity Concept

Infinity is the concept to consider the highest decimal number that could exist. That number doesn't actually exist but, to support the idea, the F# language provides the infinity keyword. Here is an example of accessing it:

let population = infinity;

printfn "Population: %.3f" population

This would produce:

Population: Infinity

Press any key to close this window . . .` Practical Learning: Ending the Lesson