I've been out of the D community for a few
reasons. The big one is that I've been loaded with schoolwork and this is
the first time in about three months that I've had any free time. The
other reason is the topic of this thread.
Personally I don't see where D is going, or if it
is going. The patches come out few and far between. I know,
one-man band, but still. Phobos is almost as shaky now as it was a year
ago. The vector-like array operations are still not implemented.
Worst of all, the whole language seems kind of.. clunky.
Granted, it's nowhere NEAR as ugly-feeling as
C++. But it's getting there.
Class properties feel like a weird compiler
hack. There is no official "property" keyword or anything like that.
In fact, the following, although confusing, is legal:
class A
{
public:
void Something(int x) {
writefln("Something here: ",x); }
}
void main()
{
A
a=new A;
a.Something=7 // prints
"Something here: 7"
}
Something() is not
a property, though I can call it with the property syntax.
The "classes are references even though the syntax
looks like they're local" (A a=new A) makes some
template definitions painful and redundant. I think it'd be easier to
bring back class pointers (A* a=new A) and
simply flag any attempt to create class instances on the stack as an
error.
Casting is, frankly, a pain. Not only do we
now have the ugly cast(type)expr operator, but
we cannot create more than one opCast per class
(understandable) and there is no such thing as opAssign (NOT understandable). We are then stuck
making all these stupid "toSomething()" member
functions, which can potentially cause frustration (imagine if you have int x; x=a.toInt(); then you change x's type to float. it'll then cast to int and then to float,
rather than automatically selecting a's toFloat() operator (if it has one)). If there's
one thing I love about C++, it's its ability to hide all that nasty casting
crap. The only problem with C++ is that sometimes it's a little obscure as
to what goes through what function when implicitly casting. But 99% of the
time it's a very simple, obvious cast anyway, so I don't see what's wrong
with implicit casting.
While I like the idea of inherent properties of
types (like .sizeof, .init etc.), unless those property names are keywords,
there will be opportunity to write such ugliness as:
class
A
{
public:
int sizeof() { return 77;
}
}
void main()
{
A
a=new A;
writefln(a.sizeof);
}
Whaat?! How can that possibly be
legal?
Lastly, I doubt this is ever going to change, and
this isn't really part of the language per se, but I really really
REALLY would like to see the D compiler produce regular old COFF files and the
linker support them as well, instead of the weird DM OMF files that it currently
makes (and are, as far as I know, incompatible with virtually everything else,
so no using D libs in VC++). There are TONS of C libs out there that come
in COFF format and it's just stupid to not be able to use them without messing
with a third-party linker.
This is just where I see D as it stands now.
I've been working on a C++ project recently, and I just can't get into the swing
of C++ anymore, after seeing and using D. But I look at D and I see a
language that's getting to be just as quirky as C++.