A few weeks back, Soma blogged about an increased investment by the Microsoft Developer Division in the F# language. Part of this increased investment has been the creation of a small team in Redmond to work with F#'s creator Don Syme to bring F# into the set of first class languages supported on .NET. This provided a great opportunity for me to become one of the early members of this Redmond based F# team. So, as of a few weeks ago, I've traded in my C# Compiler PM role for the newly created F# PM job!
As you can probably tell from some of my previous blog posts, I have a lot of interest in functional programming with .NET. This makes F# is a naturally exciting language for me to be involved in. F# provides a language in which functional programming is easy and expressive, while at the same time practical and well-connected to the underlying .NET type-system and programming model. A exciting language for the .NET platform indeed!
Sample F# Code - Mandelbrot
Here's a little example piece of F# code to hopefully pique your interest to learn more about the language.
[Note: This code has been updated to work with .NET4, which now includes a built-in Complex type]
let maxIteration = 100
let modSquared (c : Complex) = c.Real * c.Real + c.Imaginary * c.Imaginary
type MandelbrotResult =
| Escaped of int
let mandelbrot c =
let rec mandelbrotInner z iterations =
if(modSquared z >= 4.0)
then Escaped iterations
elif iterations = maxIteration
else mandelbrotInner ((z * z) + c) (iterations + 1)
mandelbrotInner c 0
for y in [-1.0..0.1..1.0] do
for x in [-2.0..0.05..1.0] do
match mandelbrot (Complex(x, y)) with
| DidNotEscape -> Console.Write "#"
| Escaped _ -> Console.Write " "
The let keyword is used to declare a new variable or function. Note in particular the similarities between the declaration of maxIterations and modSquared. Functions are treated much the same as values of any other type throughout F#.
Let can be used both at the top level and also inside function definitions to declare a local variable or function. For example, the mandelbrot function uses a local function mandelbrotInner which computes the result, and simply calls it with the initial values. Note also that mandelInner refers to the parameter c passed to the mandelbrot function - local functions are true closures.
Recursive function can be defined using let rec.
F# is built on the .NET type system, and provides access to any type defined in a .NET assembly. Types can also be defined in F# using the keyword type. There are many kinds of types that can be created in F#, for example, standard .NET types such as classes and interfaces can be defined, but F# also supports types such as records and discriminated unions.
As an example of discrimated unions, in the code above, MandelbrotResult is defined to be a type whose values are either DidNotEscape or are Escaped with an integer. This accurately captures the mathematical definition of the mandelbrot set, which is defined in terms of points in the complex plane either escaping to infinity after a certain number of iterations, or remaining within a bounded region.
One of the most striking features of F# code is that it is very terse - ideas can typically be expressed with a small amount of code. There are a few significant language features which contribute to this:
- Type Inference: F# is strongly typed, like C#, but instead of having to declare the type of variables, parameters and return types, F# uses type inference to determine these automatically. When the types cannot be inferred, type annotations can be supplied in the code, such as in the definition of the modSquared function above.
- Indentation-aware syntax: By dfault, F# allows code to omit begin...end keywords and some other tokens, and instead relies on indentation to indicate nesting. This is similar to languages like Python, and enables the same kind of syntactic lightness that programs in these languages enjoy.
- Expressions: F# programs are built out of expressions, which can be composed very simply. For example, if is an expression in F#, as opposed to in C# where it is a statement. This can make code simpler, while also enabling a high degree of flexibility.
F# code can use all of the exisiting .NET libraries, such as the Console class used in the code above. But F# also has access to a rich set of F# libraries, providing types that are well suited to functional programming and F# in particular. A few notable libraries:
- Collections: The standard .NET Framework collections can be used from F#, but there is also a fully-featured set of functional collections, including the ubiquotous immutable linked list (List<A>), an efficient immutable set built on binary trees (Set<A>) and an immutable dictionary (Map<Key,A>)
- Control: High-level control structures, such as compositional eventing (IEvent<A>), laziness (Lazy<A>) and most importantly, asynchronous programming primitives (Async<A>). The last of these in particular is a very exciting feature of F# for multi-threaded programming.
F# comes with an "F# Interactive" toolwindow for Visual Studio, and also a command line interactive shell (fsi.exe). These are tremendously useful for protyping and exploring, and can also be used as a testbed while working on larger projects. As an example (see screenshot below) the code above can be pasted into an interactive shell to execute immediately. If you want to make changes, just edit the code and paste into the interactive prompt again to run the new version.
Now that I'm working full-time on F#, you can expect to see more blogs posts here about F# in the future. If you want to try out the code above, or any of the other great F# samples that are floating around the web, go to http://research.microsoft.com/fsharp/release.aspx and grab the most recent .msi download of the current Microsoft Research release of F#.