I am using Parameters and ReturnType which give me the "name" of the type used. e.g.,

int foo(SomeEnum)

will give SomeEnum and int for the type respectively.

What I need to do, is also get the D types that these use.

int is int, but SomeEnum is an enum.

Is there a traits function or some way to reduce the derived type to it's most primitive D type?

A specific class should give "class", some enum should give "enum", an interface "interface", a function should give "function", etc.

On Friday, 17 March 2017 at 23:54:36 UTC, Hussien wrote:
> I am using Parameters and ReturnType which give me the "name" of the type used. e.g.,
>
> int foo(SomeEnum)
>
> will give SomeEnum and int for the type respectively.
>
> What I need to do, is also get the D types that these use.
>
> int is int, but SomeEnum is an enum.
>
> Is there a traits function or some way to reduce the derived type to it's most primitive D type?
>
> A specific class should give "class", some enum should give "enum", an interface "interface", a function should give "function", etc.

Parameters!foo[0] == SomeEnum
SomeEnum == enum

if some enum is
SomeEnum : int
{
    someValue
}
then
static assert (is(Parameters!foo[0] == T, T : int));
will pass.

On Saturday, 18 March 2017 at 00:36:21 UTC, Nicholas Wilson wrote:
> On Friday, 17 March 2017 at 23:54:36 UTC, Hussien wrote:
>> I am using Parameters and ReturnType which give me the "name" of the type used. e.g.,
>>
>> int foo(SomeEnum)
>>
>> will give SomeEnum and int for the type respectively.
>>
>> What I need to do, is also get the D types that these use.
>>
>> int is int, but SomeEnum is an enum.
>>
>> Is there a traits function or some way to reduce the derived type to it's most primitive D type?
>>
>> A specific class should give "class", some enum should give "enum", an interface "interface", a function should give "function", etc.
>
> Parameters!foo[0] == SomeEnum
> SomeEnum == enum
>
> if some enum is
> SomeEnum : int
> {
>     someValue
> }
> then
> static assert (is(Parameters!foo[0] == T, T : int));
> will pass.

I need the general solution. One that simply returns the type. None of what you      said helps...

On Friday, 17 March 2017 at 23:54:36 UTC, Hussien wrote:
> What I need to do, is also get the D types that these use.

Those aren't types, they are more like categories of type, so there's nothing in the language that can represent them to return (except maybe a string).

Instead, you can test the family with the is expression, like so:

static if(is(SomeEnum == enum))

else static if(is(SomeClass == class))

and so on. you could write a function that checks those (there are only i think 10 possibilities, enum, class, interface, struct, union, function, template, module, or basic type, or not a type at all) and return a string or whatever you choose to represent them.

On 03/17/2017 07:28 PM, Adam D. Ruppe wrote:
> On Friday, 17 March 2017 at 23:54:36 UTC, Hussien wrote:
>> What I need to do, is also get the D types that these use.
>
> Those aren't types, they are more like categories of type, so there's
> nothing in the language that can represent them to return (except maybe
> a string).
>
> Instead, you can test the family with the is expression, like so:
>
> static if(is(SomeEnum == enum))
>
> else static if(is(SomeClass == class))
>
> and so on. you could write a function that checks those (there are only
> i think 10 possibilities, enum, class, interface, struct, union,
> function, template, module, or basic type, or not a type at all) and
> return a string or whatever you choose to represent them.
>

I wrote the following before reading your reply:

None of those are concepts that you can capture i.e. you can't say:

    kind = class;

However, the 'is' expression can differentiate between them, in which case you can get e.g. a string out:


http://ddili.org/ders/d.en/is_expr.html#ix_is_expr.struct,%20is%20expression

template Kind(T) {
    static if (is (T == struct)) {
        enum Kind = "struct";
    }
    else static if (is (T == union)) {
        enum Kind = "union";
    }
    // etc.
    else {
        static assert("WAT!");
    }
}

unittest {
    struct S {}
    union U {}
    static assert(Kind!S == "struct");
    static assert(Kind!U == "union");
}

void main() {
}

Ali

On Saturday, 18 March 2017 at 02:23:01 UTC, Hussien wrote:

>
> I need the general solution. One that simply returns the type. None of what you      said helps...

string dtype(T)() {
    static if(is(T == enum)) return "enum";
    else static if(is(T == class)) return "class";
    else static if(is(T == struct)) return "struct";
    // etc...
}

void main() {
    struct Foo {};
    assert(dtype!Foo == "struct");
}

On Saturday, 18 March 2017 at 05:15:07 UTC, Mike Parker wrote:
> On Saturday, 18 March 2017 at 02:23:01 UTC, Hussien wrote:
>
>>
>> I need the general solution. One that simply returns the type. None of what you      said helps...
>
> string dtype(T)() {
>     static if(is(T == enum)) return "enum";
>     else static if(is(T == class)) return "class";
>     else static if(is(T == struct)) return "struct";
>     // etc...
> }
>
> void main() {
>     struct Foo {};
>     assert(dtype!Foo == "struct");
> }

So you are telling me there is no way to do this easily? I have to fill in the // etc part with all the possible types that can exist in D? I guess there could be a default that simply returns the typeof, but just seems like a hack overall.

On Saturday, 18 March 2017 at 13:06:56 UTC, Hussien wrote:
> So you are telling me there is no way to do this easily?

What are you actually trying to do?

On Saturday, 18 March 2017 at 13:16:49 UTC, Adam D. Ruppe wrote:
> On Saturday, 18 March 2017 at 13:06:56 UTC, Hussien wrote:
>> So you are telling me there is no way to do this easily?
>
> What are you actually trying to do?

Glad you asked! It is very simple: I am trying to get the underlying D type from a type that I have.

interface X; => dtype!(X) == "interface"
enum X; => dtype!(X) == "enum"
class X; => dtype!(X) == "class"
struct X; => dtype!(X) == "struct"
union X; => dtype!(X) == "union"
wchar* X; => dtype!(X) == "wchar*"
int X; => dtype!(X) == "int"
void function() X; => dtype!(X) == "function*"
void X(); => dtype!(X) == "function"
etc..
etc..

The very right terms should only be terms that are listed in the D grammar as types besides the *'s. If a type is a pointer to a _type_, dtype should return _type_*, etc.

On Saturday, 18 March 2017 at 13:30:22 UTC, Hussien wrote:
> Glad you asked! It is very simple: I am trying to get the underlying D type from a type that I have.

But why? What are you going to do with it?