D's type declarations seem to read right to left.

[Jonathan M Davis]

On Wednesday, March 21, 2018 20:07:09 tipdbmp via Digitalmars-d-learn wrote:
> D's type declarations seem to read right to left.
>
>
> int an_integer;
>
> int[10] an_array_of_10_integers;
> int[10]* a_pointer_to_an_array_of_10_integers =
> &an_array_of_10_integers;
>
> int*[10] an_array_of_10_pointers_to_integers;
> int*[10]* a_pointer_to_an_array_of_10_pointers_to_integers =
> &an_array_of_10_pointers_to_integers;
>
> int[3][2] an_array_of_2_arrays_of_3_integers;
> int[string] a_hashtable_with_string_keys_and_integer_values;
>
> int[3][string][2]
> an_array_of_2_hashtables_with_string_keys_and_array_of_3_integers_values;
>
> int function(float)
> a_pointer_to_a_function_that_takes_a_float_and_returns_an_integer;
> int function(float)[10]
> an_array_of_10_functions_that_take_floats_and_return_integers;
>
>
> I think this is a big improvement over C's "spiral" way of
> reading types: http://www.unixwiz.net/techtips/reading-cdecl.html
> I guess it could've been left to right, but... it's okay.

In principle, D types read in more or less the same way as C types. The main
differences are that we simplifed how function pointers are declared (making
them more like function prototypes) and got rid of the types on the
right-hand side of the name. e.g.

int[10] arr;

instead of

int arr[10];

Both read outward from the type, but the D way is then right-to-left in this
case, whereas the C way is left-to-right even though they're both reading
outward from the type. So, this makes it look like D reads right-to-left,
but it'st still reading outward from the type. e.g. if you look at how
dynamic arrays are declared, it's still outward from the type, not
right-to-left. e.g.

auto foo = new int[][](10, 14);
assert(foo.length == 10);
assert(foo[0].length == 14);

vs

int[10][14] foo;
assert(foo.length == 14);
assert(foo[0].length == 10);

The fact that parens are used for const does muck with things a bit though.
In C/C++, you have

const int* p;

which is equivalent to

int const* p;

but for whatever reason, both are allowed. The second one reads outward from
the type, whereas the first one essentially breaks those rules a bit. And D
essentially went with the first one, because the equivalent would be

const(int)* p;

and there's no way to put the const on the right. So, while the pointer
portion of the type does read outward from the type, const doesn't really.

So, overall, D cleaned things up, but it didn't actually make them fully
consistent either.

- Jonathan M Davis