theburningmonk.com

In C#, you can use the object/collection ini­tial­iza­tion syn­tax like this:

The F# equiv­a­lent of object ini­tial­iza­tion is done like this:

As for col­lec­tion ini­tial­iza­tion, you have a far more diverse range of tools avail­able to you, for example:

You can also cre­ate slices of an exist­ing array:

You can even add your own multi-dimensional index­ers to sup­port sim­i­lar behav­iours in your type too!

Update 2012/01/11:

As Robert Pick­er­ing men­tioned in the com­ments, slic­ing is not lim­ited to arrays, it works with other col­lec­tion types too (as long as a Get­Slice exten­sion method is defined on the type, for more infor­ma­tion, see here). For instance, you can use slic­ing on a string like this:

With 2D arrays, you can also use a multi-dimensional slicer too:

If you’re read­ing this post, you prob­a­bly know about F#’s Units of Mea­sure already, it’s very use­ful when work­ing with real-world units and adds extra safety to code that needs to work with and con­vert from one unit to another.

Here’s a quick snip­pet that shows you how to define and use units-of-measure:

This code out­puts the fol­low­ing, note the units asso­ci­ated with the float values:

As you can see, units of mea­sure can also be com­pounded by mul­ti­pli­ca­tion or division!

If you have a func­tion that requires a int<m>, you won’t be able to call the func­tion with a nor­mal int, hence pro­vid­ing you with extra pro­tec­tion to ensure the cor­rect­ness of your appli­ca­tion because the unit of a numeric value is now a for­mal con­tract between a func­tion and its caller:

Hav­ing said that, there are cases where you want to be able to con­vert between an int and an int<m>. For instance, to pro­vide bet­ter inter­op­er­abil­ity with other .Net lan­guages, as units-of-measure only exists in F# there’s no way to cre­ate a numeric value with units-of-measure in C# (that I’m aware of anyway).

To con­vert from int<m> to int (or any other numeric type) is easy, just do a straight cast:

Going the other way is slightly more tricky, you can’t use int<m> to cast an int to an int<m>, but you can either mul­ti­ply the value with 1<m> or use the Int32WithMeasure method on the Lan­guagePrim­i­tives core module:

In C#, you define an empty class, struct, or inter­face like this:

So how do you define an empty type in F#?

Well, when­ever you define a new class in F#, the com­piler infers the class and end tokens at the begin­ning and end of the class’s def­i­n­i­tion, as you can see from below:

So the eas­i­est way to define an empty type is to spec­ify the class and end tokens explicitly:

Run­ning these few lines of code into the F# inter­ac­tive out­puts the following:

For class types, you also have other alter­na­tive tech­niques, such as:

There’re a num­ber of built-in lit­eral types in F#, and one of the cool things you can do is to get the byte or byte array rep­re­sen­ta­tion of a char or string using the ‘B’ suf­fix, the result is the same as Encoding.ASCII.GetBytes:

Pretty cool, eh?