I am making heavy use of delegates in a D program I am currently writing.  They are awesome!

However, more than once I have found myself wishing that they could store more than just one argument.  Why can't you have delegates of any size?  Better yet (for the needs of my program) why can't you have delegates which have a VARIABLE number of implicit arguments?

I think I know (roughly) how to do this.



Stated roughly, a delegate is really just a struct.  For example, this:
	int delegate(char a,Object b) foo;
could be viewed as this struct:
	struct myDelegate {
		void *arg;
		int function(void*,char,Object) fptr;
	};
	myDelegate foo;

When you call the delegate
	foo('a',null);
the compiler is basically doing this:
	foo.fptr(foo.arg, 'a',null);



So a delegate is really just a function pointer with a single void* argment embedded into it.  What if we decided to view this as a static-sized array instead?
	struct myDelegate {
		void*[1] arg;
		int function(void*,char,Object) fptr;
	};

This implies that you might have arrays of other sizes:
	struct myDelegate_2args {
		void*[2] args;
		int function(void*,void*,char,Object) fptr;
	};

In fact, a "normal" function pointer is just the trivial case, where the size of the array is 0:
	struct myDelegate_0args {
		void*[0] args;
		int function(char,Object) fptr;
	};

Finally, this conception suggests that we might be able to declare delegates with a dynamic number of arguments:
	struct myDelegate_dynArgs {
		void*[] args;
		int function(..., char,Object) fptr;
	};

In this last case, what the compiler would turn this call:
	myDelegate_dynArgs foo;
	foo('a',null);
into something like this pseudocode:
	foreach(void *arg; foo.args)
		push(arg);
	push('a');
	push(null);
	call(foo.fptr);



So I propose the following syntaxes:
	<retType> function[<val>](<args...>)
	<retType> function[](<args...>)

'function[<val>]' would be a function with <val> stored arguments.
'function' would be syntax sugar for 'function[0]'.
'delegate' would be syntax sugar for 'function[1]'.
'function[]' declares a function pointer which has a dynamic number of stored arguments.

You can implicitly cast any function[x] to function[] if the args and return values are the same.

PROBLEMS:
- What if one of the arguments you want to store is less than the size of a void pointer, like a char?  Maybe the [] size should be in bytes rather than void pointers?
- You should be able to turn a function[x] into a function[x+n] by supplying some additional stored arguments.  I don't have a good, readable syntax for this yet.  Any ideas?

"Russ Lewis" <spamhole-2001-07-16@deming-os.org> wrote in message
news:c1oiko$hs4$1@digitaldaemon.com...
| I am making heavy use of delegates in a D program I am currently
| writing.  They are awesome!
|
| However, more than once I have found myself wishing that they could
| store more than just one argument.  Why can't you have delegates of any
| size?  Better yet (for the needs of my program) why can't you have
| delegates which have a VARIABLE number of implicit arguments?

Below is some template magic to do roughly the same thing. The
calls in the user code could most likely be cleaned up but it
works just fine. Another drawback compared to your proposal is
that it allocates another wrapper object per implicit argument
so it isn't as efficient as it could be. Also it needs to support
delegates with return values. There seems to be a bug in dmd with
opApply and template classes (the error message is that wrapper(8)
expects a function and not WrapDG).
Anyway, it's fun to play around with:


// no explicit arg
class WrapDG(DG,S)
{
   S data;
   DG dg;
   this(DG dg, S data)
   {
      this.data = data;
      this.dg = dg;
   }
   void opApply()
   {
      dg(data);
   }
}
// one explicit arg
class WrapDG(DG,S,A)
{
   S data;
   DG dg;
   this(DG dg, S data)
   {
      this.data = data;
      this.dg = dg;
   }
   void opApply(A x)
   {
      dg(data,x);
   }
}


class Foo {
   int x;
   void the_callback(int p,int q)
   {
      printf("field x = %d\n",x);
      printf("param p = %d\n",p);
      printf("param q = %d\n\n",q);
   }
}

