Question

I would like to define a type such as:

type blah =
     AThing
   | AnotherThing
   with 
     static member ofString : string -> blah
     override x.ToString () : string

I would like to make sure that the two methods are always guaranteed to be consistent. A good way of doing this would be to construct two maps from the same list of pairs, and then turn them into the obvious implementations of the two methods. Roughly:

let pairs = [Athing, "AThing"; AnotherThing, "AnotherThing"]
let tostr = Map.ofList pairs
let toblah = pairs |> List.map swap |> Map.ofList

I think this code can only be defined in a static member function. The static bit is implied by it needing to be accessible from ofString, which is static. It cannot be defined before the type, since the list relies on it. It cannot be defined afterwards because F# does not allow methods to be just declared and implemented later (in the same way that e.g. C++ would). So that leaves the choice between a static member and a static let. The compiler says that static lets are not allowed in an augmentation. (?)

The code works fine when put into a static member function, however it makes the maps every time they are needed. Needless to say, this is even less efficient than linear search. How do I do it correctly please? Many thanks.

Answer 1

Here’s the code that works as required:

type blahFactory() =
    static let pairs = printf "array initialized; "; [AThing, "AThing"; AnotherThing, "AnotherThing"]
    static member tostr = Map.ofList pairs
    static member toblah = pairs |> List.map swap |> Map.ofList
and blah =
    | AThing
    | AnotherThing
    with
    static member ofString (string) = blahFactory.toblah.[string]
    override x.ToString () = blahFactory.tostr.[x]

I’ve placed printf instruction to demonstrate the array is initialized just once.

Several thoughts you may consider useful.
First, using DU is overhead for sample provided. If your data is that simple, you may consider enum types.
If you really mean DU, that may be sign of possible problems in the future. Consider this:

type blah =
    | AThing of string
    | AnotherThing of int * int

Both construction and comparison will be impossible in this case.

Do you have any reasons not to use standard XML serialization?