Hi,

I have a CTFE function that I want to make more generic by given it a module as parameter.


My actual code looks like :

mixin(implementFunctionsOf());


string implementFunctionsOf()
{
    import std.traits;

    string	res;

    foreach(name; __traits(allMembers, myHardCodedModule))
    {
    }
    return res;
}


I tried many things but I can't figure out the type of the parameter I should use for the function implementFunctionsOf.

On Monday, 12 March 2018 at 21:00:07 UTC, Xavier Bigand wrote:
> Hi,
>
> I have a CTFE function that I want to make more generic by given it a module as parameter.
>
>
> My actual code looks like :
>
> mixin(implementFunctionsOf());
>
>
> string implementFunctionsOf()
> {
>     import std.traits;
>
>     string	res;
>
>     foreach(name; __traits(allMembers, myHardCodedModule))
>     {
>     }
>     return res;
> }
>
>
> I tried many things but I can't figure out the type of the parameter I should use for the function implementFunctionsOf.

you can use a alias or a string:

void fun(alias mod, string mod2)()
{
    foreach(m; __traits(allMembers, mod))
        pragma(msg, m);

    foreach(m; __traits(allMembers, mixin(mod2)))
        pragma(msg, m);
}

void main()
{
    import std.stdio;
    fun!(std.stdio, "std.stdio");
}

Le 12/03/2018 à 22:30, arturg a écrit :
> On Monday, 12 March 2018 at 21:00:07 UTC, Xavier Bigand wrote:
>> Hi,
>>
>> I have a CTFE function that I want to make more generic by given it a
>> module as parameter.
>>
>>
>> My actual code looks like :
>>
>> mixin(implementFunctionsOf());
>>
>>
>> string implementFunctionsOf()
>> {
>>     import std.traits;
>>
>>     string    res;
>>
>>     foreach(name; __traits(allMembers, myHardCodedModule))
>>     {
>>     }
>>     return res;
>> }
>>
>>
>> I tried many things but I can't figure out the type of the parameter I
>> should use for the function implementFunctionsOf.
>
> you can use a alias or a string:
>
> void fun(alias mod, string mod2)()
> {
>     foreach(m; __traits(allMembers, mod))
>         pragma(msg, m);
>
>     foreach(m; __traits(allMembers, mixin(mod2)))
>         pragma(msg, m);
> }
>
> void main()
> {
>     import std.stdio;
>     fun!(std.stdio, "std.stdio");
> }


I tried both without success,


Here is my full code :

module api_entry;

import std.stdio : writeln;
import std.algorithm.searching;

import derelict.opengl3.functions;

import std.traits;

string implementFunctionsOf(string mod)
{
    import std.traits;

    string	res;

    static foreach(name; __traits(allMembers, mixin(mod)))
    {
        static if (mixin("isCallable!" ~ name)
                   && name.startsWith("da_"))
        {
            string oglFunctionName = name[3..$];
            string returnType = ReturnType!(mixin(name)).stringof;
            string parametersType = Parameters!(mixin(name)).stringof;

            res ~=
                "export\n" ~
                "extern (C)\n" ~
                returnType ~ "\n" ~
                oglFunctionName ~
                parametersType ~ "\n" ~
                "{\n" ~
                "   writeln(\"" ~ oglFunctionName ~ "\");\n";

            static if (ReturnType!(mixin(name)).stringof != "void")
            {
                res ~=
                    "   " ~ returnType ~ " result;\n" ~
                    "   return result;";
            }
            res ~=
                "}\n";
        }
    }
    return res;
}

mixin(implementFunctionsOf("derelict.opengl3.functions"));


As string I get the following error:
..\src\api_entry.d(16): Error: variable `mod` cannot be read at compile time
..\src\api_entry.d(48):        called from here: `implementFunctionsOf("derelict.opengl3.functions")`




I also tried to make implementFunctionsOf a mixin template.

