Bill Baxter wrote:
On Tue, Nov 3, 2009 at 1:27 PM, Derek Parnell <de...@psych.ward> wrote:
On Mon, 02 Nov 2009 17:47:53 +0100, Don wrote:
is(typeof(XXX)) is infamously ugly and unintuitive
__traits(compiles, XXX) is more comprehensible, but just as ugly.
They are giving metaprogramming in D a bad name. I think we need to get
rid of both of them.
A very easy way of doing this is to replace them with a 'magic
namespace' -- so that they _look_ as though they're functions in a
normal module.
Names which have been suggested include 'meta', 'traits', 'scope',
'compiler'. Personally I think 'meta' is the nicest (and I suggested two
of the others <g>).
Thank you Don for this "voice of reason". A specific keyword for the
concept of compile-time activity/functionality is totally justified.
"meta" is very suitable. Short and to the point.
Shortness is key. In compile-time code this keyword is going to
appear a lot. So if it's going to be a new keyword, I vote for this
one.
"compiler" I could live with.
"traits" is unsuitable, as it is too limiting a concept.
"scope" is unsuitable, as it is already too highly overloaded with
semantics.
"static" is extremely unsuitable. This word should, at best, be only used
for things that do not change value or location during run-time.
A type doesn't change whether it "isArithmetic" at runtime. A "static
if" doesn't change the branch it takes at run-time. So by your
explanation static is exactly the right thing to use.
... and slightly off topic ...
now if only we could get the 'bang' out of template instantiation syntax as
well. When I see the '!' in something like "Foo!(X)()", my mind first says
"we are about to negate something" and then has to switch tracks "oh no,
this actually means we are using a template this time".
It does make template code in D look noisy, but I don't think there's
much chance it's going away. I think if I were making a new language,
I'd seriously consider going with () for both indexing and function
calls, and use [] for template arguments.
--bb
Aka, Scala.
/* D */
T some_func (T : int) (T a, T b) { ... }
U[] another (U) (U a, U[] b) { ... }
some_func!int(1, 2)
/* Scala */
def some_func [T <:Int] (a: T, b: T) = ...
def another [U] (a: U, b: Seq[U]): Seq[U] = ...
some_func[Int] (1, 2)
-- Chris Nicholson-Sauls
