So, let's start with the mandatory Hello World program, but first, keep in mind that you will have to activate F# tools in Visual Studio if you did not do that at installation time. (If you didn't, when accessing the F# language section, you'll be offered this activation.) Once activation is ready, you will be presented with a new type of project linked to this language in the way shown in the following screenshot:

To start with, you can pick up the tutorial, which is a comprehensive collection of the different aspects of the language— it's pretty well structured—or just use a console application for that matter.

If you opt for the tutorial, you can mark a section of the code you want to test, and if you right-click on that area, you'll be presented with two options for execution: Execute In Interactive and Debug In Interactive:

To visualize the results, we can—of course—create an executable and launch it in a console window, but for this scenario, F# Interactive Window is more suitable. For completeness, keep in mind that you can call the compiler (named fsc.exe) using the build option in Visual Studio just like you would with any other project.

So, we'll start with writing very simple code:

let a = 1 + 2
let b = a * 3
printfn "Expression a equals to %i" a
printfn "Expression b equals to %i" b
printfn "So, expression b (%i) depends on a (%i)" b a

This generates the following output in the F# Interactive window:

Here, we've done the following:

Note how the interactive window presents an echo of the members implied in the process, indicating its type as well.

Keep in mind that since F# is considered another member of the Visual Studio family, it has its own area of configuration in the Tools/Properties dialog box, as shown in the next screenshot. In addition, another entry in this dialog allows you to configure behaviors of the F# Interactive window:

The scope of an identifier indicates the area of code where such an identifier is usable. All identifiers, either functions or values, are scoped (valid) starting at the end of their definition until the end of the section in which they act. Additionally, in F#, you don't have to explicitly return any value, since the result of the computation is automatically assigned the corresponding identifier.

So, in order to create intermediate values for a computation, you denote it with indentation (by convention, the size of the indentation is 4, but the user can opt for any other value). Every indentation defines a new scope, and the end of every scope is marked by the end of the indentation. For example, let's think of a function to calculate the hypotenuse of a right triangle:

let hypo (x:float) (y:float) =
  let legsSquare = x*x + y*y
// System.Math.Sqrt(legsSquare)
sqrt(legsSquare) // an alias of the former
printfn "The hypotenuse for legs 3 and 4 is: %f" (hypo 3.0 4.0)

First, we define the hypo function, which receives two arguments of type float (note that we can explicitly indicate types with the syntax arg:type). Then, we declare legsSquare to be the sum of the squares of both triangle's legs, and this is done with a new level of indentation. Finally, we just calculate the square root of this intermediate variable without any other indication, which means that System.Math.Sqrt(legsSquare) is the return value.

Also, note how we make a reference to System.Math directly since it's included in the references of the project. Alternatively, you can use the open keyword to indicate a reference to System (such as open System), and then, you can use the Math static class in an unqualified way.

Finally, we call printfn to format the output and make sure there's only one value to include in the formatted output string by enclosing the call to hypo in the parenthesis.

Of course, the F# Interactive window will show the formatted result, as is expected:

In F#, lists are ordered collections of immutable elements of the same type. Its generation admits many language-compatible options, but the initial style is very simple. If you go through the tutorial a bit, you'll discover the following declaration:

/// A list of the numbers from 0 to 99
let sampleNumbers = [ 0 .. 99 ]

Here, you are introduced to the range operator: (..), which denotes a sequence of elements deductible for the compiler. Due to the echo feature of the Interactive window, we just have to mark that line and select Interactive Window to view the results:

The range operator also admits the increment descriptor (..), allowing you to define a different, collective type, called sequence (seq) that supports many of the same functions as lists:

seq {5..3..15}

Here, we define a sequence of elements starting with 5, going through 15, and increasing in steps of three (the output being the following):

val it : seq<int> = seq [5; 8; 11; 14]

In the same manner as earlier, let's mark the following sentence and proceed:

let sampleTableOfSquares = [ for i in 0 .. 99 -> (i, i*i) ]

An array of tuples is created, each containing a number from 0 to 99 and its corresponding squares. There are a few things to notice in this sentence.

Assigning something in squared brackets means that the expression inside it should be evaluated to an array (similar to JavaScript). We've seen this in the previous sentence as well, but this time, inside the brackets, we see a for..in loop and a -> symbol, which indicate the generated value for each step in the loop.

This generated value turns out to be a tuple, since it's enclosed in parenthesis—a very powerful and expressive syntax.

List objects contain several useful methods to manipulate their inner collections. One of them is List.map, which permits you to apply a function to each element in the list and returns a new list with the calculated results.

It's important to note how close the philosophy of this approach reminds what we saw in C# when using generic's collections and passing a lambda expression to their methods.

For example, we can write the following:

let initialList = [9.0; 4.0; 1.0]
let sqrootList = List.map (fun x -> sqrt(x)) initialList

printfn "Square root list: %A" sqrootList

Here, initialList contains three float numbers, for which we want to calculate the square root. So, we generate another list (sqrootList) by calling List.map and passing to it as an argument an anonymous function that gets a value and returns its square root. The last argument is initialList. Note that the argument of map is just like a lambda expression.