Le 12/03/2018 à 23:24, Xavier Bigand a écrit :
> Le 12/03/2018 à 22:30, arturg a écrit :
>> On Monday, 12 March 2018 at 21:00:07 UTC, Xavier Bigand wrote:
>>> Hi,
>>>
>>> I have a CTFE function that I want to make more generic by given it a
>>> module as parameter.
>>>
>>>
>>> My actual code looks like :
>>>
>>> mixin(implementFunctionsOf());
>>>
>>>
>>> string implementFunctionsOf()
>>> {
>>>     import std.traits;
>>>
>>>     string    res;
>>>
>>>     foreach(name; __traits(allMembers, myHardCodedModule))
>>>     {
>>>     }
>>>     return res;
>>> }
>>>
>>>
>>> I tried many things but I can't figure out the type of the parameter I
>>> should use for the function implementFunctionsOf.
>>
>> you can use a alias or a string:
>>
>> void fun(alias mod, string mod2)()
>> {
>>     foreach(m; __traits(allMembers, mod))
>>         pragma(msg, m);
>>
>>     foreach(m; __traits(allMembers, mixin(mod2)))
>>         pragma(msg, m);
>> }
>>
>> void main()
>> {
>>     import std.stdio;
>>     fun!(std.stdio, "std.stdio");
>> }
>
>
> I tried both without success,
>
>
> Here is my full code :
>
> module api_entry;
>
> import std.stdio : writeln;
> import std.algorithm.searching;
>
> import derelict.opengl3.functions;
>
> import std.traits;
>
> string implementFunctionsOf(string mod)
> {
>     import std.traits;
>
>     string    res;
>
>     static foreach(name; __traits(allMembers, mixin(mod)))
>     {
>         static if (mixin("isCallable!" ~ name)
>                    && name.startsWith("da_"))
>         {
>             string oglFunctionName = name[3..$];
>             string returnType = ReturnType!(mixin(name)).stringof;
>             string parametersType = Parameters!(mixin(name)).stringof;
>
>             res ~=
>                 "export\n" ~
>                 "extern (C)\n" ~
>                 returnType ~ "\n" ~
>                 oglFunctionName ~
>                 parametersType ~ "\n" ~
>                 "{\n" ~
>                 "   writeln(\"" ~ oglFunctionName ~ "\");\n";
>
>             static if (ReturnType!(mixin(name)).stringof != "void")
>             {
>                 res ~=
>                     "   " ~ returnType ~ " result;\n" ~
>                     "   return result;";
>             }
>             res ~=
>                 "}\n";
>         }
>     }
>     return res;
> }
>
> mixin(implementFunctionsOf("derelict.opengl3.functions"));
>
>
> As string I get the following error:
> ..\src\api_entry.d(16): Error: variable `mod` cannot be read at compile
> time
> ..\src\api_entry.d(48):        called from here:
> `implementFunctionsOf("derelict.opengl3.functions")`
>
>
>
>
> I also tried to make implementFunctionsOf a mixin template.
>

I forgot to precise, that I don't have a main, because I am trying to create an opengl32.dll. This is why I already have a mixin to inject to function definitions in the root scope.

