Thread overview | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
July 01, 2014 How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
I have a question. How could I know if some alias or template parameter is some template symbol. I want to not that I want to know that symbol is template symbol itself but not instance of template (std.traits.isInstanceOf give answer for that question). I'll give some example template Foo(T...) { } template isFoo(alias F) { } |
July 01, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | I suddenly posted it for somehow. But I hope idea is clear. How could I test if symbol is equal to some concrete template. I tried these examples: template isFoo(alias F) { enum bool isFoo = is( F == Foo ); } template isFoo(alias F) { enum bool isFoo = F == Foo; } Could you advise something to solve this? |
July 01, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | template Foo(T...) {} template Bar(T...) {} template isFoo(alias F) { enum isFoo = __traits(isSame, F, Foo); } pragma(msg, isFoo!Foo); // true pragma(msg, isFoo!Bar); // false |
July 01, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Peter Alexander | On Tuesday, 1 July 2014 at 05:51:17 UTC, Peter Alexander wrote:
> template Foo(T...) {}
> template Bar(T...) {}
>
> template isFoo(alias F)
> {
> enum isFoo = __traits(isSame, F, Foo);
> }
>
> pragma(msg, isFoo!Foo); // true
> pragma(msg, isFoo!Bar); // false
Thanks for quick response. I really forget to look into language __traits statement.
|
July 01, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | On Tuesday, 1 July 2014 at 05:58:19 UTC, Uranuz wrote:
> Thanks for quick response. I really forget to look into language __traits statement.
Another option:
enum isFoo(T) = is(T == Foo!P, P...);
By using such an is-expression you get the parameters Foo was instantiated with as an added bonus.
struct Foo(T)
{
T val;
}
auto createAFoo(T)(string s)
if(is(T == Foo!P, P))
{
return T(s.to!P);
}
|
July 06, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Rene Zwanenburg | I have another question about testing if given symbol is instance of the given template and geting it's template arguments. I'm talking about raw template symbols, but not struct or class templates. For case with struct or class template std.traits.isInstanceOf is working well. But using *raw* template is not possible for it. There is an example. import std.stdio, std.traits; template WrapperTemplate(T) {} void main() { writeln( isInstanceOf!(WrapperTemplate, WrapperTemplate!(int)) ); } Because isInstanceOf implemented as *is* expression it expects type arguments, but template is not type at all. So this is not working. As we have __traits(isSame, ...) we could make such a test, but I need to have tuple of template arguments. But I don't understand how to get them template isMyInstanceOf(alias Templ, alias Inst) { } |
July 06, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | Suddenly posted. I don't know why it's happened)) template isMyInstanceOf(alias Templ, alias Inst) { alias Args = ???; //I don't have idea how to get it enum bool isMyInstanceOf = __traits(isSame, Templ!(Args), Inst); } Do you have any idea how to solve this? May be standad library could be improved with such type of test for template instance? |
July 06, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | > template isMyInstanceOf(alias Templ, alias Inst) > { > alias Args = ???; //I don't have idea how to get it > > enum bool isMyInstanceOf = __traits(isSame, Templ!(Args), Inst); > } > > Do you have any idea how to solve this? May be standad library could be improved with such type of test for template instance? Is new compiler trait is needed for solving this like alias Args = __traits(getTemplateArgumentList, Inst); or it could be solved with existing tools? |
July 06, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Uranuz | On 07/05/2014 10:33 PM, Uranuz wrote:
> I have another question about testing if given symbol is instance of the
> given template and geting it's template arguments.
Applying Rene Zwanenburg's message... It is not complete because integral template parameters don't work yet.
import std.typetuple;
template instanceArgsOf(alias S, T)
{
import std.traits : isInstanceOf;
static if (isInstanceOf!(S, T))
{
static if (is(T == S!Args, Args...)) {
alias instanceArgsOf = Args;
} else {
alias instanceArgsOf = void;
}
} else {
alias instanceArgsOf = void;
}
}
unittest
{
// Adapting the unittests of std.traits.isInstanceOf
static struct Foo(T...) { }
static struct Bar(T...) { }
static struct Doo(T) { }
static struct ABC(int x) { }
static assert(is (instanceArgsOf!(Foo, Foo!(int, double)) ==
TypeTuple!(int, double)));
static assert(is (instanceArgsOf!(Foo, Bar!int) == void));
static assert(is (instanceArgsOf!(Foo, int) == void));
static assert(is (instanceArgsOf!(Doo, Doo!int) == TypeTuple!(int)));
/*
* The following needs more work because what comes back is something
* called a 'tuple(1)' (Yes, in lowercase.)
*
* static assert(is (instanceArgsOf!(ABC, ABC!1) == TypeTuple!(1)));
*/
static assert(!__traits(compiles, instanceArgsOf!(Foo, Foo)));
}
void main()
{}
Ali
|
July 06, 2014 Re: How to test templates for equality? | ||||
---|---|---|---|---|
| ||||
Posted in reply to Ali Çehreli | Seeing his example, the OP wants a solution that works even for templates: template Test1(T) {} pragma(msg, instanceArgsOf!(Test1, Test1!int)); which fails because Test1!int is not a type (std.traits.isInstanceOf fails also, for the same reason). And is(symbol == Name!Args, Args...) does not work if Name!Args and symbol are not types. In this particular case, the only solution I know of is an awful hack: using .stringof and __traits(identifier, x) and then parse the strings: "Name!(int, double[string])" and "Name(T, U[V], U, V)" and then the fun begins: in the general case, you must then equate the arguments lists (recursively). Philippe |
Copyright © 1999-2021 by the D Language Foundation