I’ve found the process slow, and the learning curve painfully steep, but completely fascinating, and rewarding. There’s a dearth of good books, but if you have a solid grasp of the basics “F# for Scientists” is pretty good.

A dictionary enumerates as a sequence of KeyValuePairs, so if d is the same Dictionary as above

d |> Seq.fold_left (fun acc kvp -> acc.add kvp.Key kvp.Value) Map.empty

is all you need.

I’m translating “Programming Collective Intelligence”, a pretty damn interesting book on data analysis - something I’m sure you MMO guys are all over - into F# over at http://code.google.com/p/dataviz

I don’t have much to show for it yet, but it’s powerful stuff. Take a look if your interested.

http://cs.hubfs.net/ is also worth looking at if you haven’t already.

http://wfrobozz.blogspot.com/2008/09/visual-c-2008-express-and-3264-bit.html

#light

open System.Collections.Generic
let d = new Dictionary<string,int>()
d.["one"] <- 1
d.["two"] <- 2
d.["three"] <- 3
let keyValuePairs = (d :> seq<_>)
let m = keyValuePairs |> Seq.map (fun kvp -> (kvp.Key, kvp.Value)) |> Map.of_seq
for kvp in m do
printfn “%s -> %d” kvp.Key kvp.Value

#light

open System.Collections.Generic
let d = new Dictionary<string,int>()
d.["one"] <- 1
d.["two"] seq<_>)
let m = keyValuePairs |> Seq.map (fun kvp -> (kvp.Key, kvp.Value)) |> Map.of_seq
for kvp in m do
printfn “%s -> %d” kvp.Key kvp.Value

#light

open System.Collections.Generic
let d = new Dictionary()
d.["one"] <- 1
d.["two"] <- 2
d.["three"] seq)
let m = keyValuePairs |> Seq.map (fun kvp -> (kvp.Key, kvp.Value)) |> Map.of_seq
for kvp in m do
printfn “%s -> %d” kvp.Key kvp.Value

As you have noted, immutable data structures are often 10x slower than their mutable counterparts and, consequently, their elegant style can be great for making concurrent programming easier but it is virtually useless for parallelism because computational efficiency is critical there.

However, you will find that F# is enormously beneficial for both concurrent and parallel programming. Concurrent programming is greatly simplified in F# thanks to its Erlang-style support via asynchronous workflows. Parallelism is greatly aided in F# thanks to improved code factoring via first-class functions and the Task Parallel Library.

High performance parallelism has already been covered in one of our F#.NET Journal articles and concurrency will be covered soon.

Regards,
Jon Harrop.