A question that comes up early in F# demonstrations is, "Can I use F# to
access code written in my favorite .NET language, <BLANK>?" The answer is an
emphatic yes. F# is a first-class .NET citizen that compiles to
the same IL as
any other .NET language. Consider the following code:
The above code1 instantiates a new
TValue> for int and string, and adds three key/value pairs to it.
Note that Dictionary is not written in F#. It is part of the .NET base class
library, written in C#.
Retrieving values from d is easy.
We simply pass the value's key to the dictionary's indexer like so:
However, if we pass a key that isn't found in the
dictionary, an exception is thrown.2
Fortunately, Dictionary provides a
function that allows us to query using an invalid key without throwing an exception. This
has the following signature (shown in C#):
The purpose of TryGetValue is obvious. If key is found, the
function returns true
and the value is returned in the output parameter3.
If key is not found, the
function returns false and value contains some
The C# code below demonstrates how this function might be used.
So, how can we use this function in F#? Well, there're a few ways.
The first approach is almost exactly the same as the C# version above. First,
we declare a variable to pass as the output parameter. Note that
this variable must be declared as mutable so TryGetValue can modify it.
Now, we can call TryGetValue, passing v by reference.
OK. That worked but displayed an ugly warning about non-verifiable code.
Fortunately, F# provides another way to declare variables which support
Declaring a variable as a reference cell is trivial:
We can pass the reference cell into TryGetValue without receiving
that nasty warning.
That's much better.
At this point, many of you are probably thinking, "Wait a minute! Wasn't this
article supposed to be about tuples? What's all this
mutable-variable-output-parameter stuff?" Don't worry. There's a method to my
madness. Are you ready?
Consider what happens if we call TryGetValue without
specifying a variable for the output parameter:
Did you catch that? When calling a function containing output parameters in F#, you
don't have to specify variables for them. The F# compiler will automatically
consolidate the function's result and output parameters into a tuple (in
this case, a pair).
Awesome! If you were paying attention
time, you've probably already realized that we can bind the
to a pattern that extracts the values from the resulting pair.
Now, we can easily query our dictionary using an invalid key without an
exception being thrown. Best of all, we don't have to declare an awkward mutable variable to
store the value. What takes two lines of code in C# consumes just one in F#.
It is the attention to detail that makes it a joy to code with F#. This is just one example of how F# can
consume .NET framework classes in ways more
elegant than even C#, the
lingua franca of the .NET universe!
I haven't decided what the next article will cover yet. Are there any
requests? Feel free to email them to dustin AT diditwith.net.
1The #light directive in the
first line of the code sample
F# lightweight syntax. We'll look closer at this in a future article.
2This might be frustrating to users of the
System.Collections.Hashtable class from .NET Framework 1.0. Unlike
Dictionary, Hashtable returns null when a key isn't found
rather than throwing an exception. The reason for this behavior difference is
3Normally, I would consider the use of output parameters to be a
code smell. However, TryGetValue is an example
of a scenario where an output parameter is justified.
4We'll be looking more deeply into reference cells in a future article.
Page rendered at Sunday, May 19, 2013 3:56:03 PM (Pacific Standard Time, UTC-08:00)
If feel a bit behind and need to catch up on WPF, this is the book.
Great book on F# containing from Beginner to Advanced. It even has chapters on more arcane features of the language, such as Computation Expressions and Quotations.
Because this book provides source code in Standard ML, it's a fantastic
resource for learning F#. One bit of warning: this book does not teach classic
data structures. While structures such as binomial heaps and red-black trees
are presented, it is assumed that the reader already knows and understands
The opinions expressed herein are my own personal opinions and do not represent
my employer's view in any way.