Question

I am looking for an efficient indexed persistent data structure. I typically work in .NET and am aware of FSharp’s Map however that implementation and most others I am aware of only provide a single ‘index’, the left side of the mapping.

Basically here is the scenario

public class MyObject
    public int Id { get; }
    public int GroupId { get; }
    public string Name { get; }

Where the Id of an object will be globally unique set of items added. GroupId may have duplicate values, and I want to be able to query for all values with a matching GroupId and within a GroupId names will be unique but may be duplicated across different GroupId’s. This not a situation where I can simply create a composite key of the 3 fields as I need independent access to groups of the items based on particular field values.

I can do this, and have in the past, using dictionaries of dictionaries, which has been recommended in other posts here on STackoverflow…however, I also want the data structure to be
1) Fully Persistent and everything that means
2) efficient in memory – meaning that versions need to share as many nodes as possible
3) efficient in modifcations – I would like it to be fast

I realize that I am asking for quite a bit here but I wanted to ask to avoid even trying to re-invent the wheel if it has already been done.

Thanks

Answer 1

I am not sure why elsewhere, and in existing replies to your question, people recommend to imbricate existing structures. Imbricating structures (maps of maps, maps of lists, dictionaries of dictionaries, …) only works for two indexes if one is looser than the other (two values having the same index for Index1 implies these two values have the same index for Index2), which is an unnecessary constraint.

I would use a record of maps, as many of them as you want different indexes, and I would maintain the invariant that every value that is present in a map is present in all the others in the same record. Adding a value obviously requires adding it to all maps in the record. Similarly for removal. The invariant can be made impossible to transgress from the outside through encapsulation.

If you worry that the values stored in your data structure would be duplicated, don’t. Each map would only contain a pointer. They would all point to the same single representation of the value. Sharing will be as good as it already is with simple single-indexed maps.