isSameSymbol

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);