F# is a functional first language in the .NET family and is a derivative of the Meta-Language (ML) family of languages. It shares many features with dialects of ML, which originally derives from the classical ML language designed by Robin Milner in 1973 at the University of Edinburgh. As a .NET language, F# code compiles to Microsoft Intermediate Language (MSIL), which runs on top of Common Language Runtime (CLR).
In this chapter, we will cover the following topics:
- The key features of F#
- The functional and imperative languages
- Using F# with Visual Studio
- Basic expressions in F#
The following are some points that Distinguish the F# language from other .NET languages:
- F# is a functional first language, which means that functions are treated as first-class citizens, but it also provides ways to work with other paradigms, such as object-oriented programming (OOP) (as in C#).
- Unlike other languages, such as C#, which mixes expressions (language constructs returning a value) and statements (constructs that don't return a value), F# is an expression-based language. You can think of every syntax construct in F# as a small function.
- F# is a strongly-typed language, meaning that the type of every expression in the program is determined at compile time. This allows the compiler to make verifications in our code and enables great tooling support, such as autocompletion, refactoring, and so on.
- Additionally, F# has a very strong type inference mechanism to infer types for the expressions in a program. This removes much of the verbosity usually associated with strongly-typed languages.
- The .NET generics' type system is baked into the core of F#. For example, the programmer doesn't have to specify the functions to be generic; if the F# type system infers the variables can be generic (provided it is implemented that way), the function becomes generic. This makes it easier to write polymorphic code, that is, functions that can be reused with different types.
- F# has a module system that allows data structures to be specified and defined abstractly. Unlike C# namespaces, F# modules can contain functions that help you separate data (types) from logic (functions in modules).
- F# implements a pattern matching mechanism, which allows controlling conditions based upon structural similarities; whereas, other languages only allow value matching as in
IF...ELSE
statements in C#.
Imperative languages usually modify the state of a variable for most operations. This makes it more difficult to reason about our program, particularly when different parts of our code change values that are globally accessible. When a piece of code modifies a value outside its scope, we talk about side-effects (this may also include other state modifications, such as file or console operations). OOP tries to tame side-effects by encapsulating state. However, this is not always a complete solution, as objects often develop tight and complex dependencies with each other that are still difficult to reason with.
Functional languages solve this problem using pure functions. Pure functions are closer to the mathematical ideal of functions, in the sense that they don't have side-effects (don't change state outside their scope) and always produce the same output given the same input. Pure functions are easier to refactor and reason with because their output is predictable, and can be used as building blocks to write large programs with different techniques of function composition.
F#, as described, is a functional-first language, but the language can also deal with unavoidable side-effects such as file or logging operations.
To compare F# with a more imperative language, we can take the example of a Fibonacci sequence generator, as follows:
public static int Fibonacci(int n) { int a = 0; int b = 1; // In N steps compute Fibonacci sequence iteratively. for (int i = 0; i < n; i++) { int temp = a; a = b; b = temp + b; } return a; }
|
let rec fib n = if n < 2 then 1 else fib (n - 2) + fib (n - 1)
|
Note
For illustration purposes, C# in procedural style is used. It is also capable of more functional implementations, such as Language Integrated Query (LINQ). Also, performance is not taken into consideration.
In an imperative language, the algorithm is normally implemented as a loop, and progress is made by modifying the state of the variables used in the loop.
In F#, the Fibonacci sequence is implemented using recursion. The let
keyword, which defines the function, and the rec
keyword, which specifies the function, can be called recursively. Using recursion, we are parameterizing the state (we will pass the updated values as parameters to the next call) so we do not need to use mutable variables.
However, please note that programs exclusively using a functional style can have performance problems. In this book, we will take an intermediate approach of using imperative code when necessary.
F# is very well integrated into Visual Studio 2010 and higher versions. This is a first-class language along with C# and VB.NET. There is also support for F# in cross-platform integrated development environments (IDEs) such as Xamarin Studio, the Ionide extension for Visual Studio Code, or Atom. See http://fsharp.org/ for more information.
Visual Studio includes the default project templates for F#. We can look for Visual F# and see a list of templates available.

Note
The screenshots in this book have been taken with Visual Studio 2012, but they should be very similar to other Visual Studio versions.
For example, let's create an F# console application called FSharpHelloWorld
and understand the different aspects of an F# project. The Solution Explorer lists the following files:

Open Program.fs
and view the contents; it has very low-ceremony code to run the console application, which is as follows:
[<EntryPoint>] let main argv = printfn "%A" argv 0 // return an integer exit code
If you are a C# developer, some elements of this little program may surprise you. For example, the EntryPoint
attribute indicates which function must be run when a console application starts. Also, as mentioned in the preceding code snippet, every expression in F# returns a value, so there is no need for an explicit return
keyword.
Modify the printfn
statement to include "Hello World"
, as shown in the following code snippet:
[<EntryPoint>] let main argv = printfn "Hello from F# :)" 0 // return an integer exit code
F# projects follow a top-to-bottom structuring of program files. Unlike C# or VB.NET, this is the very first thing to understand to organize files and folders with F#.
Note
Folder management is not available in F# within Visual Studio by default; you will need to install the Visual F# Power Tools extension for that.
You will learn by adding some files to the hello world project, as follows:
- Add a new F#
Employee.fs
source file to the hello world project - The
Employee.fs
file gets added to the end of the project - Press ALT + the up arrow, or right-click and move up or down, to arrange the file as shown in the following screenshot:

With F#, you can not write projects (.fsproj
) containing module files (.fs
), but also scripts (.fsx
). These are single-file projects that are useful to write short programs, automation tasks, and so on.

