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.)

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.

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(&copy) == 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(&copy).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...

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(&copy) == 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(&copy).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