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]

open System.Numerics
open System

let maxIteration = 100

let modSquared (c : Complex) = c.Real * c.Real + c.Imaginary * c.Imaginary

type MandelbrotResult =
| DidNotEscape
| Escaped of int

let mandelbrot c =
let rec mandelbrotInner z iterations =
if(modSquared z >= 4.0)
then Escaped iterations
elif iterations = maxIteration
then DidNotEscape
else mandelbrotInner ((z * z) + c) (iterations + 1)
mandelbrotInner c 0

for y in [-1.0..0.1..1.0] do
x in [-2.0..0.05..1.0] do
mandelbrot (Complex(x, y)) with
| DidNotEscape -> Console.Write "#"
| Escaped _ -> Console.Write " "
Console.WriteLine ()


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.

Terse Syntax

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:

  1. 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.

  2. 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.

  3. 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:

  1. 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>)

  2. 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#.

File iconmandelbrot.fs

Comments (25)

  1. derekslager says:

    F# is a great language. I’m thrilled to see another resource for F# content, as that’s the biggest weakness of the language at this point in time IMHO.

    The best F# learning resource I’ve found thus far, in fact, is the O’Reilly OCaml book. As that’s been my route to F# enlightenment, I’m rather impressed with the efforts made strictly in the name of compatibility.

    Congratulations on the new position. Hope to see more good things coming from the F# team soon!

  2. Tom Kirby-Green says:

    Ditto. I’m really looking forward to reading your F# posts going forwards. I’ve just picked up a copy of Don Syme’s new "Expert F#" book in ebook form from APress. It’s so cool to see this language be promoted to the mainstream!

  3. Luke Hoban is now full time as program manager on F#, and has just posted a short introduction about

  4. Luke Hoban is now full time as program manager on F#, and has just posted a short introduction about

  5. art_scott –

    Integrated F# help inside Visual Studio is certinaly one of the (many) things on our list of goals for F#.  No information yet on when we’ll have this – but stay tuned!

  6. Refik says:

    I’d seriously consider using .Net platform if F# had a certified open source license. With F#’s current license Scala looks more attractive to me. I look forward to see an improvement on this aspect.

  7. Jomo Fisher–Luke Hoban wrote something in a blog entry that resonated with me: One of the most striking

  8. Jomo Fisher–Luke Hoban wrote something in a blog entry that resonated with me: One of the most striking

  9. I was actually wondering – will F# feature the same kind of higher order functions such as map and fold?

  10. Julian and Gnub –

    Yes, F# does look a lot like ML – in fact, it is a variant of ML, most closely related to OCaml.  There is a core of the F# language which is shared with OCaml.

  11. Julian –

    Higher order functions are indeed an important part of F#.  In particular, versions of "map" (which applies a function to each element of a collection) and "fold" (which walks across a collection building up a result as it goes) are available over most of the collection types in F#, such as lists, arrays, sets, etc.

  12. Oh what an unfortunate language name. Couldn’t you guys have chosen ANY of the other 20 or so remaining letters in the english alphabet? It HAD to be "F#"? HAH HAH

    Well, I’m already building my library of "F"-word programming jokes…

  13. Gaurav says:

    Great Luke…

    Will like to catch u on a channel9 video for F# now…

    Cum up with some interesting stuff at channel9…

    Congratulations for new position…

    I m really enjoying the F# world & learning the new language…

  14. Jay/R says:

    Is it possible to get the current version of F# for VS 2005 somewhere?  I would like to install it and start working with it.  It sounds exciting!  Please advise.

  15. Andy Norris says:

    I loved the awesome interactive-console sample with the manifold and the rolling balls that you presented at Lang.Net 2008. Any chance you’ll be posting that stuff here to play with?

  16. Andy – The manifold and rolling balls demo I showed at Lang.NET is actually part of the samples that ship with the F# distrubution at http://research.microsoft.com/fsharp/research.aspx.  This sample is in SamplesFSharpDirectX3DVisualizationDirectX.fsharpp.

  17. Very impressive indeed! I also wrote my own LINQ mandelbrot set generator (in C#) a few days ago using many of your techniques from the raytracer – http://latebound.blogspot.com/2008/03/generating-fractals-with-linq.html.

  18. Andrei says:

    Did you ever try Nemerle? This language really deserves to take a look at. And I think it’s better than F#

  19. John says:

    You have just outgeeked me by a power of 10, at least.

    Hangs tail between legs and goes home

  20. Joyce says:

    Detail introduction about these codes?

    Waiting on line!

Skip to main content