www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - immutable singleton pattern with static opCall

reply Justin Johansson <no spam.com> writes:
The following declaration implements the classic singleton
design pattern and uses D's static opCall feature to make
for brevity of use, that is to say, you can access the singleton
instance by simply writing Foo() rather than Foo.instance.

Furthermore, the use of private on the static instance forces
use of the function call style idiom, i.e. Foo(), rather than
the long hand form Foo.instance.

class Foo
{
    static private Foo instance;

    static this() {
       instance = new Foo;
    }

    static Foo opCall() {
       return instance;
    }
}


Now I would like to make this class immutable.  How many times
should I have to type the immutable keyword to achieve this result?

Ideally once only would be my answer.  But the following, possibly naive
code, does not compile:

immutable class Foo
{
    static private Foo instance;

    static this() {			// line 9
       instance = new Foo;
    }

    static Foo opCall() {		// line 13
       return instance;
    }
}

test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot 
be const/immutable
test.d(13): Error: function test.Foo.opCall without 'this' cannot be 
const/immutable

How should this declaration best be written to achieve my design?  One
variation I have is as follows but it is very noisy with the immutable
keyword.

class Foo
{
    static private immutable Foo instance;

    static this() {
       instance = cast(immutable Foo) new Foo;
    }

    static immutable(Foo) opCall() {
       return instance;
    }
}
Jun 26 2010
parent reply Michal Minich <michal.minich gmail.com> writes:
On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:

 immutable class Foo
 {
     static private Foo instance;
 
     static this() {			// line 9
        instance = new Foo;
     }
 
     static Foo opCall() {		// line 13
        return instance;
     }
 }
 
 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...
Jun 26 2010
next sibling parent Justin Johansson <no spam.com> writes:
Michal Minich wrote:
 On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:
 
 immutable class Foo
 {
     static private Foo instance;

     static this() {			// line 9
        instance = new Foo;
     }

     static Foo opCall() {		// line 13
        return instance;
     }
 }

 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...

Thanks for your quick response and analysis. I agree that "it should affect static data". Since this bug impedes the use of good functional style, imho this is a *serious* bug.
Jun 26 2010
prev sibling next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Sat, 26 Jun 2010 20:19:44 -0400, Michal Minich  
<michal.minich gmail.com> wrote:

 On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:

 immutable class Foo
 {
     static private Foo instance;

     static this() {			// line 9
        instance = new Foo;
     }

     static Foo opCall() {		// line 13
        return instance;
     }
 }

 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...