With F# Script File, we will get the following features:
- Full IntelliSense support
- Loading external files or .NET libraries
- Prototyping code that can easily be moved to a real codebase with minimal or no code changes
- An F# interactive window in Visual Studio that can be used to quickly test parts of the code from your F# script or normal F# files
The F# Interactive window provides a read-evaluate-print-loop (REPL) to evaluate your expressions without having to create, build, and run an F# project. This is very useful for developers to work in exploratory mode.
The following are the two ways to use the F# Interactive window:
- Visual Studio
- Command line
To access the F# Interactive window from the menu, navigate to View | Other Windows | F# Interactive.

Note
To evaluate an expression directly in the interactive window, terminate the code with double semicolons (;;
). This is not necessary in the F# source code.
Use the F# script files to quickly check a piece of code. We will now check this feature by writing a square root and a Fibonacci function. Add the following functions to a script file:
let sqr x = x * x let rec fib n = if n < 2 then 1 else fib (n - 2) + fib (n - 1)
After adding the preceding code snippet in the script file, perform the following steps:
Right-click on the selected code and select Execute In Interactive or press Alt + Enter.
- This will send the functions to the F# Interactive window. The window then displays the signature of the functions. Note that the syntax for signatures is a bit different from what we saw before. In this case, it means both functions accept and return an
int
value. We can call the functions directly in the interactive window by applying an
int
argument to the name of the function, as shown in the following screenshot:
There are some idioms that you will need to be familiar with when using F# Script File or the F# Interactive mode.
Idioms |
Description |
|
This loads a script/F# file. For example, refer to the following piece of code: #load "sample.fs" #load "sample.fsx"
|
|
This refers to a folder to load the assemblies in. For example, refer to the following piece of code: #I @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0"
|
|
This refers to the assembly to load from the referenced folder. Usually, this is used in conjunction with #I.
For example, refer to the following piece of code:
#I @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0" #r "presentationcore.dll"
|
|
This displays information about available directives. |
|
This terminates the interactive session. |
|
The |
FSI interactive shell is a simple console app that is bundled with the F# installation. To open FSI, perform the following steps:
- Open a terminal window.
- Type
fsi
to log in to the FSI session. Try some simple code to evaluate.
In F#, every valid value must have a type, and a value of one type may not be bound to a value of another type. We will declare values in F# using the let
keyword. For example, refer to the following piece of code:
// variable expression let x = 10 // function expression let add a b = a + b
As you learn F#, you will initially spend a lot of time getting the F# type checker to accept your programs. Being patient and analyzing the results with the F# type checker eventually helps you program better; you will later realize that the type checker is your best friend. Some rules about type checking are as follows:
- Every expression has exactly one type
- When an expression is evaluated, one of the following two things can happen:
- It could evaluate to a value of the same type as the expression
- It may raise an exception or error (this is actually a side-effect)
The let
bindings can also be nested as follows:
let z = let x = 3 let y = 4 x + y
Note
Note that the inner let
bindings are placed to the right of the outer let
bindings. This is important because the F# compiler determines scope by indentation.
When an expression is bound to a value in a let
binding, the value can be used within the body of let
(its scope). If a value with the same name was declared previously, the previous definition is overridden with the new definition; this is called shadowing and is often used in F# instead of value mutation. Let's consider the following example:
let test() = let x = 5 do let x = 10 printfn "%i" x // prints 10 x // returns 5
Here, we are not reassigning 10
to the previously declared x
value. Instead, we are effectively creating a new value, as you can see, because in the outer scope x
is still 5
.
If needed, it is still possible to modify values in F#. For that, we will need to use the mutable
keyword, as shown in the following piece of code:
let test() = let mutable x = 5 do x <- 10 // assignment printfn "%i" x // prints 10 x // returns 10
Anonymous functions, or lambdas, are defined with the fun
keyword, followed by a sequence of parameters with the ->
separator, and then the body of the function expression. The following is an example function to add two numbers:
> let sum = fun a b -> a + b;;
val sum : a:int -> b:int -> int
The type for sum
is int -> int -> int
. Like other functional languages, this means that arguments are curried. Think of sum
as a function returning another function, which can be partially applied, as we will see in the following section.
In F#, and other similar functional languages, functions actually have only one input and output. When we declare a function with multiple arguments, we are actually building functions that return other functions until the desired output is obtained. In the following code snippet, the two functions are effectively identical:
> let sum = fun x y z -> x + y + z;;
val sum : x:int -> y:int -> z:int -> int
> let sum' = fun x -> fun y -> fun z -> x + y + z;;
val sum' : x:int -> y:int -> z:int -> int
Note
The apostrophe is a valid character in F# and it is often used to mark values with a slight modification from a previously existing one.
The application of lesser arguments than the arity (the total number of arguments a function can accept) is called a partial application.
> let sum a b = a + b;;
> let incr_by_ten = sum 10;;
> incr_by_ten 5;;
val it : int = 15
Partial functions also help in writing concise code with F# pipeline operators, as shown in the following code:
let res1 = List.map (fun x -> x + x) [2; 4; 6] let res2 = List.filter (fun x -> x > 5) res1
The preceding code can be rewritten in a more expressive way using the pipe (|>
) operator:
[2; 4; 6] |> List.map (fun x -> x + x) |> List.filter (fun x -> x > 5)
Note
In F#, infix operators can be declared the same way as functions; the only difference is that we will surround them with parentheses in the declaration (for example, let (++) x y = (x + y) * 2
) and then use them in the middle of the arguments (for example, 5 ++ 3
).
For C# and VB.NET users, this is much like the continuation style programming with LINQ functions. In LINQ, you will normally pipeline a sequence of function calls, as follows:
var listOfItems = someItems.Select(x => x.Name).OrderBy(x => x);
However, for this the type returned by the first method needs to implement the method we want to call next. This is not a limitation when using the pipe operator.
Note
It is also possible to declare functions in a more similar way to languages such as C# (for example, let sum (x, y) = x + y
), but there is an important difference-these functions take a single tuple argument. We will discuss tuples in Chapter 2, Functional Core with F#.
In functional languages, recursion is used to express repetition or looping. For example, the Fibonacci sequence generator can be written as follows:
let rec fib n = if n < 2 then 1 else fib (n - 2) + fib (n - 1)
We use the rec
keyword to define a function as recursive. This is necessary to help the F# type checker infer the types of the function signature.
Every time a function is called recursively, a new routine is added to the call stack. As the call stack is limited, we must be careful not to overflow it. To prevent this, the compiler of F# and most functional programming languages implements an optimization called tail-call, which basically compiles down to a while
loop. To enable this optimization, we will need to make sure the recursive call is the last expression in the function.
// tail-recursion let factorial x = // Keep track of both x and an accumulator value (acc) let rec tailRecursiveFactorial x acc = if x <= 1 then // use the accumulator that has the final result acc else // pass the accumulator + original value again to the recursive method tailRecursiveFactorial (x - 1) (acc * x) tailRecursiveFactorial x 1
As functions are first-class citizens in functional languages, we can pass them as arguments to other functions. When a function takes another function as an argument, we it a higher-order function. Let's consider the following example:
> let apply x f = f x
val map : x:'a -> f:('a -> 'b) -> 'b
> let sqr x = x * x
val sqr : x:int -> int
> let f = apply 5 sqr;;
val f : int = 25
The preceding code snippets perform the following functions:
- The
apply
function takes a function as a parameter and evaluates the function - We will declare a
sqr
function, which squares anint
value - We will then call the
sqr
function throughapply
Higher-order functions are very important to write composable and reusable code. Earlier, we saw List.map
. Many of the functions in the Collections
modules (List
, Array
, and Seq
) accept functions as arguments so we can adapt their behavior to our needs.
In this chapter, we covered the basics of working with F# projects and used the interactive window to try out some basic constructs. Also, we saw a brief overview of different programming paradigms and the advantages of functional programming. In the next chapter, we will delve into some of the more powerful features of F#, such as record and union types as well as pattern matching.