CODEWITHSUNDEEP
f#
Thomas
Thomas

Reputation: 12107

Confused about static dictionary in a type, in F#

With this type:

type A =
    {
        S: string
    }

    static member private l = Dictionary<string, A>()
    static member add s = A.l.[s] <- { S=s }
    static member list () = l.Values

if I do:

A.add "hello"
A.add "world"

I'd expect A.list() to return something since the dictionary is static, but it returns an empty list. Why is that?

To clarify what I'm trying to do: I'd like to have the ability to register the objects of type A into a static dictionary that is attached to the type itself as it would make the object repository 'self contained' in the type, in a way.

Upvotes: 1

Views: 115

Answers (1)

Fyodor Soikin
Fyodor Soikin

Reputation: 80744

Your l is not a field, but a property with a getter.

A "property", contrary to appearances, is not a memory cell with some value in it. A "property" is a pair of get+set functions. Just functions, that's all. No memory cell.

So what you made yourself is a property with a getter (without a setter), and all that getter does is create a new Dictionary and return it.

This means, every time you access A.l, you get yourself a new, fresh dictionary. Because l is a function, not a memory cell.

Now, in order to make a memory cell (aka "field"), one would ordinarily use static member val, like so:

static member val private l = Dictionary<string, A>()

Unfortunately, in this particular case this doesn't work, because static fields are not permitted on F# records and unions. They work fine on actual classes, but not on F# types.

So instead what I would recommend is to put those functions in a module rather than making them static methods:

type A = { S: string }

module A =
  let private l = Dictionary<string, A>()
  let add s = l.[s] <- { S=s }
  let list () = l.Values

(and just in general: try to use fewer classes and more modules and functions; they're more idiomatic in F# and lead to fewer problems in general)

Now this works as expected:

> A.add "hello";;
val it : unit = ()

> A.add "world";;
val it : unit = ()

> A.list();;
val it : Dictionary`2.ValueCollection<string,A> =
  seq [{ S = "hello" }; { S = "world" }]

Upvotes: 5

Related Questions