Hi,

I would like store the delegate to another var but when i try i
get:


testTraitsWithDelegate.d(13): Error: expression template
__lambda2 is void and has no value

I do not want to run it only to save the «function» somewhere.


----------- CODE ------------
import std.stdio;
import std.typecons : Tuple;

struct attribute( alias Pred )
{
     alias Predicate = Pred;
}



struct Data
{
     @attribute!( (a) => a == 42 )
     int x;
}



void main()
{

     bool delegate( int ) tmp;

     pragma( msg, __traits(getAttributes, Data.x)[0].Predicate( 42
) );

     tmp = __traits(getAttributes, Data.x)[0].Predicate;
}
----------- END CODE ------------

On Monday, 2 June 2014 at 22:18:39 UTC, bioinfornatics wrote:
> Hi,
>
> I would like store the delegate to another var but when i try i
> get:
>
>
> testTraitsWithDelegate.d(13): Error: expression template
> __lambda2 is void and has no value
>
> I do not want to run it only to save the «function» somewhere.
>
>
> ----------- CODE ------------
> import std.stdio;
> import std.typecons : Tuple;
>
> struct attribute( alias Pred )
> {
>      alias Predicate = Pred;
> }
>
>
>
> struct Data
> {
>      @attribute!( (a) => a == 42 )
>      int x;
> }
>
>
>
> void main()
> {
>
>      bool delegate( int ) tmp;
>
>      pragma( msg, __traits(getAttributes, Data.x)[0].Predicate( 42
> ) );
>
>      tmp = __traits(getAttributes, Data.x)[0].Predicate;
> }
> ----------- END CODE ------------

The problem is that you're missing the type of a in "(a) => a == 42". Without the type, it's actually a template lambda, not a lambda function. Try changing it to "(int a) => a == 42".
auto

On Monday, 2 June 2014 at 23:27:03 UTC, Meta wrote:
> On Monday, 2 June 2014 at 22:18:39 UTC, bioinfornatics wrote:
>> Hi,
>>
>> I would like store the delegate to another var but when i try i
>> get:
>>
>>
>> testTraitsWithDelegate.d(13): Error: expression template
>> __lambda2 is void and has no value
>>
>> I do not want to run it only to save the «function» somewhere.
>>
>>
>> ----------- CODE ------------
>> import std.stdio;
>> import std.typecons : Tuple;
>>
>> struct attribute( alias Pred )
>> {
>>     alias Predicate = Pred;
>> }
>>
>>
>>
>> struct Data
>> {
>>     @attribute!( (a) => a == 42 )
>>     int x;
>> }
>>
>>
>>
>> void main()
>> {
>>
>>     bool delegate( int ) tmp;
>>
>>     pragma( msg, __traits(getAttributes, Data.x)[0].Predicate( 42
>> ) );
>>
>>     tmp = __traits(getAttributes, Data.x)[0].Predicate;
>> }
>> ----------- END CODE ------------
>
> The problem is that you're missing the type of a in "(a) => a == 42". Without the type, it's actually a template lambda, not a lambda function. Try changing it to "(int a) => a == 42".
> auto

with this i got an error even if i do public alias Predicate in
struct attribute:
Error: struct testTraitsWithDelegate.attribute!(function (int a)
=> a == 42).attribute member __lambda2 is not accessible

and i fail to do same with

struct attribute
{
   public:
     static bool delegate( int ) Predicate;
}

