Nested Arrays weren’t without controversy as there were two competing designs called Floating and Grounded which differed in many ways, but fundamentally on whether the enclose of a simple scalar produced a new array or the same array.
What's 'enclosing' (is it something like boxing?) and what does it mean to produce a new or the same array?
⎕ ← 1 + 2
⎕ ← 1 9 5 + 2
I don't think the question of "which is best" here can be answered without a lot of practical experience trying both methods. If you like APL, I think this is a good tutorial: http://www.zerobugsandprogramfaster.net/essays/5b.html
Way cool to play with...
Now, with this design, how do you manage a collection of strings? Turns out you can't, so what old software used to do was so have a two-dimensional array of characters. This works reasonably well, except that this means that all strings have to be the same length. You can work with this, but can be very annoying.
What APL2 introduced was the idea that you can not only put scalars inside an array, but also other arrays. This is of course how pretty much every other programming language works, but at the time (as far as I know, this is way before my time) this was seen as very controversial since it made the language less clean, or "elegant".
To go into some details, you can consider a scalar as an array of dimension zero:
⍴⍴5
0
Once you have nested arrays, you can also wrap an array inside a scalar. This allows you to more easily treat arrays as single objects:
s ← 'hello' ⍝ Assign the string "hello" to s
⍴⍴s ⍝ Confirm that s is a one-dimensional array
1
s2 ← ⊂s ⍝ The ⊂ wraps its argument as a scalar, assign the result to s2
⍴⍴s2 ⍝ The result now has 0 dimensions
0
Is this a divergence between APL2 and Sharp implementation? I used to work (a long time ago) with a lot of ex-Sharp people from Toronto who were always harping about the superiority of Sharp.
As far as I know, Sharp APL was "old style" in the sense that it did not support nested arrays. Some people may like that style, but I have a hard time seeing that it is "better", since the nesed arrays are backward compatible with the non-nested style.
Note that you can also use the ⊂ and ⊃ functions to convert between nested and recursive arrays. For example, assuming you have an array of strings:
a ← 'here' 'are' 'some' 'strings'
⍝ a is now a single-dimensional array of 4 elements
⍴a
4
⍝ The ⊃ function converts the nested array into a two-dimensional array
⊃a
here
are
some
strings
⍝ The array is two-dimensional with 4 rows and 7 columns
⍴ ⊃a
4 7This greatly simplified the entire language - both semantics and implementation.
(From what I could understand with floating you are actually adding a scalar element to the array, with grounded you are creating a 1-element array containing the scalar, and adding this to the original array, which is an array of arrays - but I might have completely misunderstood)
In the early 1980’s, a number of APL vendors almost simultaneously introduced a new concept into APL - the nested array. Each element of a nested array can itself be any other (nested) array. A new monadic primitive function, called enclose, was introduced that took any array as its argument and returned a scalar enclosed array. This scalar (rank zero) array could then be inserted in place of any scalar element of any APL array.
Unfortunately there were two inequivalent approaches; grounded arrays as proposed by Ken Iverson [...] and floating arrays as proposed by Jim Brown [...] In the grounded system, enclosing a simple scalar produces an enclosed scalar, whereas in the floating system, enclosing a simple scalar leaves it unchanged.
So enclose(x) is always a scalar, but the two schemes disagree about whether enclose(s) == s for a scalar s.
I was horrified when I learned FORTRAN: I have to write a do-loop to add two arrays together? Why? (No array fortran back then.)