Programming Languages – Advantages of Left-to-Right Language Syntax

cgoprogramming-languages

I've been watching an interview with Herb Sutter on Channel9 and he mentioned at the end of the video that left to right language syntax would be on the top on his whishlist for a future C++ standard(although he acknowledges that modifying C++ in that way would pretty much make for a completely different beast).

Apart from:

  • more understandable by humans, clearer to the naked eye;e.g.

    //C syntax

/*pointer to function taking a pointer to function(which takes 2 integers as 

arguments and returns an int), and an int as arguments and returning an int*/

int (*fp)(int (*ff)(int x, int y), int b)

//Go analogous syntax which is left to write

f func(func(int,int) int, int) int

  • easier to parse(leads to better tool support as mentioned in the video – e.g. code refactoring)

what other advantages are there with a "left to right" syntax in a programming language.
I know only of Pascal and Go employing that kind of syntax(and Go does not even go the full way as I understand from this blog post from which I took also the examples)
Would it be feasible to have a systems programming language with that kind of syntax?

Best Answer

The basic advantage is that parsing is simpler and unique. Note that after the line is parsed, the compiler will know what the exact type is, so from there on, how the type was defined is irrelevant.

Any function that returns an argument of array type, or function pointer type are hard to read currently:

// common way of obtaining the static size in elements of an array:
template <typename T, int N>
char (&array_size_impl( T (&)[N] ))[N];
// alternative parser:
template <typename T, int N>               // this would probably be changed also
array_simple_impl function( T [N] & ) char [N] &;

And there would be less chance for misunderstanding (as the most-vexing-parse):

// Current C++
type x( another_type() );      // create an instance x of type passing a
                               // default constructed another_type temporary?
                               // or declare a function x that returns type and takes as argument
                               // a function that has no arguments and returns another_type
// How the compiler reads it:
x function( function() another_type ) type;

// What many people mean:
x type { another_type{} };

Using a similar approach to uniform initialization in C++0x (i.e. {} to identify initialization). Note that with a left to right approach it is much clearer what we are defining. Many people (me for sure) have been bitten at any point by this parsing error in the past (more than once), and that would not be the case with a left-to-right syntax.

Related Topic