I'd like to have a Command class, where their is a name and a handler field:

```d
class Command
{
  string name;
  string delegate(string[]) handler;
}
```

this is ok, but sometimes I want the handler also accept a function (lambdas are init to functions if no capture of outer scope variables are present), but it can't.

So I'd like to generalize the Command to a template, the best I've got sofar:

```d

alias string delegate(string[]) HandlerDele;
alias string function(string[]) HandlerFunc;

class Command(T) if (is (T HandlerDele) || is (T HandlerFunc))
{
	immutable {
		string name;
		T handler;
	}

	this(string name, T handler)
	{
		this.name = name;
		this.handler = handler;
	}

}

void main()
{

	HandlerFunc f = xs => xs[0]; // just a test
	auto cmd = new Command!HandlerFunc("echo", f);
}
```

I've got several questions about this:

1. I cant ignore `HandlerFunc` when initiating cmd:

```d
auto cmd = new Command("echo", f); // Error: class dshell.command.Command(T) if (is(T HandlerDele) || is(T HandlerFunc)) is used as a type
```

Can DMD automatically infer the type here?

2. Is this the right way to do this?

3. I'd like a unified description of `a function pointer or a delegate`, and from the experience of lambda, it seems the syntax of lamdba is really useful here, if we have that, then instead of:

```d
void execute(T)(Context cxt, T handler) if (is (T HandlerFunc) || is (T HandlerDele))
{
  //...
}

we could define a function that accepts a function/delegate like this:

```d

void execute(T : string[] => string)(Context cxt, T handler)
{
  //...
}

// in main
ctx.execute(xs => xs[0]);

On 16/07/2014 3:50 p.m., Puming wrote:
> I'd like to have a Command class, where their is a name and a handler
> field:
>
> ```d
> class Command
> {
>    string name;
>    string delegate(string[]) handler;
> }
> ```
>
> this is ok, but sometimes I want the handler also accept a function
> (lambdas are init to functions if no capture of outer scope variables
> are present), but it can't.
>
> So I'd like to generalize the Command to a template, the best I've got
> sofar:
>
> ```d
>
> alias string delegate(string[]) HandlerDele;
> alias string function(string[]) HandlerFunc;
>
> class Command(T) if (is (T HandlerDele) || is (T HandlerFunc))
> {
>      immutable {
>          string name;
>          T handler;
>      }
>
>      this(string name, T handler)
>      {
>          this.name = name;
>          this.handler = handler;
>      }
>
> }
>
> void main()
> {
>
>      HandlerFunc f = xs => xs[0]; // just a test
>      auto cmd = new Command!HandlerFunc("echo", f);
> }
> ```
>
> I've got several questions about this:
>
> 1. I cant ignore `HandlerFunc` when initiating cmd:
>
> ```d
> auto cmd = new Command("echo", f); // Error: class
> dshell.command.Command(T) if (is(T HandlerDele) || is(T HandlerFunc)) is
> used as a type
> ```
>
> Can DMD automatically infer the type here?
>
> 2. Is this the right way to do this?
>
> 3. I'd like a unified description of `a function pointer or a delegate`,
> and from the experience of lambda, it seems the syntax of lamdba is
> really useful here, if we have that, then instead of:
>
> ```d
> void execute(T)(Context cxt, T handler) if (is (T HandlerFunc) || is (T
> HandlerDele))
> {
>    //...
> }
>
> we could define a function that accepts a function/delegate like this:
>
> ```d
>
> void execute(T : string[] => string)(Context cxt, T handler)
> {
>    //...
> }
>
> // in main
> ctx.execute(xs => xs[0]);

Or using std.functional toDelegate you could convert the function into a delegate.

class Command {
    string name;
    string delegate(string[]) handler;

    this(string name, string delegate(string[]) handler) {
        this.name = name;
        this.handler = handler;
    }

    this(string name, string function(string[]) handler) {
        import std.functional : toDelegate;
        this.name = name;
        this.handler = toDelegate(handler);
    }
}

Just keep in mind, you can't go the opposite way.

On Wednesday, 16 July 2014 at 04:10:13 UTC, Rikki Cattermole wrote:
> On 16/07/2014 3:50 p.m., Puming wrote:
>> I'd like to have a Command class, where their is a name and a handler
>> field:
>>
>> ```d
>> class Command
>> {
>>   string name;
>>   string delegate(string[]) handler;
>> }
>> ```
>>
>> this is ok, but sometimes I want the handler also accept a function
>> (lambdas are init to functions if no capture of outer scope variables
>> are present), but it can't.
>>
>> So I'd like to generalize the Command to a template, the best I've got
>> sofar:
>>
>> ```d
>>
>> alias string delegate(string[]) HandlerDele;
>> alias string function(string[]) HandlerFunc;
>>
>> class Command(T) if (is (T HandlerDele) || is (T HandlerFunc))
>> {
>>     immutable {
>>         string name;
>>         T handler;
>>     }
>>
>>     this(string name, T handler)
>>     {
>>         this.name = name;
>>         this.handler = handler;
>>     }
>>
>> }
>>
>> void main()
>> {
>>
>>     HandlerFunc f = xs => xs[0]; // just a test
>>     auto cmd = new Command!HandlerFunc("echo", f);
>> }
>> ```
>>
>> I've got several questions about this:
>>
>> 1. I cant ignore `HandlerFunc` when initiating cmd:
>>
>> ```d
>> auto cmd = new Command("echo", f); // Error: class
>> dshell.command.Command(T) if (is(T HandlerDele) || is(T HandlerFunc)) is
>> used as a type
>> ```
>>
>> Can DMD automatically infer the type here?
>>
>> 2. Is this the right way to do this?
>>
>> 3. I'd like a unified description of `a function pointer or a delegate`,
>> and from the experience of lambda, it seems the syntax of lamdba is
>> really useful here, if we have that, then instead of:
>>
>> ```d
>> void execute(T)(Context cxt, T handler) if (is (T HandlerFunc) || is (T
>> HandlerDele))
>> {
>>   //...
>> }
>>
>> we could define a function that accepts a function/delegate like this:
>>
>> ```d
>>
>> void execute(T : string[] => string)(Context cxt, T handler)
>> {
>>   //...
>> }
>>
>> // in main
>> ctx.execute(xs => xs[0]);
>
> Or using std.functional toDelegate you could convert the function into a delegate.
>
> class Command {
>     string name;
>     string delegate(string[]) handler;
>
>     this(string name, string delegate(string[]) handler) {
>         this.name = name;
>         this.handler = handler;
>     }
>
>     this(string name, string function(string[]) handler) {
>         import std.functional : toDelegate;
>         this.name = name;
>         this.handler = toDelegate(handler);
>     }
> }
>
> Just keep in mind, you can't go the opposite way.

Thanks. I wonder if functions could implicitly convert to delegates...but toDelegate is OK.


Also, after another dig into the language docs, I found:


> The .ptr property of a delegate will return the frame pointer value as a void*.

> The .funcptr property of a delegate will return the function pointer value as a function type.

> Future directions: Function pointers and delegates may merge into a common syntax and be interchangeable with each other.

Wonder how that would happen.

The compiler would generate calls to toDelegate and toFunction automatically.