Re: DIP10005: Dependency-Carrying Declarations is now available for community feedback

[ArturG via Digitalmars-d]

On Friday, 30 December 2016 at 23:49:23 UTC, Andrei Alexandrescu 
wrote:

The main win, which indeed is not emphasized enough, is better 
encapsulation. Walter pointed that out, and I will redo the DIP 
to put that front and center.

Maybe i can provide an example where i think DCD's would be 
usefull.
Im experimenting with a more Qt like signals and slots 
implementation,
it introspects some type for function declarations with the 
@("Signal") uda
and mixes them into the current type.
It currently looks like this:

// moda.d
interface TestSignals
{
   import modb: TestType;
   @("Signal"):
      void someTestSig(TestType);
}

// modb.d
struct TestType{}

// test.d
class A : SignalObject
{
   import moda: TestSignals;
   import modb: TestType; // has to be manually imported for the 
generated signal

   mixin signalsOf!(SignalList, TestSignals);

   interface SignalList
   {
      @("Signal"):
         void foo(int);
         void bar(string, int = 100);
         int bar(int a, int b);
   }

   void someFun(string s) { s.writeln; }
}

class B : SignalObject
{
   struct SignalList
   {
      @("Signal"):
         void someSig(string);
   }

   mixin signalsOf!SignalList;

   void fooHandler(int i){ i.writeln; }

   int onBar(int a, int b){ writeln(a + b); return a + b; }
   void onBar(string s, int i){ writeln(s, i); }

   import modb: TestType;
   void someTestSigHandler(TestType t){ t.writeln; }
}

class C : SignalObject
{
   import modb: TestType; // has to be manually imported for the 
generated signal

   mixin signalsOf!(A, B);

   // i wanted to support string based signal declaration
   // but that would require double manual import declarations

   // import modb: TestType;

   // enum signalList =
   // q{
   //    import modb: TestType;
   //    @("Signal"):
   //    void someSig(TestType);
   //    int someOtherSig();
   // }

   // mixin signalsOf!signalList;
}

void main(string[] args)
{
   auto a = new A;
   auto b = new B;
   auto c = new C;

   a.connect!"foo"(&b.fooHandler);
   a.connect(b); // connect all bar's with all onBar's

   a.foo(66);
   a.bar("asd");
   a.bar(4, 6);

   c.connect!"someSig"(&b.someSig);
   b.connect!"someSig"(&a.someFun);

   c.someSig("emitted by c forwarded by b handled by a");

   a.connect!"someTestSig"(&b.someTestSigHandler);
   c.connect!"someTestSig"(&b.someTestSigHandler);

   import modb: TestType;
   TestType t;
   a.someTestSig(t);
   c.someTestSig(t);
}

i assume with DCD's i could remove those manual imports if they 
get some traits.