CHAPTER 2

How to Obtain, Install,
and Use F#

This chapter is designed to get you up and running with F# as quickly as possible. You'll look at how to obtain F#, how to install it on both Windows and Linux, and how to use the compiler in various ways. I'll also discuss what version of software the examples in this book were tested with and what extra software you might need to install.

Obtaining F#

You can download F# from the Microsoft Research F# Download page at http://research.microsoft.com/fsharp/release.aspx. The package includes various versions of the compiler, which are compatible with different versions of the CLR, fsi.exe (the F# interactive console), some F#-based parsing tools, the F# base class libraries, the F# documentation, and some F# samples.

Installing F# on Windows

Installing F# on Windows is straightforward. You need to be running as an account with system administrator privileges to install F#. Simply unzip the contents of the F# distribution to a temporary location, and then run the InstallFSharp.msi package, which is in the root of the distribution. The .msi should work whether or not Visual Studio 2003 or Visual Studio 2005 is installed.

If you'd prefer not to use an .msi, you can compile from the command line simply by unzipping to your preferred location and running alternative-install.bat, which will install the F# runtime libraries into the global assembly cache (GAC). You can also use this batch file to install F# against the Shared Source Common Language Infrastructure (SSCLI), more commonly known as Rotor, by using the -sscli command-line switch.

Note The SSCLI is a compressed archive of the source code for a working implementation of the ECMA CLI and the ECMA C# language specifications. This implementation builds and runs on Windows XP, and you can also compile and run it on other operating systems such as Linux or Mac OS X. This implementation is ideal if you really want to get under the covers and see what's going on; however, you may find it more difficult to use than .NET, so you're probably best off sticking with .NET while reading this book.

If you use the alternative-install.bat batch file, Visual Studio integration will not be installed. For installing Visual Studio integration, two further batch files are available, alternative-install-vs2003.bat and alternative-install-vs2005.bat. Please note that at the time of this writing the free Express Editions of Visual Studio do not support plug-ins, so you cannot use F# integration with them.

Installing F# on Linux

It's difficult to write a simple guide to installing F# on Linux, because there are so many different distributions of Linux and so many ways you can configure them. The following are the steps that worked well for me running SUSE Linux on a single computer. I performed all these steps as the root account.

1. Install Mono using the packages provided with the SUSE Linux distribution; you can find these by searching for mono and then sharp in the Install Software dialog box available from the Computer menu.
2. Unpack the F# distribution, and copy the resulting files to /usr/lib/fsharp.
3. In the /usr/lib/fsharp directory, run chmod +x install-mono.sh.
4. Run the dos2unix tool on the text file install-mono.sh.
5. Still in the /usr/lib/fsharp directory, run the command sh install-mono.sh.

After performing those steps, I was able to use F# from any account from the command line by running mono /usr/lib/fsharp/bin/fsc.exe, followed by the command-line options. Obviously, this was inconvenient to run every time, so I created a shell script file in /usr/bin and as fsc:

I then ran chmod +x fsc to give users permission to execute it. After this, running the F# compiler was as simple as typing fsc at the command line. The F# interactive compiler, fsi.exe, will also run under Linux, but on the installation I used at the time of this writing, I needed to use the --no-gui switch. The shell script for this is as follows:

Note I used SUSE Linux, available from http://www.novell.com/linux/, because I found it installed smoothly on real and virtual machines, requiring very little manual setup.

Using F# in Different Ways

F# programs are just text files, so you can use any text editor to create them. Just save your program with the extension .fs, and use fsc.exe to compile them. For example, if you had the following program in the text file helloworld.fs:

you could just run fsc.exe helloworld.fs to compile your program into helloworld.exe, which would output the following to the console:

In my opinion, the easiest and quickest way to develop F# programs is in Visual Studio in conjunction with the F# interactive compiler (see Figure 2-1). You can type F# programs into the text editor, taking advantage of syntax highlighting and IntelliSense code completion; compile them into executables; and debug them interactively by setting breakpoints and pressing F5. Also, you can execute parts of your code interactively using F# interactive. Just highlight the code you want to execute, and press Alt+Enter; F# interactive will execute the code and show the results. This is great for testing snippets individually.