int main()
{
   Foo t = new Foo();
   t.x = 2;

   // wrap dg_t to get dg2_t
   alias void delegate(int,int) dg_t;
   alias void delegate(int) dg2_t;

   // make wrapper delegate resulting in dg
   alias WrapDG!(dg_t,int,int) wrapper_t;
   wrapper_t wrapper = new wrapper_t(&t.the_callback,4);
   dg2_t dg = &wrapper.opApply; // template opApply needs help

   // try applying it
   printf("calling delegate dg with arg 8\n");
   dg(8);

   // another example: wrap the wrapper to add more implicit args
   WrapDG!(dg2_t,int) wrapper2 = new WrapDG!(dg2_t,int)(dg,16);
   void delegate() dg2 = &wrapper2.opApply;

   // try applying it
   printf("calling delegate dg2 with no args\n");
   dg2();

   return 0;
}

Delegates and function pointers should be united in one way to point to functions.  The problem right now is that delegates can't call static methodes in a class.  Also delegates can't point to more than one method and you have to use arrays.

int (*pt2Function)        (float, char, char);           // C
int (TMyClass::*pt2Member)(float, char, char);           // C++


----------------------------------------------------------------------------
import std.c.stdio;

class Foobar
{
	void printHello()
	{
		puts("Foobar.printHello(): Hello  !");
	}
}

class Foobar2
{
	void printHello()
	{
		puts("Foobar2.printHello(): Hello  !");
	}
}


void main ( char [] [] args )
{
	void delegate()[2] d;
	
	Foobar f = new Foobar();
	Foobar2 f2 = new Foobar2();
	
	d[0] = &f.printHello;
	d[1] = &f2.printHello;
	
	for (int i = 0; i < d.length; i++)
	{
		d[i]();
	}
	
	foreach (void delegate() x; d)
	{
		x();
	}
}


On Sat, 28 Feb 2004 09:50:46 -0500, Ben Hinkle <bhinkle4@juno.com> wrote:

>
> "Russ Lewis" <spamhole-2001-07-16@deming-os.org> wrote in message
> news:c1oiko$hs4$1@digitaldaemon.com...
> | I am making heavy use of delegates in a D program I am currently
> | writing.  They are awesome!
> |
> | However, more than once I have found myself wishing that they could
> | store more than just one argument.  Why can't you have delegates of any
> | size?  Better yet (for the needs of my program) why can't you have
> | delegates which have a VARIABLE number of implicit arguments?
>
> Below is some template magic to do roughly the same thing. The
> calls in the user code could most likely be cleaned up but it
> works just fine. Another drawback compared to your proposal is
> that it allocates another wrapper object per implicit argument
> so it isn't as efficient as it could be. Also it needs to support
> delegates with return values. There seems to be a bug in dmd with
> opApply and template classes (the error message is that wrapper(8)
> expects a function and not WrapDG).
> Anyway, it's fun to play around with:
>
>
> // no explicit arg
> class WrapDG(DG,S)
> {
>    S data;
>    DG dg;
>    this(DG dg, S data)
>    {
>       this.data = data;
>       this.dg = dg;
>    }
>    void opApply()
>    {
>       dg(data);
>    }
> }
> // one explicit arg
> class WrapDG(DG,S,A)
> {
>    S data;
>    DG dg;
>    this(DG dg, S data)
>    {
>       this.data = data;
>       this.dg = dg;
>    }
>    void opApply(A x)
>    {
>       dg(data,x);
>    }
> }
>
>
> class Foo {
>    int x;
>    void the_callback(int p,int q)
>    {
>       printf("field x = %d\n",x);
>       printf("param p = %d\n",p);
>       printf("param q = %d\n\n",q);
>    }
> }
>
> int main()
> {
>    Foo t = new Foo();
>    t.x = 2;
>
>    // wrap dg_t to get dg2_t
>    alias void delegate(int,int) dg_t;
>    alias void delegate(int) dg2_t;
>
>    // make wrapper delegate resulting in dg
>    alias WrapDG!(dg_t,int,int) wrapper_t;
>    wrapper_t wrapper = new wrapper_t(&t.the_callback,4);
>    dg2_t dg = &wrapper.opApply; // template opApply needs help
>
>    // try applying it
>    printf("calling delegate dg with arg 8\n");
>    dg(8);
>
>    // another example: wrap the wrapper to add more implicit args
>    WrapDG!(dg2_t,int) wrapper2 = new WrapDG!(dg2_t,int)(dg,16);
>    void delegate() dg2 = &wrapper2.opApply;
>
>    // try applying it
>    printf("calling delegate dg2 with no args\n");
>    dg2();
>
>    return 0;
> }
>
>
>



-- 
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/