Le 12/03/2018 à 23:28, Xavier Bigand a écrit :
> Le 12/03/2018 à 23:24, Xavier Bigand a écrit :
>> Le 12/03/2018 à 22:30, arturg a écrit :
>>> On Monday, 12 March 2018 at 21:00:07 UTC, Xavier Bigand wrote:
>>>> Hi,
>>>>
>>>> I have a CTFE function that I want to make more generic by given it a
>>>> module as parameter.
>>>>
>>>>
>>>> My actual code looks like :
>>>>
>>>> mixin(implementFunctionsOf());
>>>>
>>>>
>>>> string implementFunctionsOf()
>>>> {
>>>>     import std.traits;
>>>>
>>>>     string    res;
>>>>
>>>>     foreach(name; __traits(allMembers, myHardCodedModule))
>>>>     {
>>>>     }
>>>>     return res;
>>>> }
>>>>
>>>>
>>>> I tried many things but I can't figure out the type of the parameter I
>>>> should use for the function implementFunctionsOf.
>>>
>>> you can use a alias or a string:
>>>
>>> void fun(alias mod, string mod2)()
>>> {
>>>     foreach(m; __traits(allMembers, mod))
>>>         pragma(msg, m);
>>>
>>>     foreach(m; __traits(allMembers, mixin(mod2)))
>>>         pragma(msg, m);
>>> }
>>>
>>> void main()
>>> {
>>>     import std.stdio;
>>>     fun!(std.stdio, "std.stdio");
>>> }
>>
>>
>> I tried both without success,
>>
>>
>> Here is my full code :
>>
>> module api_entry;
>>
>> import std.stdio : writeln;
>> import std.algorithm.searching;
>>
>> import derelict.opengl3.functions;
>>
>> import std.traits;
>>
>> string implementFunctionsOf(string mod)
>> {
>>     import std.traits;
>>
>>     string    res;
>>
>>     static foreach(name; __traits(allMembers, mixin(mod)))
>>     {
>>         static if (mixin("isCallable!" ~ name)
>>                    && name.startsWith("da_"))
>>         {
>>             string oglFunctionName = name[3..$];
>>             string returnType = ReturnType!(mixin(name)).stringof;
>>             string parametersType = Parameters!(mixin(name)).stringof;
>>
>>             res ~=
>>                 "export\n" ~
>>                 "extern (C)\n" ~
>>                 returnType ~ "\n" ~
>>                 oglFunctionName ~
>>                 parametersType ~ "\n" ~
>>                 "{\n" ~
>>                 "   writeln(\"" ~ oglFunctionName ~ "\");\n";
>>
>>             static if (ReturnType!(mixin(name)).stringof != "void")
>>             {
>>                 res ~=
>>                     "   " ~ returnType ~ " result;\n" ~
>>                     "   return result;";
>>             }
>>             res ~=
>>                 "}\n";
>>         }
>>     }
>>     return res;
>> }
>>
>> mixin(implementFunctionsOf("derelict.opengl3.functions"));
>>
>>
>> As string I get the following error:
>> ..\src\api_entry.d(16): Error: variable `mod` cannot be read at compile
>> time
>> ..\src\api_entry.d(48):        called from here:
>> `implementFunctionsOf("derelict.opengl3.functions")`
>>
>>
>>
>>
>> I also tried to make implementFunctionsOf a mixin template.
>>
>
> I forgot to precise, that I don't have a main, because I am trying to
> create an opengl32.dll. This is why I already have a mixin to inject to
> function definitions in the root scope.
>

Ok, it works with the alias, I didn't see the last () in the implementFunctionsOf prototype.

Thank you a lot.

On Monday, 12 March 2018 at 22:28:30 UTC, Xavier Bigand wrote:
>
> I forgot to precise, that I don't have a main, because I am trying to create an opengl32.dll. This is why I already have a mixin to inject to function definitions in the root scope.

you have to pass the string as a template arg so make implementFunctionsOf a template:

string implementFunctionsOf(string mod)()
{
}

then mix it in somewhere you want:

mixin(implementFunctionOf!"std.stdio");

On Monday, 12 March 2018 at 22:34:10 UTC, Xavier Bigand wrote:
>
> Ok, it works with the alias, I didn't see the last () in the implementFunctionsOf prototype.
>
> Thank you a lot.

no problem. :)

On Monday, 12 March 2018 at 22:24:15 UTC, Xavier Bigand wrote:
> mixin(implementFunctionsOf("derelict.opengl3.functions"));
>
>
> As string I get the following error:
> ..\src\api_entry.d(16): Error: variable `mod` cannot be read at compile time
> ..\src\api_entry.d(48):        called from here: `implementFunctionsOf("derelict.opengl3.functions")`
>
> I also tried to make implementFunctionsOf a mixin template.

make the argument to implementFunctionsOf a template arg.