View mode: basic / threaded / horizontal-split · Log in · Help
March 03, 2012
Delegator
hi,
In ruby we can delegate some method. by example:
---- Ruby ----
class MineArray
 include Forwardable
 def_delegators: @array, :[], :[]=, :each_with_index, :length

 def initialize( array )
   @array = array
 end
end
-------------

this code delegate opIndexAssign opIndex, length ... attribute to his
member.

This save time, bug and line. You do not to have to write a code as:
void opIndexAssign( size_t index, T item){
	array[index] = item;
}

thanks
March 03, 2012
Re: Delegator
Le samedi 03 mars 2012 à 17:42 +0100, bioinfornatics a écrit :
> hi,
> In ruby we can delegate some method. by example:
> ---- Ruby ----
> class MineArray
>   include Forwardable
>   def_delegators: @array, :[], :[]=, :each_with_index, :length
> 
>   def initialize( array )
>     @array = array
>   end
> end
> -------------
> 
> this code delegate opIndexAssign opIndex, length ... attribute to his
> member.
> 
> This save time, bug and line. You do not to have to write a code as:
> void opIndexAssign( size_t index, T item){
> 	array[index] = item;
> }
> 
> thanks
> 
I miss the question ^^

can w do same in D ?

thanks
March 03, 2012
Re: Delegator
On 2012-03-03 17:50, bioinfornatics wrote:
> Le samedi 03 mars 2012 à 17:42 +0100, bioinfornatics a écrit :
>> hi,
>> In ruby we can delegate some method. by example:
>> ---- Ruby ----
>> class MineArray
>>    include Forwardable
>>    def_delegators: @array, :[], :[]=, :each_with_index, :length
>>
>>    def initialize( array )
>>      @array = array
>>    end
>> end
>> -------------
>>
>> this code delegate opIndexAssign opIndex, length ... attribute to his
>> member.
>>
>> This save time, bug and line. You do not to have to write a code as:
>> void opIndexAssign( size_t index, T item){
>> 	array[index] = item;
>> }
>>
>> thanks
>>
> I miss the question ^^
>
> can w do same in D ?
>
> thanks

I would say "yes", but not with the same pretty syntax. Something like this:

class MineArray
{
    mixin delegates!(array, "opIndexAssign", "opIndex");
}

Just implement "delegates" to generate the given functions and forward 
them to "array".

-- 
/Jacob Carlborg
March 03, 2012
Re: Delegator
Le samedi 03 mars 2012 à 19:18 +0100, Jacob Carlborg a écrit :
> On 2012-03-03 17:50, bioinfornatics wrote:
> > Le samedi 03 mars 2012 à 17:42 +0100, bioinfornatics a écrit :
> >> hi,
> >> In ruby we can delegate some method. by example:
> >> ---- Ruby ----
> >> class MineArray
> >>    include Forwardable
> >>    def_delegators: @array, :[], :[]=, :each_with_index, :length
> >>
> >>    def initialize( array )
> >>      @array = array
> >>    end
> >> end
> >> -------------
> >>
> >> this code delegate opIndexAssign opIndex, length ... attribute to his
> >> member.
> >>
> >> This save time, bug and line. You do not to have to write a code as:
> >> void opIndexAssign( size_t index, T item){
> >> 	array[index] = item;
> >> }
> >>
> >> thanks
> >>
> > I miss the question ^^
> >
> > can w do same in D ?
> >
> > thanks
> 
> I would say "yes", but not with the same pretty syntax. Something like this:
> 
> class MineArray
> {
>      mixin delegates!(array, "opIndexAssign", "opIndex");
> }
> 
> Just implement "delegates" to generate the given functions and forward 
> them to "array".
> 

they are a way to create a decorator as @delgator for able to this
pretty ?
March 03, 2012
Re: Delegator
On Saturday, 3 March 2012 at 16:50:45 UTC, bioinfornatics wrote:
> can w do same in D ?

alias this does that, although it does for all unknown
methods, not specific ones:

struct A {
   int[] data;
   alias data this;
}

A a;

a[0] = 10; // this works like a.data[0] = 10;


alias this also lets you pass the struct
when the member is expected:

void somethingWithArray(int[] arr) {}

A a;
somethingWithArray(a); // works, passes a.data automatically
March 03, 2012
Re: Delegator
Le samedi 03 mars 2012 à 19:45 +0100, Adam D. Ruppe a écrit :
> On Saturday, 3 March 2012 at 16:50:45 UTC, bioinfornatics wrote:
> > can w do same in D ?
> 
> alias this does that, although it does for all unknown
> methods, not specific ones:
> 
> struct A {
>     int[] data;
>     alias data this;
> }
> 
> A a;
> 
> a[0] = 10; // this works like a.data[0] = 10;
> 
> 
> alias this also lets you pass the struct
> when the member is expected:
> 
> void somethingWithArray(int[] arr) {}
> 
> A a;
> somethingWithArray(a); // works, passes a.data automatically

