check type

[bearophile]

spir:

> What is the common idiom to check whether the type of a given element is what I expect?
> Seems that
> 	typeof(e) == Type
> is refused by the compiler, for any reason? I get
> 	DeeMatch.d(237): Error: type string is not an expression

I don't know why the language refuses a natural and more clean syntax like:
if (typeof(x) == Type) {...
I think it's to keep the compiler simple, clearly telling apart the compile-time phase that uses types (or CTFE) from the run-time that uses values.
So you have to wrap it into a is(), often this is enough:
if (is(typeof(x) == Type)) {...
But look in the docs at the complex syntax of is() for the many other different ways to use it.


> Also, how to override a class's field so that it is accessed according actual/runtime type? (Like method dispatch.)

This feature is named "double dispatch", and it's present in the object system named CLOS of CommonLisp, but unfortunately it's not present in D (or C++, Java, Python). Maybe the Scala language too has this feature. See:
http://en.wikipedia.org/wiki/Double_dispatch
http://en.wikipedia.org/wiki/Visitor_pattern

The D language allows you to perform the dispatch only on the compile time type of the arguments (or the dynamic type of the "this"). This means that if you have to perform double dispatch in D/C++/Python, then you need to implement/simulate this feature manually. There are several ways to do it, see . In some situations if your program needs to use double dispatch heavily, then you may invent a string mixin to reduce somehow the boilerplate code.


> 	void method (SuperType x) {...access x.f...}
> If I don't define f in SuperType, then I get a compiler error. If I do, then SuperType.f is accessed, not the field on actual class of x.

D is a statically typed language, this means that in general the choices about types (this mean choice of code path or code generation by templates) are performed only at compile time.

Despite languages like Java and D are statically typed, they allow a bit of dynamic typing, using the virtual table of the classes, and allowing run-time types of objects to differ from their compile-time type. But this bit of dynamic typing is limited and is not extended to double/multiple dispatch (on the other hand even very dynamic languages like Python lack double or multiple dispatch).

Bye,
bearophile