Declaration syntax

[John Colvin]

On Wednesday, 8 January 2014 at 00:23:34 UTC, deed wrote:
> 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);

It's really a matter of opinion which is best, which in my 
opinion is trumped by the familiarity of C-style syntax. I'm sure 
I could work with either way.