I've been thinking that

1.  R7RS Large may adopt multi-dimensional array operations in some
form, and

2.  I'd like to propose something based on this SRFI as the thing to adopt.

I also suspect

1(b) The R7RS Large process will not consider arrays for a long time,
and then a choice will relatively quickly be made among existing
options, with little time for polishing proposals,

while

2(b) I've identified several deficiencies in the current SRFI that I'd
like to remedy before putting forward an array proposal for R7RS Large.

So I'd like to implement these changes ahead of time. I'm soliciting
opinions about the best way to proceed.

I can think of a number of options:

1.  Start another SRFI.

2.  Make the changes in a repository in my own Github account.

3.  Develop the changes in a branch of the SRFI 231 Github repository.

As for (1), the changes I want to make are relatively minor (mainly
listed here after the signature), and perhaps another SRFI is not warranted.

Proceeding with (2) would seem not to invite discussion or criticism of
the changes.

So I guess I prefer option (3); perhaps this SRFI mail list can provide
a forum for discussing any proposed changes (and I could certainly use
some help with some of them).  I admit I haven't seen a similar process
done before.

I welcome other suggestions on how to proceed.

Brad

Things to change in a future library:

1.  There should be a single library, without "safe" and "unsafe"
versions.  Invoking (array-{getter|setter} A) checks the validity of
arguments.  Perhaps %%array-unsafe-{getter|setter} should be exported as
array-unsafe-{getter|setter} for library builders.

2.  Get rid of array-freeze!

3.  Do not fix the order of evaluation of array elements in arguments to
the "bang" (!) procedures.

4.  Add (array-rebase array [lower-bounds]) to translate an array to
given lower bounds.

5.  Add broadcasting of arrays and adding new axes to arrays.

6.  Add interval-{every|any} as wrappers around %%interval-{every|any}.

7.  Add a notation for quickly specifying Bawden-style array
transformations similar to that of NumPy or Racket's math/array.