Thread overview | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
|
April 20, 2012 Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Attachments:
| So I've been running into cases repeatedly all week where I really need one or the other, or in some cases, both of these so solve some meta problems, relating to rich bindings to a C++ code base. I'm currently rolling with quite a few workarounds for various things, but I've finally reached an impass. Here's my problem, and maybe people can suggest some nice workaround to this one... I have a class, and it contains various method declarations. These methods are to be implemented via mixins which generate stubs binding it to some complex C++ call-through mechanism. My approach was to allow the user to forward declare the methods, which will tell the compiler all the information about the function call, and then later on, a mixin would scan the class for such methods, and produce the actual function stubs accordingly. This doesn't work, because the compiler gives me a message that it is an ambiguous call, even though it is actually the exact same function declared twice (once as a forward declaration). So apparently forward declarations aren't supported, even though they appeared to be... then I found this: "The program is looked at as a whole, and so not only is it not necessary to code forward declarations, it is not even allowed! " Well, in this case, a forward declaration is necessary, since it effectively provides the compiler with the signature that it can use to generate the function, in a way that looks exactly like a function definition to anyone who is reading the code. Having failed that, I have a workaround where I name the function with a silly prefix, and make it private... but this makes no sense to someone reading the source for the binding class (they see a weird list of private mangled functions). So I'm not entirely happy with the solution, but it does technically work for the moment. There is a secondary problem with my workaround though... I can't figure any way to *alias* a function argument, I can only get a typetuple of the arguments. Since I don't have _alias_es of the function args, I have no way to access their 'identifier'(/name), and that leads to a problem where I'm generating the public stub function, and I have nothing to name the args other than a0, a1, a2, etc... That is complete rubbish, and unusable to an end user by my measure; intellisense is useless if the pop-up argument list says a0,a1,a2. >_< There's a third crudeness to my problem, and that is, to generate the bindings, I need to put a mixin in every class. I already have a 'RegisterModule' mixin at the end of the file, which binds all the 'loose'/static methods. What would be really handy in this case, is to be able to use partial classes as in C# and C++0x to add the extra bits to the previously defined classes all within the one RegisterModule at the end. I think partial classes will become considerably more useful too when we have attributes, and some may classes need to have some extra data members added to support their given attributes. So let's ignore partial classes for the moment, I'm happy enough with the meta spam for the time being. What kinds of tricks can I use to generate the stub functions I want, while preserving the argument names, and sensible declaration/readibility of the module. How else could the functions be declared, short of a string literal, is there any way I can pull out the names of args currently? I think there's definitely room for a trait to refer to the _instance_ of a function arg in the same way as 'getMember', thus allowing it to be enumerated+supplied to templates as alias parameters. |
April 20, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Manu | On 2012-04-20 14:07, Manu wrote: > There is a secondary problem with my workaround though... I can't figure > any way to *alias* a function argument, I can only get a typetuple of > the arguments. Since I don't have _alias_es of the function args, I have > no way to access their 'identifier'(/name), and that leads to a problem > where I'm generating the public stub function, and I have nothing to > name the args other than a0, a1, a2, etc... > That is complete rubbish, and unusable to an end user by my measure; > intellisense is useless if the pop-up argument list says a0,a1,a2. >_< Don't know if it helps but you can get the name of the arguments of a function: https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L29 I don't think that function handles delegate/function parameters. -- /Jacob Carlborg |
April 20, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg Attachments:
| On 20 April 2012 17:19, Jacob Carlborg <doob@me.com> wrote:
> On 2012-04-20 14:07, Manu wrote:
>
> There is a secondary problem with my workaround though... I can't figure
>> any way to *alias* a function argument, I can only get a typetuple of
>> the arguments. Since I don't have _alias_es of the function args, I have
>> no way to access their 'identifier'(/name), and that leads to a problem
>> where I'm generating the public stub function, and I have nothing to
>> name the args other than a0, a1, a2, etc...
>> That is complete rubbish, and unusable to an end user by my measure;
>> intellisense is useless if the pop-up argument list says a0,a1,a2. >_<
>>
>
> Don't know if it helps but you can get the name of the arguments of a function:
>
> https://github.com/jacob-**carlborg/orange/blob/master/** orange/util/Reflection.d#L29<https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L29>
Amazing, that needs to go in std.traits pronto! :P
This should help with my hack in the mean time.
I don't think that function handles delegate/function parameters.
Bummer. I still think there's room for a formal trait to do this. Complimentary to allMembers and getMember, but for a functions.
|
April 20, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg | On Friday, 20 April 2012 at 14:19:25 UTC, Jacob Carlborg wrote:
> Don't know if it helps but you can get the name of the arguments of a function:
>
> https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L29
>
> I don't think that function handles delegate/function parameters.
This function is too naive, it's incredibly easy to break.
void foo(immutable(int) a);
|
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Manu | On 2012-04-20 16:47, Manu wrote: > Bummer. I still think there's room for a formal trait to do this. > Complimentary to allMembers and getMember, but for a functions. The function currently just splits the string on ",". It would be possible to add a more sophisticated algorithm to handle delegate and function pointer parameters. -- /Jacob Carlborg |
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jakob Ovrum | On 2012-04-20 18:21, Jakob Ovrum wrote: > On Friday, 20 April 2012 at 14:19:25 UTC, Jacob Carlborg wrote: >> Don't know if it helps but you can get the name of the arguments of a >> function: >> >> https://github.com/jacob-carlborg/orange/blob/master/orange/util/Reflection.d#L29 >> >> >> I don't think that function handles delegate/function parameters. > > This function is too naive, it's incredibly easy to break. > > void foo(immutable(int) a); Yeah, I know. This function more or less shows it's possible. -- /Jacob Carlborg |
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Jacob Carlborg | On 21-04-2012 16:32, Jacob Carlborg wrote: > On 2012-04-20 16:47, Manu wrote: > >> Bummer. I still think there's room for a formal trait to do this. >> Complimentary to allMembers and getMember, but for a functions. > > The function currently just splits the string on ",". It would be > possible to add a more sophisticated algorithm to handle delegate and > function pointer parameters. > It would basically mean having to parse D's full type syntax to be 100% correct, which is not cool. The compiler ought to help out here. -- - Alex |
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Alex Rønne Petersen | On 2012-04-21 17:45, Alex Rønne Petersen wrote: > It would basically mean having to parse D's full type syntax to be 100% > correct, which is not cool. The compiler ought to help out here. > Yet again we need a compiler library. -- /Jacob Carlborg |
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Manu | > I have a class, and it contains various method declarations. These methods > are to be implemented via mixins which generate stubs binding it to some > complex C++ call-through mechanism. > My approach was to allow the user to forward declare the methods, which > will tell the compiler all the information about the function call, and > then later on, a mixin would scan the class for such methods, and produce > the actual function stubs accordingly. Not sure if I understood you problem correctly, but these are the two idioms I use regularly. //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: module lib; mixin template genFuncAlias(string fname, RT, Args...) { RT __genFunc(Args args) { //... return RT.init; } mixin("alias __genFunc "~fname~";"); } mixin template genFuncName(string fname, RT, Args...) { enum __s = codegen(fname); mixin(__s); } string codegen(string fname) { import std.array, std.format; auto app = appender!string(); formattedWrite(app, q{ RT %1$s(Args args) { //... return RT.init; } }, fname); return app.data; } //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: module client; import lib; class Blah { // not overloadable ?? mixin genFuncAlias!("bar", int, string, double); // mixin genFuncAlias!("bar", int, double, string); mixin genFuncName!("foo", int, string, double); mixin genFuncName!("foo", int, double, string); } void main() { auto b = new Blah(); b.bar("1.0", 1.0) && assert(0); // not overloadable ?? // b.bar(2.0, "2.0") && assert(0); b.foo("1.0", 1.0) && assert(0); b.foo(2.0, "2.0") && assert(0); } //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: dmd -run client lib |
April 21, 2012 Re: Partial classes & forward declarations | ||||
---|---|---|---|---|
| ||||
Posted in reply to Alex Rønne Petersen Attachments:
| On 21 April 2012 18:45, Alex Rønne Petersen <xtzgzorex@gmail.com> wrote:
> On 21-04-2012 16:32, Jacob Carlborg wrote:
>
>> On 2012-04-20 16:47, Manu wrote:
>>
>> Bummer. I still think there's room for a formal trait to do this.
>>> Complimentary to allMembers and getMember, but for a functions.
>>>
>>
>> The function currently just splits the string on ",". It would be possible to add a more sophisticated algorithm to handle delegate and function pointer parameters.
>>
>>
> It would basically mean having to parse D's full type syntax to be 100% correct, which is not cool. The compiler ought to help out here.
Some traits would be nice; allArguments, getArgument.
This would allow enumeration of argument lists in the exact same way as
struct members.
D has gone hard out with its compile time meta capabilites, but there's just a couple of small things missing from the complete introspection set.
|
Copyright © 1999-2021 by the D Language Foundation