Prettier iterator implementations in D?

[Unknown W. Brackets]

Shorter and more beautiful is good, and has merits indeed...

But sometimes clarity comes as a price, and that's not so good.  If I 
were new to D, this:

void opApply( (inout uint) block)

Would look like a funky sort of cast.  That said, this:

void opApply( ) |inout uint|

Is at least clear, if not horrendously ugly to my eyes.

-[Unknown]


> Forgetting about 'foreach' for the moment, I'd like to talk about the 
> other end of things: opApply().
> 
> This code in D:
>     int opApply(int delegate(inout uint) dg)
>     {   int result = 0;
> 
>     for (int i = 0; i < array.length; i++)
>     {
>         result = dg(array[i]);
>         if (result)
>         break;
>     }
>     return result;
>     }
> 
> seems to be rendered in Ruby-ish D as something like:
> 
>     void opApply( ) |inout uint|
>     {
>     for (int i = 0; i < array.length; i++)
>     {
>         yield array[i];
>     }
>     }
> 
> Is there some way to make the real D one look as clean as the Rubified one?
> 
> Main differences:
> 1) need to explicitly declare a delegate,
> 2) need to fiddle with return values.
> 
> For 1) I'm thinking if there were only some more compact way to declare 
> a delegate it would be golden.
> 
> How about this: with function literals, if you leave out the keyword 
> 'delegate' or 'function' you get a delegate.  I.e.
> 
>      int delegate(long c) { return 6 + b; }
> 
> is equivalent to
> 
>      int (long c) { return 6 + b; }
> 
> So it seems logical that as a variable declaration:
> 
>      int delegate(long c) dg;
> 
> could also be made to be equivalent to
> 
>      int (long c) dg;
> 
> In that case we could say in D:
> 
>     void opApply(void (inout uint) dg)
>     {
>     for (int i = 0; i < array.length; i++)
>     {
>         dg(array[i]);
>     }
>     }
> 
> (assuming that pesky 'int return' business can also be sorted out).
> 
> The void can also be omitted frequently in D.  So for a void-returning 
> delegate that could even be shortened to:
> 
>     void opApply( (inout uint) block)
>     {
>     for (int i = 0; i < array.length; i++)
>     {
>         block(array[i]);
>     }
>     }
> 
> Now *that* is something I wouldn't mind staring at at 3am after a long 
> day coding. :-)
> 
> --bb