Does D have too many features?

[akaz]

Sorry for my 2nd intervention on this thread. I recently ported 
some (not much) code from C to D. My impression was that D(2) 
tries to be too many things at once. I even considered porting to 
D(1) instead of D(2). What attracted me into the first place to D 
was it promise to be a "better C" (and a better C++), at least 
this is I saw it. However, it seems to have grown too complex to 
me. Yes, I understand that new, modern features should be 
provided by the language, but I do not like to be forced to use 
those.

 From my (limited) background, what I really liked in D:

*the new type[n] and type* declaration syntax
*the templates syntax (that's a biiig plus)
*other things that I do not remember now, but they are plenty of 
them
*the fact that constructors and destructors do not need renaming 
when class name changes (I hated that in C++ and Java), although 
I would have liked more special kewords like "ctor()" and 
"dtor()", instead of "this()" and "~this()", but I can cope with 
that)

What I did NOT like in D (is my impression):

*the confusion between . and -> operators (yes, I know the latter 
does not exist in D, is just for talking first here) for classes 
and structs and why classes are or are not pointers and why 
structs behave differently (or, at least, this is how I perceive 
it) and why not the pointer syntax is not used if they are 
pointers (well, references) and so on (yes, I am a bit dizzy, but 
is not entirely my fault; it's also D's).
*the many @ annotations that is not clear if they are compulsory 
or not (and, if not, how to convince me to use them...)
*the writing of the p[0..len] that you need to use when some 
other code (C code) passes you the pointer to data and the length 
(I just do not like it)
*it is also my impression that you cannot declare int[] 
x=<<some_initialization>> as a static array with length filled in 
by compiler at the compile time, since the length is known? 
instead, x is interpreted as a dynamic array (which, also, I do 
not like that same syntax, or very similar, is used for both 
concepts).
*the fact that the calling of a function bears no indication if 
you modify or not the passed variable (I much prefer the C-ish 
style of foo(a,&b); where you *almost* know that b will be 
modified)

Well, these are some. I feel that the right line is somewhere 
between D1 and D2. It is good that advanced, complex features are 
present in D, I just not want to be forced to use those when 
porting "traditional" C code.

I expected to meet D and exclaim: wow! C++ done right! Instead, I 
feel like being forced to learn another, completely new paradigm 
language, like I would start with Lisp or something else.

Remember:
"Within D, there is a much smaller and cleaner language 
struggling to get out".