int i; int j; real r; static assert( isSameSymbol!(i, i)); static assert(!isSameSymbol!(i, j)); static assert(!isSameSymbol!(i, r)); static assert(!isSameSymbol!(j, i)); static assert( isSameSymbol!(j, j)); static assert(!isSameSymbol!(j, r)); static assert(!isSameSymbol!(r, i)); static assert(!isSameSymbol!(r, j)); static assert( isSameSymbol!(r, r)); auto foo() { return 0; } auto bar() { return 0; } static assert( isSameSymbol!(foo, foo)); static assert(!isSameSymbol!(foo, bar)); static assert(!isSameSymbol!(foo, i)); static assert(!isSameSymbol!(bar, foo)); static assert( isSameSymbol!(bar, bar)); static assert(!isSameSymbol!(bar, i)); // Types are symbols too. However, in most cases, they should be compared // as types, not symbols (be it with is expressions or with isSameType), // because the results aren't consistent between scalar types and // user-defined types with regards to type qualifiers when they're compared // as symbols. static assert( isSameSymbol!(double, double)); static assert(!isSameSymbol!(double, const double)); static assert(!isSameSymbol!(double, int)); static assert( isSameSymbol!(Object, Object)); static assert( isSameSymbol!(Object, const Object)); static assert(!isSameSymbol!(i, int)); static assert( isSameSymbol!(typeof(i), int)); // Lambdas can be compared with __traits(isSame, ...), // so they can be compared with isSameSymbol. static assert( isSameSymbol!(a => a + 42, a => a + 42)); static assert(!isSameSymbol!(a => a + 42, a => a + 99)); // Partial instantiation allows it to be used with templates that expect // a predicate that takes only a single argument. import phobos.sys.meta : AliasSeq, indexOf; alias Types = AliasSeq!(i, j, r, int, long, foo); static assert(indexOf!(isSameSymbol!j, Types) == 1); static assert(indexOf!(isSameSymbol!int, Types) == 3); static assert(indexOf!(isSameSymbol!bar, Types) == -1);
Whether the given symbols are the same symbol.
All this does is __traits(isSame, lhs, rhs), so most code shouldn't use it. It's intended to be used in conjunction with templates that take a template predicate - such as those in phobos.sys.meta.
The single-argument overload makes it so that it can be partially instantiated with the first argument, which will often be necessary with template predicates.