problems with Rebindable

[chmike via Digitalmars-d-learn]

On Saturday, 21 May 2016 at 13:17:11 UTC, ag0aep6g wrote:
> On 05/21/2016 12:42 PM, chmike wrote:
>>      Rebindable!Info x1, x2 = Infos.one;
>
> Rebindable!(immutable Info) x1, x2 = Infos.one;

Indeed. Thanks. Reading the unit tests in the source code and the 
implementation of Rebindable helped.

Note however that it doesn't work with immutable. It only works 
with constant. I guess this is because immutable is "stronger" 
than const. I determined that only const was supported by looking 
at Rebindable's code.

Here is the code that finally works as I want. The flyweight 
pattern is thus well supported with the exception that switch 
can't be used.

using static functions to get the Infos.one also allow to 
implement lazy object instantiation.

----
import std.stdio;
import std.typecons;


interface IInfo {
     string toString() const;
}

// alias Rebindable!(immutable IInfo) Info;  <-- Doesn't compile
alias Rebindable!(const IInfo) Info;

class Infos {

     static class Obj : IInfo
     {
         this(string msg) { this.msg = msg; }
         private string msg;
         override string toString() const { return msg; }
     }

     static Info one()
     {
         static auto x = Info(new Obj("I'm one"));
         return x;
     }
     static Info two()
     {
         static auto x = Info(new Obj("I'm two"));
         return x;
     }
}

void main()
{
     Info x1;
     Info x2 = Infos.one;

     assert(x1 is null);
     assert(x2 !is null);
     assert(x2 is Infos.one);
     assert(x2 == Infos.one);

     x1 = x2;
     assert(x1 is x2);
     assert(x1 == x2);

     assert(x1 is Infos.one);
     assert(x1 == Infos.one);

     writeln(x1);

     Info x3 = Info(new Infos.Obj("I'm one"));
     assert(x1 !is x3);
     assert(x1 != x3); // Because there is no opEqual for deep 
equality test

     IInfo o1 = new Infos.Obj("I'm one"), o2 = new Infos.Obj("I'm 
one");
     assert(o1 !is o2);
     assert(o1 != o2); // What I need for the flyweight pattern

     /* -- Doesn't compile : x1 is not a string or integral value
     switch(x1)
     {
     case Infos.one: writeln("case Infos.one"); break;
     default: writeln("default"); break;
     }
     */
}

I wasn't indeed using Rebindable correctly and it support only 
const objects, not immutable objects.

Thank you everybody for your help.