On Tuesday, 3 June 2014 at 12:27:45 UTC, bioinfornatics wrote:
> On Monday, 2 June 2014 at 23:27:03 UTC, Meta wrote:
>> On Monday, 2 June 2014 at 22:18:39 UTC, bioinfornatics wrote:
>>> Hi,
>>>
>>> I would like store the delegate to another var but when i try i
>>> get:
>>>
>>>
>>> testTraitsWithDelegate.d(13): Error: expression template
>>> __lambda2 is void and has no value
>>>
>>> I do not want to run it only to save the «function» somewhere.
>>>
>>>
>>> ----------- CODE ------------
>>> import std.stdio;
>>> import std.typecons : Tuple;
>>>
>>> struct attribute( alias Pred )
>>> {
>>>    alias Predicate = Pred;
>>> }
>>>
>>>
>>>
>>> struct Data
>>> {
>>>    @attribute!( (a) => a == 42 )
>>>    int x;
>>> }
>>>
>>>
>>>
>>> void main()
>>> {
>>>
>>>    bool delegate( int ) tmp;
>>>
>>>    pragma( msg, __traits(getAttributes, Data.x)[0].Predicate( 42
>>> ) );
>>>
>>>    tmp = __traits(getAttributes, Data.x)[0].Predicate;
>>> }
>>> ----------- END CODE ------------
>>
>> The problem is that you're missing the type of a in "(a) => a == 42". Without the type, it's actually a template lambda, not a lambda function. Try changing it to "(int a) => a == 42".
>> auto
>
> with this i got an error even if i do public alias Predicate in
> struct attribute:
> Error: struct testTraitsWithDelegate.attribute!(function (int a)
> => a == 42).attribute member __lambda2 is not accessible
>
> and i fail to do same with
>
> struct attribute
> {
>    public:
>      static bool delegate( int ) Predicate;
> }




To have same code

------------- code -----------
import std.stdio;
import std.typecons : Tuple;
//~ import std.functional : toDelegate;
//~ struct attribute( alias Pred )
//~ {
//~     public:
//~     alias Predicate = Pred;
//~ }

struct attribute
{
    public bool delegate( int ) predicate;
    public this(  bool delegate( int ) pred )
    {
        predicate = pred;
    }
}

struct Data
{
    @attribute( (int a) => a == 42 )
    int x;
}



void main()
{

    bool delegate( int ) tmp;

    pragma( msg, __traits(getAttributes, Data.x)[0] );
    pragma( msg, __traits(getAttributes, Data.x)[0].predicate( 42 ) );

    pragma( msg, __traits(getAttributes, Data.x)[0].predicate.stringof );
    tmp = __traits(getAttributes, Data.x)[0].predicate;
    writeln( tmp(42 ) );
    //~tmp = toDelegate(__traits(getAttributes, Data.x)[0].Predicate);
}
----------------------------------




give at compile time this:

attribute(function (int a) => a == 42)
true
(attribute __ctmp1474;
 , __ctmp1474).this(function (int a) => a == 42).predicate


And segfault at run-time

On 06/03/2014 05:57 AM, bioinfornatics wrote:

> On Tuesday, 3 June 2014 at 12:27:45 UTC, bioinfornatics wrote:

>>>> I would like store the delegate to another var but when i try i
>>>> get:
>>>>
>>>>
>>>> testTraitsWithDelegate.d(13): Error: expression template
>>>> __lambda2 is void and has no value
>>>>
>>>> I do not want to run it only to save the «function» somewhere.

> ------------- code -----------
> import std.stdio;
> import std.typecons : Tuple;
> //~ import std.functional : toDelegate;
> //~ struct attribute( alias Pred )
> //~ {
> //~     public:
> //~     alias Predicate = Pred;
> //~ }
>
> struct attribute
> {
>      public bool delegate( int ) predicate;
>      public this(  bool delegate( int ) pred )
>      {
>          predicate = pred;
>      }
> }
>
> struct Data
> {
>      @attribute( (int a) => a == 42 )
>      int x;
> }
>
>
>
> void main()
> {
>
>      bool delegate( int ) tmp;
>
>      pragma( msg, __traits(getAttributes, Data.x)[0] );
>      pragma( msg, __traits(getAttributes, Data.x)[0].predicate( 42 ) );
>
>      pragma( msg, __traits(getAttributes, Data.x)[0].predicate.stringof );
>      tmp = __traits(getAttributes, Data.x)[0].predicate;
>      writeln( tmp(42 ) );
>      //~tmp = toDelegate(__traits(getAttributes, Data.x)[0].Predicate);
> }
> ----------------------------------
>
>
>
>
> give at compile time this:
>
> attribute(function (int a) => a == 42)
> true
> (attribute __ctmp1474;
>   , __ctmp1474).this(function (int a) => a == 42).predicate
>
>
> And segfault at run-time

A delegate has a context pointer that it uses when executing at run-time. However, there can't be a run-time context of a delegate that is created at compile-time. I think that is why the segfault.

Is there a reason why it needs to be a delegate?

Replacing every 'delegate' with 'function' makes your code work.

Ali

