auto & class members
Steven Schveighoffer
schveiguy at yahoo.com
Tue May 22 13:55:03 UTC 2018
On 5/22/18 4:40 AM, Robert M. Münch wrote:
> On 2018-05-21 18:55:36 +0000, Steven Schveighoffer said:
>
>> When you use the alias, both are using the same exact lambda.
>
> Ok. I didn't expect that the name is relevant in this case, instead
> assumed that only the types need to match.
The type is the problem. The type returned by filter is parameterized on
that *specific* lambda. If you look at the error message, it says
something like "lamda1" and "lambda4" in the type for filter.
In order to make this work, the compiler would have to make the name of
the lambda based on the actual AST inside it. I think something like
that should be done.
>
>> I see you are casting now as well,
>
> Do I? Not that I'm aware of it in my pseudo-code example...
Haha, looking back, I see you didn't cast originally, which is probably
the reason it didn't work :)
Here is the line from your revised example after Jonathan showed you how
to declare a member of that type:
myB.mySubstream = myA.myStream.filter!(x => x == myMessage);
And here is the subsequent line:
myB.mySubstream = cast(myMessageType)myA.myStream.filter!(x => x ==
myMessage);
Both exactly the same, but one forces the cast. Your first line could
have been done:
myB.mySubstream =
cast(typeof(myB.mySubstream))myA.myStream.filter!(x => x == myMessage);
Giving a name helps to make the code less verbose, but essentially that
is what you are doing -- forcing the cast.
>> What may make more sense (both for type sanity and for code reuse) is
>> to wrap your call to filter into one place so it can be used wherever
>> you need it:
>>
>> auto wrapStream(S)(S str) { return str.filter!(x => x == myMessage); }
>>
>> class b
>> {
>> typeof(wrapStream(a.init.myStream)()) mySubStream;
>> }
>>
>> void myFunc() {
>> a myA = new a;
>> b myB = new b;
>> myB.mySubstream = myA.myStream.wrapStream;
>> }
>
> This would require one wrap function per different lambda, right? Assume
> I have 50-100 of these. Maybe the myMessage value can be given as
> parameter and with this becomes more like a "filter factory". Not sure
> if this would work
Well, you then have to have 50-100 types of b with the correct member.
Unless... you want to parameterize b, in which case it becomes REALLY easy:
class b(FilterType)
{
FilterType mySubstream;
}
auto makeB(FilterType)(FilterType f)
{
return new b!FilterType(f);
}
...
auto myB = myA.myStream.filter!(x => coolCrazyFunction(x)).makeB;
-Steve
More information about the Digitalmars-d-learn
mailing list