But when you have already a ctor ( class ) can you alias this ?
March 03, 2012
Re: Delegator
Le samedi 03 mars 2012 à 19:18 +0100, Jacob Carlborg a écrit :
> On 2012-03-03 17:50, bioinfornatics wrote:
> > Le samedi 03 mars 2012 à 17:42 +0100, bioinfornatics a écrit :
> >> hi,
> >> In ruby we can delegate some method. by example:
> >> ---- Ruby ----
> >> class MineArray
> >>    include Forwardable
> >>    def_delegators: @array, :[], :[]=, :each_with_index, :length
> >>
> >>    def initialize( array )
> >>      @array = array
> >>    end
> >> end
> >> -------------
> >>
> >> this code delegate opIndexAssign opIndex, length ... attribute to his
> >> member.
> >>
> >> This save time, bug and line. You do not to have to write a code as:
> >> void opIndexAssign( size_t index, T item){
> >> 	array[index] = item;
> >> }
> >>
> >> thanks
> >>
> > I miss the question ^^
> >
> > can w do same in D ?
> >
> > thanks
> 
> I would say "yes", but not with the same pretty syntax. Something like this:
> 
> class MineArray
> {
>      mixin delegates!(array, "opIndexAssign", "opIndex");
> }
> 
> Just implement "delegates" to generate the given functions and forward 
> them to "array".
> 


I found this way verys interestiong. Could you put plsease a shorter
implementation of delegates?
March 03, 2012
Re: Delegator
Le samedi 03 mars 2012 à 19:18 +0100, Jacob Carlborg a écrit :
> On 2012-03-03 17:50, bioinfornatics wrote:
> > Le samedi 03 mars 2012 à 17:42 +0100, bioinfornatics a écrit :
> >> hi,
> >> In ruby we can delegate some method. by example:
> >> ---- Ruby ----
> >> class MineArray
> >>    include Forwardable
> >>    def_delegators: @array, :[], :[]=, :each_with_index, :length
> >>
> >>    def initialize( array )
> >>      @array = array
> >>    end
> >> end
> >> -------------
> >>
> >> this code delegate opIndexAssign opIndex, length ... attribute to his
> >> member.
> >>
> >> This save time, bug and line. You do not to have to write a code as:
> >> void opIndexAssign( size_t index, T item){
> >> 	array[index] = item;
> >> }
> >>
> >> thanks
> >>
> > I miss the question ^^
> >
> > can w do same in D ?
> >
> > thanks
> 
> I would say "yes", but not with the same pretty syntax. Something like this:
> 
> class MineArray
> {
>      mixin delegates!(array, "opIndexAssign", "opIndex");
> }
> 
> Just implement "delegates" to generate the given functions and forward 
> them to "array".
> 


I have try to do a mixin template but i fail
------------------ D Code --------------------
import std.string;
import std.stdio;
import std.range;

mixin template arrayDelegator( alias instance, methods... ){
   string result;
  static if( methods.length > 0 ){
       static if( "opIndexAssign" ){
           result ~="
   void opIndexAssign( size_t index, " ~
ElementEncodingType!(typeof(instance)) ~ " item ){ 
       array[index] = item;
   }
                   ";
       }
       static else if( "opIndex" ){
           result ~="
   " ~ ElementEncodingType!(typeof(instance)) ~ " opIndex( size_t index
){
       return instance[index];
   }
                   ";
       }
       static else if( "length" ){
           result ~="
   @property size_t length(){
       return instance.length;
   }
                   ";
       }
       static else
           throw new Exception( "Unknown methods: "~ method );
       static if( methods.length > 2 )
           arrayDelegator!( instance, methods[1 .. $ ] );
   } 
   mixin(result);
}

class Container{
   size_t[] array;

   mixin arrayDelegator!(array, "opIndexAssign", "opIndex", "length");
   
   this( size_t[] a ){
       array = a:
   }

}

void main( string[] args ){
   Container c = new Container( [0u, 1u, 2u, 3u] );
   writeln( c[2] );
   c[2] = 4u;
   writeln( c[2] );
}
---------------------------------------------------------

$ ldc2 delegator.d
delegator.d(9): no identifier for declarator result
delegator.d(9): semicolon expected, not '~='
delegator.d(9): Declaration expected, not '~='
delegator.d(15): Declaration expected, not 'else'
delegator.d(22): Declaration expected, not 'else'
delegator.d(29): Declaration expected, not 'else'
delegator.d(32): no identifier for declarator
arrayDelegator!(instance,methods[1 .. __dollar])
delegator.d(33): unrecognized declaration
Top | Discussion index | About this forum | D home