On 12/21/20 8:47 PM, Rekel wrote:
> On Monday, 30 January 2017 at 07:33:34 UTC, Ali Çehreli wrote:
>> As others have said, D's array definition is natural because unlike
>> C's inside-out (or is that outside-in?) syntax, it follows from the
>> alias syntax. Replacing History inside main with Matrix[], etc.:
>>
>> History history; // is the same as:
>> Matrix[] history; // is the same as:
>> Row[4][] history; // is the same as:
>> int[4][4][] history;
>>
>> Ali
>
> Defending array-notation by giving an example of explicitly not using
> declared aliases makes no sense to me.
Reading 3-year younger Ali's message, I still agree with him. The
aliases were not given to defend D's array syntax. They were just an
additional information which I do use occasionally to simplify my code.
> When I define 2d arrays, or index them, I think in row -> column terms
Everybody have their own mental model. Because C, C++, D, three
languages that I am quite familiar with, don't have 2d arrays,
personally, I never felt comfortable with that mental model. I don't
think C's array syntax is left-to-right or right-to-left, it's either
inside-out or outside-in. As soon as I learned about D's array syntax I
felt happy. Consistent...
> (often math notation for matrix size being; 'rows x columns'), or more
> generally in big -> small terms, which is clear when using the
> consistent left->right notation, big picture first followed by detail,
> honestly the whole concept of encapsulation;
>
>> History history;
>> Matrix[] history;
Ok.
>> Row[][4] history; // collection of rows, stored in a dynamic array
But that's not consistent. If array syntax is "type followed by square
bracketed stuff", then your history must be
Row[4][] history;
Row[4] -> Four rows
Now, if we call that T, a history of those is
T[]
Replacing T with Row[4]
Row[4][] history;
That's what understand from consistency. What other consistent mental
model is there to accept int[] as an array of ints but when it comes to
an array of Row[4]s we should write Row[][4]? It's not logical nor
consistent. It's a remnant of C, where the creator decided to make the
definition and the use the same (or similar). Well, that did not work
for me. And the creator agreed in a interview (which I am not motivated
to search for now) that he might find a better syntax for C array but it
was too late then.
> At heart however, this declaration design leads to inconsistency.
I disagree and I don't even understand.
>> int[1][2] history; // 1 columm, 2 rows
> vs
>> int last_element = history[1][0] // row 1, column 0
>
> This makes no sense to anyone used to reading left to right, or even
> right to left.
You seem to expect the language to parse history[1][0] as a whole. (?)
However, history[1] is an expression by itself. There is one thing that
history[1] returns and that is the second element of that array. [0] is
and should be applied to whatever history[1] expression produces. Now,
that's consistent.
> Honestly, reversing reading-order when indexing & declaring is the worst
> idea I could imagine if consistency and readability were your goal.
I argue the complete opposite for the same reason: consistency and
readability.
> It
> doesn't make more sense because you're reading 'outward', that would
> mean I would have to read both left to right _and_ right to left.
I always read from left to right: T[]. That is the array syntax. And
arr[i]; that is the array element access syntax. Everything else falls
into place with those definitions.
> The argument Jonathan M Davis gives in this regard hold no water for me.
Neither to me. I am simple person. Definition: T[], use: arr[i]. Done. :)
>> Like in C/C++, types are mostly read outward from the variable name in
>> D. In both C/C++ and D,
Perhaps because I'm not a native speaker, I have never ever read any
definition from right-to-left or inside out or outside in.
>> int* foo;
>>
>> is a pointer to an int.
To me, it has always been an "int pointer".
> It's read outward from the variable name, so
>> you get the pointer and then what it points to. Similarly,
>>
>> int** foo;
>>
>> is a pointer to a pointer to an int.
No: "int pointer pointer". :)
> Feel free to read them the way you want, but personally, I read int* foo
> as 'integer pointer', which is not 'outward'.
Thank you! Me too! :)
Let me try the history example:
Row[4][] history;
Row array (of 4) array.
> just noticed this is how D handles multidimensional arrays
I think that's the source of the disagreements: D does not have
multidimensional arrays. C and C++ don't have multidimensional arrays
either.
> It saddens me quite a bit, as I see it as a big design flaw and quite a
> turn-off
Fully disagreed: D's array syntax makes me happy; designed right. :)
> , "unfortunately one that can't be fixed" as Profile Analysis
> put it.
Phew! :)
>> Have a nice & safe christmas!
Same to you! <3
Ali