Figure 2-1. Visual Studio hosting F# interactive

Note If you are not convinced you want to invest in a copy of Visual Studio, trial versions of this software are available at https://www.tryvs2005.com.

If you prefer, you can type your programs into the F# interactive console directly when it's running in stand-alone mode, as shown in Figure 2-2.

Figure 2-2. The F# interactive console running in stand-alone mode

When you use the interactive console, you type the code you want; then when you've completed a section, you use two semicolons (;;) to indicate that the compiler should compile and run it.

F# interactive responds to commands in two ways. If you bind a value to an identifier, it prints the name of the identifier and its type. So, typing the following into F# interactive:

gives the following:

However, if you just type a value into F# interactive, it will respond slightly differently. Typing the following into F# interactive:

gives the following:

This means the value has been bound to a special identifier, called it, that is available to other code within the F# interactive session. When any expression is evaluated at the top level, its value is also printed, after the equals sign; note the 3 in the previous example. As you get to know fsi.exe and F# in general, using F# interactive will become more and more useful for debugging programs and finding out how they work. (I discuss values, identifiers, and types in more detail in Chapter 3.)

You can get code completions by pressing Tab. I find this mode of working useful in testing short programs by copying and pasting them into the console or for checking properties on existing libraries. For example, in Figure 2-2 I checked the System.Environment.Version property. However, I find this mode inconvenient for creating longer programs since it's difficult to store the programs once they're coded; they have to be copied and pasted from the console. Using Visual Studio, even if you don't intend to just run them interactively, you can still easily execute snippets with Alt+Enter.

If you save your program with the .fsx extension instead of the .fs extension, you can run your programs interactively by right-clicking them and selecting the Run with F# Interactive menu option, as shown in Figure 2-3. This scripting style of programming is great for creating small programs to automate repetitive tasks. This way your program's configuration, such as the file paths it uses, can be stored inside regular strings in the program and can be quickly edited by the programmer using any text editor as needed.

Figure 2-3. Running an F# script by right-clicking it

You can find more information about the F# programming tools and general programming tools for .NET in Chapter 11.

Installing the Software Used in This Book

The code in this book will focus on using fsc.exe, rather than fsi.exe. This is because although fsi.exe is great for testing code, running simple scripts, and running experiments, I believe fsc.exe is more useful for producing finished software. Since there's little difference between the syntax and the commands, most examples will work with little or no adaptation in fsi.exe, and I'll warn you when any changes are necessary.

All the samples in this book were created using .NET 2.0 running on Windows XP Professional. If you're using .NET 1.0 or 1.1, you'll experience problems with many of the samples because quite a few of them use classes and methods from the .NET 2.0 base class library (BCL) that aren't available in version 1.0 or 1.1.

The most common problem you will face when working with .NET 1.0 and 1.1 is that I use System.Collections.Generic.List, referred to as ResizeArray in F#, and System.Collections.Generic.Dictionary. You can always work around this by replacing these two classes with System.Collections.ArrayList and System.Collections.Hashtable, respectively. There may be other places where I use methods or classes not available in .NET 1.0 and 1.1, but generally you will be able to work around this with a little extra coding.

At the time of this writing, Mono shipped with its version of Framework 2.0, which the F# compiler targets by default; however, this was still in beta, with a production-quality version due to ship in mid-2007. A small subset of this book's examples has been tested on Mono 2.0, and the examples ran without problems.

A small number of examples use several other software libraries and packages. It's not necessary to immediately download and install all these software packages, but for specific examples, as listed in Table 2-1, you'll need to do this at some point.

Table 2-1. Additional Software Used Within This Book

Obviously, some of these links are a little long to type, so I've summarized them all at http://strangelights.com/FSharp/Foundations/default.aspx/FSharpFoundations.Downloads where I'll keep them updated.

Summary

This chapter described how to install and run F# and the different ways you can work with it. The following chapters will explain how to program with F#, starting in Chapter 3 with functional programming in F#.