• Melvin (30/30) May 09 2018 I'm trying to find a friendly syntax for defining things in a
• Simen =?UTF-8?B?S2rDpnLDpXM=?= (8/29) May 09 2018 I'm afraid a mixin is the only real solution. You could also mark
• arturg (28/58) May 09 2018 hi, i actually have something like that, which i should put on

Melvin <mxtcapps gmail.com> writes:

I'm trying to find a friendly syntax for defining things in a 
framework. For context, I've been looking into finding a solution 
for this problem 
(https://github.com/GodotNativeTools/godot-d/issues/1) on the 
Godot-D project. I've done some investigating already, and it 
looks like I can only achieve what I want with a mixin, but I'd 
like to get a second opinion.

Say we have a class that defines a custom Signal (an event). In 
an ideal world, the syntax would work similarly to this:

class SomeNode : GodotScript!Node
{
      Signal void testSignal(float a, long b);
     // The declaration above would trigger the generation of this 
line
     void testSignal(float a, long b) { 
owner.emitSignal("testSignal", a, b); }

      Method emitTest()
     {
         testSignal(3.1415, 42);
     }
}


The reason I want to use a UDA is to stay consistent with the 
other UDAs already defined for Properties and Methods. It also 
looks friendlier than using a mixin. Does anyone here have any 
thoughts as to how this could work?

My main issue is injecting that generated method without 
resorting to using a mixin. I was hoping that any code I needed 
could be generated in the template that SomeNode inherits, but 
that doesn't look possible because I can't inspect the subclass 
(for good reason).

Simen =?UTF-8?B?S2rDpnLDpXM=?= <simen.kjaras gmail.com> writes:

On Wednesday, 9 May 2018 at 10:16:22 UTC, Melvin wrote:
 class SomeNode : GodotScript!Node
 {
      Signal void testSignal(float a, long b);
     // The declaration above would trigger the generation of 
 this line
     void testSignal(float a, long b) { 
 owner.emitSignal("testSignal", a, b); }

      Method emitTest()
     {
         testSignal(3.1415, 42);
     }
 }


 The reason I want to use a UDA is to stay consistent with the 
 other UDAs already defined for Properties and Methods. It also 
 looks friendlier than using a mixin. Does anyone here have any 
 thoughts as to how this could work?

 My main issue is injecting that generated method without 
 resorting to using a mixin. I was hoping that any code I needed 
 could be generated in the template that SomeNode inherits, but 
 that doesn't look possible because I can't inspect the subclass 
 (for good reason).

I'm afraid a mixin is the only real solution. You could also mark 
testSignal as abstract, and have a template generate an 
implementation class, but that would pollute every place where 
you want to use a SomeNode, with something like SomeNode n = 
implement!SomeNode();

--
   Simen

arturg <var.spool.mail700 gmail.com> writes:

On Wednesday, 9 May 2018 at 10:16:22 UTC, Melvin wrote:
 I'm trying to find a friendly syntax for defining things in a 
 framework. For context, I've been looking into finding a 
 solution for this problem 
 (https://github.com/GodotNativeTools/godot-d/issues/1) on the 
 Godot-D project. I've done some investigating already, and it 
 looks like I can only achieve what I want with a mixin, but I'd 
 like to get a second opinion.

 Say we have a class that defines a custom Signal (an event). In 
 an ideal world, the syntax would work similarly to this:

 class SomeNode : GodotScript!Node
 {
      Signal void testSignal(float a, long b);
     // The declaration above would trigger the generation of 
 this line
     void testSignal(float a, long b) { 
 owner.emitSignal("testSignal", a, b); }

      Method emitTest()
     {
         testSignal(3.1415, 42);
     }
 }


 The reason I want to use a UDA is to stay consistent with the 
 other UDAs already defined for Properties and Methods. It also 
 looks friendlier than using a mixin. Does anyone here have any 
 thoughts as to how this could work?

 My main issue is injecting that generated method without 
 resorting to using a mixin. I was hoping that any code I needed 
 could be generated in the template that SomeNode inherits, but 
 that doesn't look possible because I can't inspect the subclass 
 (for good reason).

hi, i actually have something like that, which i should put on 
github.

i used it to learn about D's introspection, so its more of a 
prototype and will need some more work.

it looks like this:

class Test
{
     mixin signalsOf!SigList;

     interface SigList
     {
          Signal void someFun(int);
     }

     void someFunHandler(int){}
}

signalsOf takes a type/template or function list, introspects 
them then generates the actual signal functions.
the additional api is similar to qt's api.

void main()
{
     Test t = new Test;
     t.connect!"someFun"(&t.someFunHandler);
     t.someFun(4); // emit the signal
     t.disconnect!"someFun"(&t.someFunHandler);
}

you can have different connection types and i also have string 
based connection and auto connection based on a naming convetion 
like signalname: someSig and slotname: onSomeSig.