Declaration syntax

[deed]

 From time to time I find the declaration syntax slightly awkward. 
The main
reason is that the identifiers come after the types, making it 
harder to
identify names and get an overview of the code. This bothered me 
enough to
start playing with alternatives.

My two questions are:

1. Are there technical reasons not to do it this way, like 
grammar/ambiguity,
    parsing time, etc.?
2. Have others been thinking in same direction playing with 
converters
    or alternative front ends?

NB! This is by no means any suggestion to change D-syntax.

Modifications:

1. Swap type and name. Like Go, but return type between function 
name and
    parameter list.
2. Names come first, all other annotations after. ALWAYS. Example:

       private const(int)[] foo(const(int)[] all, int newNum, int 
sum) {}

    becomes

       foo const(int)[](all const(int)[], newNum int, sum int) 
private {}

    At this point the readability and overview would be improved 
IMO.

3. Separate parameter names from their types.

       foo(all, newNum, sum) const(int)[](const(int)[], int, int) 
private {}


A couple of examples from phobos follow below:

//========================================
// From std.container
//========================================
// Current syntax

struct Range
{
     private Node * _first;
     private Node * _last;
     private this(Node* first, Node* last);
     private this(Node* n);
     @property bool empty() const nothrow;
     @property T front();
     void popFront();
     @property Range save();
     @property T back();
     void popBack();
}


// Modified syntax

Range struct
{
     _first Node* private;
     _last Node* private;
     this(first, last) (Node*, Node*) private;
     this(n) (Node*) private;
     empty bool() @property const nothrow;
     front T() @property;
     popFront void();
     save Range() @property ;
     back T() @property;
     popBack void();
}

//========================================
// From std.datetime
//========================================
// Current syntax

abstract class TimeZone
{
public:
     @property string name() const nothrow;
     @property string stdName() const nothrow;
     @property string dstName() const nothrow;
     @property abstract bool hasDST() const nothrow;
     abstract bool dstInEffect(long stdTime) const nothrow;
     abstract long utcToTZ(long stdTime) const nothrow;
     abstract long tzToUTC(long adjTime) const nothrow;
     Duration utcOffsetAt(long stdTime) const nothrow;
     static immutable(TimeZone) getTimeZone(string name);
     static string[] getInstalledTZNames(string subName = "");
private:
     this(string name, string stdName, string dstName) immutable 
pure;
     immutable string _name;
     immutable string _stdName;
     immutable string _dstName;
}


// Modified syntax

TimeZone class abstract
{
public:
     name() string() @property const nothrow;
     stdName() string() @property const nothrow;
     dstName() string() @property const nothrow;
     hasDST() bool() @property const nothrow abstract;
     dstInEffect(stdTime) bool(long) abstract const nothrow;
     utcToTZ(stdTime) long(long) abstract const nothrow;
     tzToUTC(adjTime) long(long) abstract const nothrow;
     utcOffsetAt(stdTime) Duration(long)  const nothrow;
     getTimeZone(name) static immutable TimeZone(string);
     getInstalledTZNames(subName = "") static string[] (string);
private:
     this(name, stdName, dstName) (string, string, string) 
immutable pure;
     _name immutable string;
     _stdName immutable string;
     _dstName immutable string;
}

// Alternative layout:

TimeZone class abstract
{
   public:
     name()                  string()    @property const nothrow;
     stdName()               string()    @property const nothrow;
     dstName()               string()    @property const nothrow;
     hasDST()                bool()      @property const nothrow 
abstract;
     dstInEffect( stdTime )  bool(long)  abstract const nothrow;
     utcToTZ( stdTime )      long(long)  abstract const nothrow;
     tzToUTC( adjTime )      long(long)  abstract const nothrow;
     utcOffsetAt( stdTime )  Duration(long)  const nothrow;
     getTimeZone( name )     static immutable TimeZone(string);
     getInstalledTZNames( subName = "")
                             static string[](string);
   private:
     this(name, stdName, dstName) (string, string, string) 
immutable pure;
     _name    immutable string;
     _stdName immutable string;
     _dstName immutable string;
}

//========================================
// From std.getopt
//========================================
// Current syntax

private void getoptImpl(T...)(ref string[] args, ref 
configuration cfg, T opts);

void handleOption(R)(string option, R receiver, ref string[] args,
         ref configuration cfg, bool incremental);

private bool optMatch(string arg, string optPattern, ref string 
value,
     configuration cfg);


// Modified syntax

getoptImpl(args, cfg, opts) private
     (T...) void (ref string[], ref configuration, T);

handleOption(option, receiver, args, cfg, incremental)
     (R) void (string, R, ref string[], ref configuration, bool);

optMatch(arg, optPattern, value, cfg) private
     bool (string, string, ref string, configuration);