Re: Declaration design preference: type or name first

James Harris <james.harris.1@[EMAIL PROTECTED]
> writes:

> As a matter of preference the declarations of some languages put the
> type before the name such as
>
>    int x = 2;
>
> where others put the variable name before the type as in
>
>    x: integer := 2;
>
> I can see advantages to each and would be interested to know what
> other language designers and programmers (i.e. the customers of
> language designers) prefer.

I, mostly, don't care, as long as the context clearly tells me whether
I look at a type or something else.  Several other posters pointed out
the problem with C-style types where parsing something like "foo*bar"
requires one to know if "foo" is a type or a variable.  If you always
use a keyword or other symbol with a declaration, you are not in
doubt, and it matters little if the type is before or after the name.
Examples: "var foo* bar", "bar : foo*", "let foo* bar = ...".  I have
a small preference for types after names, but that may be because most
of my favourite languages (ML, Haskell, Pascal, ...) use this.

What I mostly object to is putting part of the type before the name
and other parts after the name, such as "int x[10]".  This makes it
very hard to read the type of a name.  Is is better with "int[10] x"
or "x : int[10]".  C-style type syntax gets even worse if we have
functional parameter types, such as "int g(int f(int x[10]))".  Note
that to specify a type for the functional parameter f, we have to
invent a dummy name for its parameter -- a name that isn't really part
of the type.  It is much better with a postfix syntax like
"g(f : int[10]->10) : int" or a prefix syntax like "int g(int[10]->10
f)".  It is even worse if we in C-style type syntax have to declare a
function that returns a function.  This would be something like

int f(int x[10]) g(int x)

I'm not sure this is valid C syntax, and it certainly isn't easy to
read.  Isn't it better to write something like

g(x : int) : int[10]->int

?

> Also, my current design, has gone through some iterations of minor
> detail and currently has the ability to allow either the name or the
> type first. I'd be interested to know what people think of this
> flexibility. Is it a good thing? Or does it simply make the code too
> hard to read? If so which option would you say should be enforced?

Keep it consistent but, where you can, make explicit types optional
and let the compiler infer them.

	Torben