F# How to implement Singleton Pattern (syntax)

Question

I have a cache of data which is getting refreshed from an outside source, and I want to limit my access tot his cache (readonly) inside of my app. I don't want to have refresh the datasource everytime I need access to it (ie. on instantiation go and pull all the data I need, as there is quite a bit of data that is being kept up to date).

type MySingleton = 

        [<DefaultValue>]
        static val mutable private instance: MySingleton

        static member GetInstance() = 
            instance

I guess this is one of the gotchas about implementing a project and trying to learn the language at the same time. I know the logic needs to be

if instance is null
    synchronize
    if instance is null
        instance = new MySingleton()

but the lack of null is throwing me for a loop. I think I can use an option type etc but it is throwing me for a loop

type MySingleton = 

        [<DefaultValue>]
        static val mutable private instance: MySingleton option

        static member GetInstance() = 
            match instance with
                 | Some(i) -> i
                 | None -> 
                            *MySingleton.instance = new MySingleton()
                            MySingleton.instance*

that logic is wrong according to the compiler...

       if Helper.notExists MySingleton.instance then
            MySingleton.instance <- Some(new MySingleton())        
       MySingleton.instance 

should I be using IF statements instead? Is there a prefered pattern for this syntax in f#?

Thank you

Answer 1

Both .NET 4.0 and F# have Lazy, so I think you want

module MySingleton =
    let private x = Lazy.Create(fun() -> 42)
    let GetInstance() = x.Value

(where 42 might be a new WhateverType() or whatever the expensive initialization is).

http://msdn.microsoft.com/en-us/library/dd997286.aspx

(Commentary: It's 2010, and getting rare to have to explicitly deal with synchronization primitives; languages and libraries are encapsulating all the common patterns.)

Answer 2

The Lazy type as Brian mentioned is a good place to start with. It allows you to ensure that a computation will be run when the value is needed and it guarantees thread safety, meaning that the computation will run only once (although, in some cases, you may also use PublicationOnly option to specify that multiple threads may start to initialize cache and only the first result will be used).

However, you'll probably also need a mechanism for marking the cache as invalid (e.g. after some specified time) and forcing re-initialization of the cache. Note that this isn't really a Singleton pattern. Anyway, you can still do this in a thread safe way using Lazy, but you'll need to structure the code like this:

module Cache = 
  // returns a lazy value that initializes the cache when 
  // accessed for the first time (safely)
  let private createCacheInitialization() = 
    lazy( // some code to calculate cache 
          cache )
  // current cache represented as lazy value
  let private mutable currentCache = createCacheInitialization()

  // Returns the current cache
  let GetCache() = currentCache.Value
  // Reset - cache will be re-initialized next time it is accessed
  // (this doesn't actually initialize a cache - just creates a lazy value)
  let Reset() = currentCache <- createCacheInitialization()

Of course, you could turn this code into a Cache class that takes only the initialization function and encapsulates the rest of the code into a reusable piece (if you need to cache multiple values, for example).

Answer 3

The original question was "how to implement a Singleton pattern in F#", not "how to implement a Lazy-Load pattern". A singleton is a type that guarantees that there exists exactly one instance of itself overall. Therefore, control over creation of the "one and only" instance must reside completely within the type itself. Using explicit type construction, this is rather difficult to achieve:

/// This type is intended for private use within Singleton only.
type private SyncRoot = private new() = {}

type Singleton =
    // Cannot use implicit ("let"-bound) fields, because the class 
    // is constructed explicitly.
    // --> Must use explicit ("val"-bound) fields. 
    // --> Explicit fields who are static must always be 
    //     default-initialized, mutable, and private.
    [<DefaultValue>] static val mutable private instance: Singleton

    private new() = {}

    static member Instance = 
        let isNull() = 
            Unchecked.compare Singleton.instance Unchecked.defaultof<Singleton> = 0

        if isNull() then
            lock typeof<SyncRoot> (fun() ->
                if isNull() then
                    Singleton.instance <- new Singleton())

        Singleton.instance

However, using implicit type construction, it can be done in a thread-safe way with only few lines of code:

type Singleton private() =
    static let instance = new Singleton()
    static member Instance = instance

Which is the same as:

type public Singleton private() =
    static let instance = new Singleton()
    static member public Instance = instance

Edit
In the original example, I commented that a primary constructor's accessibility is always the same as the type's accessibility. However, after further experimenting, I finally found out that a primary constructor can have its own access modifier, in addition to the type's access modifier. This was also mentioned in kvb's comment. I therefore revised the example. Unfortunately, this is not documented yet in the F# 2.0 specification, nor in the MSDN documentation. The example presents yet one more reason to prefer implicitly constructed types whenever possible over explicitly constructed ones.

Answer 4

Sorry to reanimate an old question, just wanted to point out that some might try to expose Instance in a public property, in which case the following piece of code might be useful:

type MyType() =
  inherit SomeParent()

  static let mutable instance = lazy(new MyType())
  static member Instance with get() = instance.Value