static variables inside an immutable class should be immutable. That was considered in the bug report and purposefully left out. The issue is that the compiler incorrectly labels static *functions* as immutable which makes no sense, static functions cannot be immutable ever. Static data can be. BTW, you can work around this problem like this: class Foo { static immutable instance; // no need to make private, it can never change static this() { instance = new Foo; // not sure if this works, you may have to cast. } static immutable(Foo) opCall() { return instance; } immutable: // member functions } -Steve
Jun 28 2010
parent reply Justin Johansson <no spam.com> writes:
Steven Schveighoffer wrote:
 On Sat, 26 Jun 2010 20:19:44 -0400, Michal Minich 
 <michal.minich gmail.com> wrote:
 
 On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:

 immutable class Foo
 {
     static private Foo instance;

     static this() {            // line 9
        instance = new Foo;
     }

     static Foo opCall() {        // line 13
        return instance;
     }
 }

 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...

static variables inside an immutable class should be immutable. That was considered in the bug report and purposefully left out. The issue is that the compiler incorrectly labels static *functions* as immutable which makes no sense, static functions cannot be immutable ever. Static data can be. BTW, you can work around this problem like this: class Foo { static immutable instance; // no need to make private, it can never change static this() { instance = new Foo; // not sure if this works, you may have to cast. } static immutable(Foo) opCall() { return instance; } immutable: // member functions } -Steve

Thanks Steve. btw. The reason I marked the static instance member as private was simply to enforce stylist use of Foo() rather than Foo.instance You guess is correct; I found that you have to use a cast with instance = new Foo but then I discovered that you can avoid the cast by writing a trivial constructor marked with immutable, i.e. immutable this {} Though this doesn't reduce the headcount of the uses of the immutable keyword, I think it looks nicer than a cast. Your idea of immutable: though is good for the remainder of the member functions (and the trivial ctor). My immutable singleton pattern now looks like this :-) class Foo { // following marked private for stylistic enforcement static immutable private Foo instance; static this() { // following works without cast thanks to immutable ctor instance = new Foo; } static immutable(Foo) opCall() { return instance; } immutable: this() {} // more immutable member function decls following // .. } Cheers Justin
Jun 28 2010
next sibling parent reply Justin Johansson <no spam.com> writes:
Steven Schveighoffer wrote:
 On Mon, 28 Jun 2010 08:07:40 -0400, Justin Johansson <no spam.com> wrote:
 
 Steven Schveighoffer wrote:

 btw. The reason I marked the static instance member as private
 was simply to enforce stylist use of Foo() rather than Foo.instance

Yuck Foo().xyz :) But, whatever floats your boat.

He he, that's a cute quip.
 To go one step further, if you want it to truly be a singleton type, you 
 should mark the constructor private.
 
 -Steve

Indeed. I forgot the private constructor in this version but had it in earlier versions. Continuing on with the saga, it's a pity that immutable is not compatible with Object toString method without a cast. class Foo { static immutable private Foo instance; static this() { instance = new Foo; } static immutable(Foo) opCall() { return instance; } immutable: private this() {} } void main() { // numerous compile errors if the cast is left out stdout.writefln( "Foo() = %s", cast(Foo) Foo()); } JJ
Jun 28 2010
parent Justin Johansson <no spam.com> writes:
Steven Schveighoffer wrote:
 On Mon, 28 Jun 2010 08:40:36 -0400, Justin Johansson <no spam.com> wrote:
 
 Steven Schveighoffer wrote:
 On Mon, 28 Jun 2010 08:07:40 -0400, Justin Johansson <no spam.com> 
 wrote:

 Steven Schveighoffer wrote:

you should mark the constructor private. -Steve

Indeed. I forgot the private constructor in this version but had it in earlier versions. Continuing on with the saga, it's a pity that immutable is not compatible with Object toString method without a cast. class Foo { static immutable private Foo instance; static this() { instance = new Foo; } static immutable(Foo) opCall() { return instance; } immutable: private this() {} } void main() { // numerous compile errors if the cast is left out stdout.writefln( "Foo() = %s", cast(Foo) Foo()); }

That's because toString should be a const function. See http://d.puremagic.com/issues/show_bug.cgi?id=1824 please vote for the bug. -Steve

That's a pretty fundamental oversight. just signed up new account (procode == me) and voted for the bug JJ
Jun 28 2010
prev sibling parent Justin Johansson <no spam.com> writes:
Steven Schveighoffer wrote:
 On Mon, 28 Jun 2010 08:07:40 -0400, Justin Johansson <no spam.com> wrote:
 
 Steven Schveighoffer wrote:
 On Sat, 26 Jun 2010 20:19:44 -0400, Michal Minich 
 <michal.minich gmail.com> wrote:

 On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:

 immutable class Foo
 {
     static private Foo instance;

     static this() {            // line 9
        instance = new Foo;
     }

     static Foo opCall() {        // line 13
        return instance;
     }
 }

 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...

That was considered in the bug report and purposefully left out. The issue is that the compiler incorrectly labels static *functions* as immutable which makes no sense, static functions cannot be immutable ever. Static data can be. BTW, you can work around this problem like this: class Foo { static immutable instance; // no need to make private, it can never change static this() { instance = new Foo; // not sure if this works, you may have to cast. } static immutable(Foo) opCall() { return instance; } immutable: // member functions } -Steve

Thanks Steve. btw. The reason I marked the static instance member as private was simply to enforce stylist use of Foo() rather than Foo.instance

Yuck Foo().xyz :) But, whatever floats your boat.

I should explain the method to my madness. Initially I was doing something else with static opCall and immutability and then ran into the problem covered in this thread. To save writing a long story on this ng I reduced the problem to something that could be easily understood by choosing to demonstrate it via the singleton pattern. My actual use case is not a singleton pattern at all. Rather my static opCall for the immutable class(es) in question will normally take one or more arguments. The arguments will be validated first by the static opCall. Only then if the arguments are valid will a constructor be called for some appropriate concrete subclass of the (abstract) class in which the static opCall is declared. This technique is reminiscent of a factory pattern though I'll be using it to effect a mechanism for memoizing results. The overall agenda, being truly idiomatic of functional programming, is to create a new instance of some class only if there has not already been an invocation of the static opCall with the same arguments. Cheers and thanks again to Steve & Michal for all help. Justin
Jun 28 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Mon, 28 Jun 2010 08:07:40 -0400, Justin Johansson <no spam.com> wrote:

 Steven Schveighoffer wrote:
 On Sat, 26 Jun 2010 20:19:44 -0400, Michal Minich  
 <michal.minich gmail.com> wrote:

 On Sun, 27 Jun 2010 09:36:04 +0930, Justin Johansson wrote:

 immutable class Foo
 {
     static private Foo instance;

     static this() {            // line 9
        instance = new Foo;
     }

     static Foo opCall() {        // line 13
        return instance;
     }
 }

 test.d(9): Error: function test.Foo._staticCtor2 without 'this' cannot
 be const/immutable
 test.d(13): Error: function test.Foo.opCall without 'this' cannot be
 const/immutable

there is bug report on this subject http://d.puremagic.com/issues/show_bug.cgi?id=3598 Your example also uses static variable, which was not considered in the bug report. This makes things more complex to design properly, because it seems now that one does not want static functions to be affected by immutable attribute of class, but it should affect static data...

was considered in the bug report and purposefully left out. The issue is that the compiler incorrectly labels static *functions* as immutable which makes no sense, static functions cannot be immutable ever. Static data can be. BTW, you can work around this problem like this: class Foo { static immutable instance; // no need to make private, it can never change static this() { instance = new Foo; // not sure if this works, you may have to cast. } static immutable(Foo) opCall() { return instance; } immutable: // member functions } -Steve

Thanks Steve. btw. The reason I marked the static instance member as private was simply to enforce stylist use of Foo() rather than Foo.instance

Yuck Foo().xyz :) But, whatever floats your boat.
 You guess is correct; I found that you have to use a cast with
 instance = new Foo
 but then I discovered that you can avoid the cast by writing
 a trivial constructor marked with immutable, i.e.
 immutable this {}

Ah, that is good. However, I was also unsure if a static immutable could be set inside a static constructor. That is also good, immutable has definitely gotten a lot easier to use!
 Though this doesn't reduce the headcount of the uses of the immutable
 keyword, I think it looks nicer than a cast.  Your idea of immutable:
 though is good for the remainder of the member functions (and the
 trivial ctor).

I have a feeling that the afore mentioned bug will eventually be fixed, and at that point, you can just make Foo an immutable class with no issues.
 My immutable singleton pattern now looks like this :-)


 class Foo
 {
     // following marked private for stylistic enforcement
     static immutable private Foo instance;

     static this() {
        // following works without cast thanks to immutable ctor
        instance = new Foo;
     }

     static immutable(Foo) opCall() {
       return instance;
     }

 immutable:
    this() {}

    // more immutable member function decls following
    // ..
 }

To go one step further, if you want it to truly be a singleton type, you should mark the constructor private. -Steve
Jun 28 2010
prev sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Mon, 28 Jun 2010 08:40:36 -0400, Justin Johansson <no spam.com> wrote:

 Steven Schveighoffer wrote:
 On Mon, 28 Jun 2010 08:07:40 -0400, Justin Johansson <no spam.com>  
 wrote:

 Steven Schveighoffer wrote:

you should mark the constructor private. -Steve

Indeed. I forgot the private constructor in this version but had it in earlier versions. Continuing on with the saga, it's a pity that immutable is not compatible with Object toString method without a cast. class Foo { static immutable private Foo instance; static this() { instance = new Foo; } static immutable(Foo) opCall() { return instance; } immutable: private this() {} } void main() { // numerous compile errors if the cast is left out stdout.writefln( "Foo() = %s", cast(Foo) Foo()); }

That's because toString should be a const function. See http://d.puremagic.com/issues/show_bug.cgi?id=1824 please vote for the bug. -Steve
Jun 28 2010