Hello,

some time ago, chris (ruunhb) posted something on his Dspec project, where he used a template syntax I didn't know:

----
void each(alias array, T : T[] = typeof(array))(void delegate(T item) dg) {
 foreach(T i; array)
   dg(i);
}

 int[] array = [1, 2, 3, 4];
 int b = 10;

 each!(array) = (int item) {
   writefln("%d", item + b);
 };
---

I'm intrigued by the last lines. I'd have thought 'each' to be invoked by:

each!(array)( (int item) {writefln("%d", item+b)} );

But this doesn't work. And I never encountered Chris' syntax before:

template!(someArgs) = moreArgs;

Could some be nice enough to enlighten me? How does that work?


Philippe

On 11/04/10 15:48, Philippe Sigaud wrote:
> Hello,
>
> some time ago, chris (ruunhb) posted something on his Dspec project, where he
> used a template syntax I didn't know:
>
> ----
> void each(alias array, T : T[] = typeof(array))(void delegate(T item) dg) {
>   foreach(T i; array)
>     dg(i);
> }
>
>   int[] array = [1, 2, 3, 4];
>   int b = 10;
>
>   each!(array) = (int item) {
>     writefln("%d", item + b);
>   };
> ---
>
> I'm intrigued by the last lines. I'd have thought 'each' to be invoked by:
>
> each!(array)( (int item) {writefln("%d", item+b)} );
>
> But this doesn't work. And I never encountered Chris' syntax before:
>
> template!(someArgs) = moreArgs;
>
> Could some be nice enough to enlighten me? How does that work?
>
>
> Philippe

When using your method, you have to use:
----
each!(array, typeof(array))((int item) {writefln("%d", item+b)});
----
(I believe this is a bug, dmd should be able to deduce the type here). As for the syntax, you can do this with any function in D:
----
void foo(int a) { writefln( "%d", a ); }
/// Prints 1
foo = 1;
----
I didn't realize this worked for free functions, apparently it does. I think in newer versions of D2 functions like this will have to be marked with @property, I don't think dmd currently enforces this though.

On Sun, Apr 11, 2010 at 17:01, Robert Clipsham <robert@octarineparrot.com>wrote:

> When using your method, you have to use:
> ----
> each!(array, typeof(array))((int item) {writefln("%d", item+b)});
> ----
> (I believe this is a bug, dmd should be able to deduce the type here).


OK.  I suppose I'd do:

void each(alias array)(void delegate(ElementType!(typeof(array)) item) dg)
if (isArray!(typeof(array))) {
 foreach(T i; array)
  dg(i);
}

and then:

each!([0,1,2,3])(
    (int i) { writeln(i);}
);




> As for the syntax, you can do this with any function in D:
> ----
> void foo(int a) { writefln( "%d", a ); }
> /// Prints 1
> foo = 1;
> ----
> I didn't realize this worked for free functions, apparently it does. I think in newer versions of D2 functions like this will have to be marked with @property, I don't think dmd currently enforces this though.
>

Urgh. OK, I didn't think of properties, thanks a lot Robert !
I think it explains some strange errors I have somewhere else, when trying
to assign some value and getting strange unvalid args errors. DMD transforms
my foo = something into foo(something).

On 11/04/10 16:01, Robert Clipsham wrote:
> When using your method, you have to use:
> ----
> each!(array, typeof(array))((int item) {writefln("%d", item+b)});
> ----
> (I believe this is a bug, dmd should be able to deduce the type here).
> As for the syntax, you can do this with any function in D:
> ----
> void foo(int a) { writefln( "%d", a ); }
> /// Prints 1
> foo = 1;
> ----
> I didn't realize this worked for free functions, apparently it does. I
> think in newer versions of D2 functions like this will have to be marked
> with @property, I don't think dmd currently enforces this though.

When I tried again, your method worked... odd, I must have done something wrong before.

Hello Philippe,

> Hello,
> 
> some time ago, chris (ruunhb) posted something on his Dspec project,
> where he used a template syntax I didn't know:
> 
> ----
> void each(alias array, T : T[] = typeof(array))(void delegate(T item)
> dg) {
> foreach(T i; array)
> dg(i);
> }
> int[] array = [1, 2, 3, 4];
> int b = 10;
> each!(array) = (int item) {
> writefln("%d", item + b);
> };
> ---
> I'm intrigued by the last lines. I'd have thought 'each' to be invoked
> by:
> 
> each!(array)( (int item) {writefln("%d", item+b)} );
> 

What that is, is the property syntax. I places where there is a function named foo that takes one arg, it can be called by "foo = arg;"

> But this doesn't work. And I never encountered Chris' syntax before:

I'm not sure why the normal syntax wouldn't work.

-- 
... <IXOYE><