F＃中的字典推导（？）（从C＃转换）

Question

OK, so, I'm just starting out learning F#. I have some exposure to functional languages from university etc, but still I'm quite green when it comes to real world programming in languages such as F#.

On a day-to-day basis I work in C#, but today I had the opportunity to spend some time with my company's code base, and look at it from an F# perspective. I decided to try to rewrite some of our C# code in F#, to get a feel for the language in a realistic business setting.

Here's a paraphrase of some C# code that I struggled to translate:

// MyData is a class with properties Id, Analysis, and some other relevant properties
// Each pair of (Id, Analysis) is (should be) distinct
IEnumerable<MyData> data = // fetch from DB...

// dataDict[id[analysis]] = MyData object (or "row") from DB
var dataDict = new Dictionary<String, Dictionary<String, MyData>> ();
foreach(var d in data)
{
    if(!dataDict.ContainsKey(d.Id))
        dataDict.Add(d.Id, new Dictionary<string, MyData>());

    if (dataDict[d.Id].ContainsKey(d.Analysis))
    {
        logger.Warn(String.Format("Id '{0}' has more than one analysis of type '{1}', 
            rows will be ignored", d.Id, d.Analysis));
    }
    else
    {
        dataDict[d.Id].Add(d.Analysis, d);
    }
} 

My attempt at rewriting the loop in a "functional" manner resulted in the following code, but I don't feel all that good about it.

let dataDict = 
      dict [ 
        for d in data 
          |> Seq.distinctBy(fun d -> d.Id) -> d.Id, 
             dict [                                                                                                   
                 for x in data |> Seq.filter(fun a -> a.Id = d.Id) -> x.Analysis, x
             ]
      ]

A couple of issues with this code:

• It does not log a warning in case of duplicate (Id, Analysis) pairs, and, even worse
• I run through the data (at least) twice with the for and the Seq.filter.

How can I improve this? Am I doing it all wrong?

Answer 1

What I would consider a more functional approach:

let intoMap (data: seq<MyData>) = 
    Seq.fold (fun (datamap, dups) (data: MyData) -> 
        match datamap |> Map.tryFind data.Id with
        | Some submap when submap |> Map.containsKey data.Analysis -> 
            datamap, data :: dups
        | Some submap ->
            let ext = Map.add data.Analysis data submap
            (Map.add data.Id ext datamap), dups
        | None ->
            let submap = Map.ofArray [| (data.Analysis, data) |]
            (Map.add data.Id submap datamap), dups
        ) (Map.empty, List.empty) data

It's a fold over the data, so it traverses the sequence once. It's also more functional in that it's not side-effecting - instead of logging duplicates, they're collected and made part of the output. You can do whatever you like with them later.

Also, I use the immutable Map instead of Dictionary - I find Dictionary to be a kind of code smell in F# code. The mutability it provides has its uses in some more esoteric scenarios, but for actually holding and passing around data, I would use Map exclusively.

That's the answer to your immediate question - but to be honest, I would probably go for a separate function for finding and splitting out duplicates, and a separate function that would build up a map without caring for potential duplicates - even if that would mean multiple passes over the data.

Answer 2

Given your requirements, what you have is probably best. You can tighten the code a bit using pattern matching.

let dataDict = Dictionary<_,Dictionary<_,_>>()
for d in data do
    match dataDict.TryGetValue(d.Id) with
    | true, m when m.ContainsKey(d.Analysis) ->
        (d.Id, d.Analysis)
        ||> sprintf "Id '%s' has more than one analysis of type '%s', rows will be ignored" 
        |> logger.Warn
    | true, m -> 
        m.Add(d.Analysis, d)
    | _ ->
        let m = Dictionary()
        m.Add(d.Analysis, d)
        dataDict.Add(d.Id, m)