August 24, 2020 Re: shared and getParameterStorageClasses bug? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Andrei Alexandrescu | On 23.08.20 21:15, Andrei Alexandrescu wrote:
> On 8/23/20 10:21 AM, Paul Backus wrote:
>> On Sunday, 23 August 2020 at 14:11:21 UTC, Jean-Louis Leroy wrote:
>>>
>>> OK since the `shared` has migrated to the type, isSharedParameter can be written like this:
>>>
>>> enum isSharedParameter(alias fun, uint param) =
>>> is(Parameters!fun[param] == SharedOf!(Parameters!fun[param]));
>>
>> An even simpler way is to use the pattern-matching feature of `is(...)`:
>>
>> enum isSharedParameter(alias fun, size_t param) =
>> is(Parameters!fun[param] == shared(T), T);
>>
>> You can read this as, "there exists some T such that Parameters!fun[param] is shared(T)".
>
> This would have problems if shared is combined with other qualifiers (const and my nemesis inout).
(Which is a compiler bug.)
|
August 25, 2020 Re: shared and getParameterStorageClasses bug? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jean-Louis Leroy | On Monday, 24 August 2020 at 21:01:30 UTC, Jean-Louis Leroy wrote:
> On Sunday, 23 August 2020 at 21:14:38 UTC, Petar Kirov [ZombineDev] wrote:
>> Hmm, why do you need to extract them in the same fashion? For use in string mixins?
>
> Yeah, it is related to my attempt to support all the language in my openmethods library.
>
>> If you just want to create a proxy function then simply using std.traits.Parameters should do the trick.
>
> That's a whole can of worms ;-) I am trying to handle that as well as possible in a part of openmethods that I spun off and donated to bolts (see here https://github.com/aliak00/bolts/blob/master/source/bolts/experimental/refraction.d).
Interesting, so essentially, you need a good solution for your refractParameter function, right? I'll try to check the code in more detail later and think about it.
|
August 25, 2020 Re: shared and getParameterStorageClasses bug? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Petar Kirov [ZombineDev] | On Tuesday, 25 August 2020 at 07:16:39 UTC, Petar Kirov [ZombineDev] wrote: > Interesting, so essentially, you need a good solution for your refractParameter function, right? I'll try to check the code in more detail later and think about it. Actually it already works as is: void original(lazy const Object); enum edited = refract!(original, "original") .withName("copy") .withParametersAt(0, Parameter("foo", "int")); mixin(edited.mixture); void expected(int, lazy const Object); static assert(is(typeof(©) == typeof(&expected))); The generated mixin is: pragma(msg, edited.mixture); // @system bolts.experimental.refraction.ReturnType!(original) // copy(int foo, lazy bolts.experimental.refraction.Parameters!(original)[0] _0); (In this case, Parameters!(original)[0..1] (note the ..) would have worked as well - and it would have looker better too. I'll implement that soon.) Let's look at the function types: pragma(msg, typeof(&original).stringof); // void function(lazy const(Object)) pragma(msg, typeof(©).stringof); // void function(int foo, lazy const(Object) _0) @system It looks like it is impossible to tell the difference between 'const object' and 'const(Object)' - the substitution happens too early. So I guess it doesn't matter... |
August 25, 2020 Re: shared and getParameterStorageClasses bug? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jean-Louis Leroy | On Tuesday, 25 August 2020 at 12:52:14 UTC, Jean-Louis Leroy wrote: > On Tuesday, 25 August 2020 at 07:16:39 UTC, Petar Kirov [ZombineDev] wrote: >> Interesting, so essentially, you need a good solution for your refractParameter function, right? I'll try to check the code in more detail later and think about it. > > Actually it already works as is: > > void original(lazy const Object); > > enum edited = > refract!(original, "original") > .withName("copy") > .withParametersAt(0, Parameter("foo", "int")); > mixin(edited.mixture); > > void expected(int, lazy const Object); > static assert(is(typeof(©) == typeof(&expected))); > > The generated mixin is: > > pragma(msg, edited.mixture); > // @system bolts.experimental.refraction.ReturnType!(original) > // copy(int foo, lazy bolts.experimental.refraction.Parameters!(original)[0] _0); > > (In this case, Parameters!(original)[0..1] (note the ..) would have worked as well - and it would have looker better too. I'll implement that soon.) > > Let's look at the function types: > > pragma(msg, typeof(&original).stringof); // void function(lazy const(Object)) > pragma(msg, typeof(©).stringof); // void function(int foo, lazy const(Object) _0) @system Nice! > It looks like it is impossible to tell the difference between 'const object' and 'const(Object)' - the substitution happens too early. So I guess it doesn't matter... Yes, `Q T` and `Q(T)` is exactly the same type (for Q ∈ { const, immutable, shared, inout } ), so you shouldn't try to differentiate between the two. (And `Q(T)` is the canonical notation.) BTW, 2-3 years ago I played with a similar task (meta programming utility library), and one difference in the approach I took was to avoid thick abstractions. In some cases, this works well, though since I didn't have use cases involving heavy function type processing recently I didn't push much in that direction. You can find some of the code here: https://gist.github.com/PetarKirov/a808c94857de84858accfb094c19bf77#file-rxd-meta2-d-L65-L123 |
Copyright © 1999-2021 by the D Language Foundation