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.

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

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.

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

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

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

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

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

> 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

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.