On Tuesday, 21 September 2021 at 13:29:44 UTC, Stefan Koch wrote:
> Note that on the "callsite" you have to instantiate the helper template as:

Not true. You can pass module names as plain names now, no more need for the special mixin, with the exception of getting the current module (just because __MODULE__ is a string), but if this were a library function, you wouldn't be using the current module anyway.

> whereas the template above used 5 magic constructs.
>  - 2 different types of pattern matching is expressions.
>    and
>  - 3 different __traits expressions.

Not true. There's two extremely basic traits and one is expression actually necessary here. You overcomplicated it again.


This works today:

import arsd.simpledisplay; // or whatever

enum string[] functionNames(alias M) = ()
{
        string[] names;
        foreach(memberName; __traits(derivedMembers, M))
            static if (is(typeof(__traits(getMember, M, memberName)) ==
            function))
                names ~= memberName;
        return names;
}();

pragma(msg, functionNames!(arsd.simpledisplay));



As you can see, there's one trait, and one is expression, to see if it is a function. Not that complicated.


> you have to use it directly you cannot assign it to a module level variable.

Also not true.

---
module qwe.whatever;

enum string[] functionNames(alias M) = ()
{
        string[] names;
        foreach(memberName; __traits(derivedMembers, M))
            static if (is(typeof(__traits(getMember, M, memberName)) == function))
                names ~= memberName;
        return names;
}();

const fNames = functionNames!(qwe.whatever);

void main() {
        import std.stdio;
        writeln(fNames);
}

void foo() {}
---



$ dmd qwe
$ ./qwe
["main", "foo"]
$ nm qwe.o | grep functionNames
// notice this is empty btw
$

On Tuesday, 21 September 2021 at 14:20:50 UTC, Adam D Ruppe wrote:
> On Tuesday, 21 September 2021 at 13:29:44 UTC, Stefan Koch

>
>
> This works today:
>
> import arsd.simpledisplay; // or whatever
>
> enum string[] functionNames(alias M) = ()
> {
>         string[] names;
>         foreach(memberName; __traits(derivedMembers, M))
>             static if (is(typeof(__traits(getMember, M, memberName)) ==
>             function))
>                 names ~= memberName;
>         return names;
> }();
>
> pragma(msg, functionNames!(arsd.simpledisplay));
>

This does work. Interesting.

But had I not posted here would I have been able to get to the template you posted above?

I am not trying to over-complicate anything this is what I naturally arrive at.
After spending more than 20 minutes to get it to show me the answer I am looking for.

Here's one with param names:

----

module qwe;

struct FunctionInfo {
        string name;
        string[] paramNames;
}

enum FunctionInfo[] functionInfo(alias M) = ()
{
        FunctionInfo[] res;
        foreach(memberName; __traits(derivedMembers, M))
            static if (is(typeof(__traits(getMember, M, memberName)) Params == __parameters)) {
                FunctionInfo fi = FunctionInfo(memberName);
                foreach(idx, param; Params)
                        fi.paramNames ~= __traits(identifier, Params[idx .. idx + 1]);
                res ~= fi;
            }
        return res;
}();

void main() {
        import std.stdio;
        writeln(functionInfo!qwe);
}

void foo(int a, int b){}

----


Of course the weird thing here is the need to slice the params tuple to get the idenfitier. I had to borrow that trick from Phobos but now that I know it it is very useful.

Otherwise the code is still fairly simple. Only hte one is expression since if it doesn't have params it doesn't trigger the condition and if all functions have params (even if it is an empty set)

On Tuesday, 21 September 2021 at 15:07:35 UTC, Adam D Ruppe wrote:
> Here's one with param names:
>
> ----
>
> module qwe;
>
> struct FunctionInfo {
>         string name;
>         string[] paramNames;
> }
>
> enum FunctionInfo[] functionInfo(alias M) = ()
> {
>         FunctionInfo[] res;
>         foreach(memberName; __traits(derivedMembers, M))
>             static if (is(typeof(__traits(getMember, M, memberName)) Params == __parameters)) {
>                 FunctionInfo fi = FunctionInfo(memberName);
>                 foreach(idx, param; Params)
>                         fi.paramNames ~= __traits(identifier, Params[idx .. idx + 1]);
>                 res ~= fi;
>             }
>         return res;
> }();
>
> void main() {
>         import std.stdio;
>         writeln(functionInfo!qwe);
> }
>
> void foo(int a, int b){}
>

```d
Here's the core.reflect version for that
struct FunctionInfo
{
    string name;
    string[] params;
}

@(core.reflect)
const(FunctionInfo)[] FunctionsInfoFromModule(string module_ = __MODULE__,
    ReflectFlags flags = ReflectFlags.NoMemberRecursion,
    immutable Scope _scope = currentScope()
)
{
    const(FunctionInfo)[] result;
    auto mod_ = nodeFromName(module_, flags, _scope);
    if (auto mod = cast(Module) mod_)
    foreach(member;mod.members)
    {
        if (auto fd = cast(const FunctionDeclaration) member)
        {
            string[] paramNames;
            foreach(p;fd.type.parameterTypes) //because that's how dmd looks and I didn't smooth that part out yet. it's going to be nicer in the future
            {
                paramNames ~= p.identfier; // TODO maybe rename identifier to name?
            }
            result ~= FunctionInfo(fd.name, paramNames);
        }
    }

    return result;
}
```

Alternatively you could of course just use the `FunctionDeclaration` object ;)
As the information is already bundled.