在 F# 中将枚举转换为列表或序列或泛型集合类型

Question

I have a type that is either a Dictionary<string,Node<'a>>*Edge<'a> list or a ConcurrentDictionary<string,Node<'a>>*Edge<'a> list . I am trying to create a get_nodes function, but when I call .Values from the Dictionary and the ConcurrentDictionary , the functions return different types!

So I need to somehow convert both of the types into the same type for F# to compile...

The type given by Dictionary.Values is Dictionary'2.ValueCollection<string,Node<'a>> while the type yielded by ConcurrentDictionary is ICollection<Node<'a>> .

I figured out that both types have a "GetEnumerator()" function. What I need to do is somehow turn the enumerator into a seq or list, etc.

Here is my code:

   static member get_nodes (g:Graph<'a>) = 
        match g with 
        | Dictionary_Graph(nd,el) -> let n = nd.Values
                                     let enum = n.GetEnumerator()


        | ConcurrentDictionary_Graph(nd,el) -> let n = nd.Values
                                               let enum = n.GetEnumerator()

How do I pull the data out of the enum variable?

Answer 1

You are probably used to C# which would auto upcast the ValueCollection to an ICollection (which ValueCollection implements). F# does not do this, so you must manually cast the result of Dictionary.Values to ICollection.

let n = nd.Values :> ICollection<Node<'a>>

Full method would look something like this:

static member get_nodes (g:Graph<'a>) = 
    match g with 
    | Dictionary_Graph(nd,el) ->
        nd.Values :> ICollection<Node<'a>>
    | ConcurrentDictionary_Graph(nd,el) ->
        nd.Values

From what I understand, F# does not auto-upcast because of the way that the auto type inference engine works. It's irritating when you're used to C#, but it's a price worth paying to get automatic type inferencing. Also consider that in C#, you would have to specify the return type up front on the method, which makes it easy for C# to do the cast for you. F# engine infers the return type based on what you actually return, so the safest thing is to not make assumptions about how you want it cast.

Not general consensus, but my opinion: I hope they will add auto upcasting of return values for specific cases (like output type is declared ahead of time or to make branches conform like above), but it's a minor irritation for now.

Update (from question in comments)

ICollection<T> should now be directly usable as a sequence since it implements IEnumerable<T> . In this case auto-upcasting actually does work. :)

myGraph
|> Graph.get_nodes 
|> Seq.iter (fun x -> printfn "%A" x)