On Tuesday, 3 June 2014 at 15:00:05 UTC, Ali Çehreli wrote:
> On 06/03/2014 05:57 AM, bioinfornatics wrote:
>
> > On Tuesday, 3 June 2014 at 12:27:45 UTC, bioinfornatics wrote:
>
> >>>> I would like store the delegate to another var but when i
> try i
> >>>> get:
> >>>>
> >>>>
> >>>> testTraitsWithDelegate.d(13): Error: expression template
> >>>> __lambda2 is void and has no value
> >>>>
> >>>> I do not want to run it only to save the «function»
> somewhere.
>
> > ------------- code -----------
> > import std.stdio;
> > import std.typecons : Tuple;
> > //~ import std.functional : toDelegate;
> > //~ struct attribute( alias Pred )
> > //~ {
> > //~     public:
> > //~     alias Predicate = Pred;
> > //~ }
> >
> > struct attribute
> > {
> >      public bool delegate( int ) predicate;
> >      public this(  bool delegate( int ) pred )
> >      {
> >          predicate = pred;
> >      }
> > }
> >
> > struct Data
> > {
> >      @attribute( (int a) => a == 42 )
> >      int x;
> > }
> >
> >
> >
> > void main()
> > {
> >
> >      bool delegate( int ) tmp;
> >
> >      pragma( msg, __traits(getAttributes, Data.x)[0] );
> >      pragma( msg, __traits(getAttributes,
> Data.x)[0].predicate( 42 ) );
> >
> >      pragma( msg, __traits(getAttributes,
> Data.x)[0].predicate.stringof );
> >      tmp = __traits(getAttributes, Data.x)[0].predicate;
> >      writeln( tmp(42 ) );
> >      //~tmp = toDelegate(__traits(getAttributes,
> Data.x)[0].Predicate);
> > }
> > ----------------------------------
> >
> >
> >
> >
> > give at compile time this:
> >
> > attribute(function (int a) => a == 42)
> > true
> > (attribute __ctmp1474;
> >   , __ctmp1474).this(function (int a) => a == 42).predicate
> >
> >
> > And segfault at run-time
>
> A delegate has a context pointer that it uses when executing at run-time. However, there can't be a run-time context of a delegate that is created at compile-time. I think that is why the segfault.
>
> Is there a reason why it needs to be a delegate?
>
> Replacing every 'delegate' with 'function' makes your code work.
>
> Ali


The only reason that is because i do nor know how to do:

 @attribute( (int a) => a == 42 )
 int x;

without using a delegate, with a function that will not work as  (int a) => a == 42 is a delegate no ?

struct attribute
{
    public bool function( int ) predicate;
    public this(  bool function( int ) pred )
    {
        predicate = pred;
    }
}

delegate has a context pointer that it uses when executing
>> at run-time. However, there can't be a run-time context of a delegate that is created at compile-time. I think that is why the segfault.
>>
>> Is there a reason why it needs to be a delegate?
>>
>> Replacing every 'delegate' with 'function' makes your code work.
>>
>> Ali
>

i got it with function, thx Ali

-------------- code ----------
import std.stdio;
import std.typecons : Tuple;

struct attribute
{
    public bool function( int ) predicate;
    public this(  bool function( int ) pred )
    {
        predicate = pred;
    }
}

struct Data
{
    @attribute( (int a) => a == 42 )
    int x;
    @attribute( (int a) => a == 8 )
    int y;
}



void main()
{

    bool function( int ) tmp;

    pragma( msg, __traits(getAttributes, Data.x)[0] );
    pragma( msg, __traits(getAttributes, Data.x)[0].predicate( 42 ) );
    tmp = __traits(getAttributes, Data.x)[0].predicate;
    writeln( tmp(42 ) );
}

On Tuesday, 3 June 2014 at 15:14:06 UTC, bioinfornatics wrote:
> without using a delegate, with a function that will not work as
>  (int a) => a == 42 is a delegate no ?

D will decide the type based on if context is needed. If you look at the output you had:

    , __ctmp1474).this(function (int a) => a == 42).predicate

Inside this, you'll see that your lambda was identified as a function. I'm guessing that having the function assigned to a delegate has confused the compiler which is why segfault.

I think such should be filed as a bug, likely should not have compiled.