Once more, the output in the F# Interactive windows is as expected:

Function declarations

We've seen how to use anonymous functions and how they can be passed as arguments to some methods. To declare a named function, you can use a similar syntax as what you used with variables but by specifying the arguments it can receive, following the function's name:

let func1 x = x*x + 3

This time, func1 is the name of the function, and x the argument to be passed, which can, optionally, be enclosed in parenthesis. Later on, we can combine the previous declaration with an assignment to a variable, which you can see if you continue to analyze this code:

let result1 = func1 4573
printfn "The result of squaring the integer 4573 and adding 3 is %d" result1

Also, remember that arguments can be annotated (indicating its type explicitly):

let func2 (x:int) = 2*x*x - x/5 + 3

When we need to indicate code structures inside the function, we will use indentation the way we saw in a previous sample along with the required expression to be evaluated (and that's what func3 does here):

let func3 x =
  if x < 100.0 then
    2.0*x*x - x/5.0 + 3.0
  else
    2.0*x*x + x/5.0 - 37.0

Note the difference between lists in relation with tuples, which are defined enclosed in parenthesis. Furthermore, a list can be generated using expressions that include loops, as you can see in the following code, which uses such a construction:

let daysList =
  [ for month in 1 .. 12 do
  for day in 1 .. System.DateTime.DaysInMonth(2012, month) do
    yield System.DateTime(2012, month, day) ]

Here, we have two for loops nested using the for..in..do syntax. Also, note the presence of the yield keyword, just like in C#. The previous code generates the following output:

And the list goes on...

let (|>) x f = f x

let sum a b = a + b
let chainOfSums = sum 1 2 |> sum 3 |> sum 4

let numberList = [ 1 .. 1000 ]  /// list of integers from 1 to 1000
let squares = numberList
  |> List.map (fun x -> x*x)

/// Computes the sum of the squares of the numbers divisible by 3.
let sumOfSquares = numberList
|> List.filter (fun x -> x % 3 = 0)
|> List.sumBy (fun x -> x * x)

Pattern matching

Another useful structure when managing collections is the match..with construct. It's used with the | operator to indicate different options, much like what we would do in a switch and case statement in C#.

To test this in simple way, let's try the typical recursive function to calculate the factorial of a number:

let rec factorial n = match n with
  | 0 -> 1
  | _ -> n * factorial (n - 1)
let factorial5 = factorial 5

Note the presence of the rec keyword as a modifier of the function's declaration in order to indicate that the function is recursive. The variable to test (n) goes in between the match..with structure and the | operator separates the distinct cases to be tested. Also, look at how the underscore operator (_) is used to indicate what to do with any other value.

The F# Interactive window, once more, will show the correct results:

Classes and types

F# can work well with classes and types, and by itself, it is considered a typed language. Actually, you can declare elements of any supported type using type abbreviations and type definitions.

In the first case, we just establish aliases of existing types. You can declare these aliases using the type keyword followed by an identifier (the alias) and assign it to the type it represents:

type numberOfEntries = int
type response = string * int

Note that the second definition declares a new type construct made of two parts (string and int) that can be used later on.

The most common usage of types is to declare type definitions, indicating members as pairs of values (key : type) enclosed in curly braces, as the RecordTypes module of the tutorial reminds us (we reproduce it here):

// define a record type
type ContactCard =
  { Name     : string;
    Phone    : string;
    Verified : bool }
  let contact1 = { Name = "Alf" ; Phone = "(206) 555-0157" ; Verified = false }

If we launch the previous code in the F# Interactive window, we will get the following:

As you can see, the contact1 identifier is qualified as val (value). This value can also be used to declare further types based on the previous one. This is the purpose of the following declaration in the tutorial:

let contact2 = { contact1 with Phone = "(206) 555-0112"; Verified = true }

In this case, contact2 is based on contact1, but there are two changed values.

The next definition makes things quite clear as well:

/// Converts a 'ContactCard' object to a string
let showCard c =
  c.Name + " Phone: " + c.Phone + (if not c.Verified then " (unverified)" else "")

This is used to convert the ContactCard type into a string as we check the output in the F# Interactive window after adding another sentence to test the output:

let stringifyedCard = showCard contact1

The following screenshot shows the output generated:

Casting

In F#, casting sentences have their own specific operators. The two possible operations depend on the type of casting required (downcasting if you go from general to particular in the hierarchy, or upcasting if you proceed in the opposite way). As it happens, with C#, the hierarchy starts with System.Object, although there is an alias, obj, which we can use in its place.

As for the behavior in relation to the compiler, let's remember that upcasting is a safe operation because the compiler always knows the ancestors of the type to be converted. It is represented by a colon, followed by a greater-than sign (:>). For example, the following operation is legitimate:

As we can see, the someObject identifier is declared in parenthesis as the result of a conversion from a literal string to obj. As a result, in the next sentence, Intellisense in V. Studio reminds us that System.Object declares exactly those members that appear in the contextual menu.