On Fri, Feb 23, 2007 at 10:49:34AM -0800, Jonathan Lang wrote:
: That said, I think I can do one better:
: Ditch all of the above.  Instead, '*' always acts like a list of all
: valid indices when used in the context of postcircumfix:<[ ]>.

Ooh, shiny!  Or at least, shiny on the shiny side...

: If you want the last index, say '*[-1]' instead of '* - 1'.
: If you want the first index, say '*[0]' instead of '* + 0'.

So the generic version of leaving off both ends would be *[1]..*[-2]
(ignoring that we'd probably write *[0]^..^*[-1] for that instead).

: So the four corners of a two-dimensional array would be:
:  @array[ *[0]; *[0] ];  @array[ *[-1]; *[0] ];
:  @array[ *[0]; *[-1] ]; @array[ *[-1]; *[-1] ];

A point against it visually is the nested use of [].

: The only thing lost here is that '@array[+*]' is unlikely to point
: just past the end of a shaped array.  But then, one of the points of
: shaped arrays is that if you point at an invalid index, you get a
: complaint; so I don't see why one would want to knowingly point to
: one.

I would expect that to point to one off the end in the first dimension only,
which might make sense if that dimension is extensible:

    my @array[*;2;2];

Adding something at +* would then add another 2x2 under it.

: Also, has the syntax for accessing an array's shape been determined
: yet?  If not, I'd like to propose the following:
: @array.shape returns a list of lists, with the top-level list's
: indices corresponding to the dimensions of the shape and each nested
: list containing every valid index in that dimension.  In boolean
: context, the shape method returns true if the array is shaped and
: false if not - though an unshaped array will otherwise pretend to be a
: one-dimensional, zero-based, non-sparse, shaped array.

That's more or less how I was thinking of it, though I hadn't got as
far as boolean context.

: So:
:  @array.shape[0][2] # the third valid index of the first dimension of the 
:  shape
:  @array.shape[-1][0] # the first valid index of the last dimension of the 
:  shape
:  @array.shape[1] # every valid index of the second dimension of the shape
:  @array.shape[1][*] # same as @array.shape[1]
:  [EMAIL PROTECTED] # is this a shaped array?
:  exists @array.shape[2] # does the array have a third dimension?
:  exists @array.shape[3][4] # does the fourth dimension have a fifth element?
:  [EMAIL PROTECTED] # how many dimensions does the shape have?
:  [EMAIL PROTECTED] # how many indices does the first dimension have?
: If we use this notation, then
:  @array[ *; * ]
: is shorthand for
:  @array[ @array.shape[0]; @array.shape[1] ]

Note also that multidimensional whatever gives us

    @array[ ** ]

to mean

    @array[ @@( @array.shape[*] ) ]

or some such.  Though ** might want to be even smarter than that if
we want

    @array[ 0; **; 42]

to dwim.  That'd have to turn into something like:
    @array[ 0; @@( @array.shape[*[1]..*[-2]] ); 42 ]

Also +** might return a shape vector, or maybe +«**.


Reply via email to