Could we make an attempt to decide on either singular or plural for SRFI
and RnRS library names?

Below is an exhaustive survey of the current names. It shows that plural
is clearly winning: R7RS Small uses singular, but even in that standard
there are only two library names that clearly use singular where they
could use plural: (scheme char) and (scheme file). The other names are
either uncountable, or refer to something intrinsically singular such as
case-lambda, which is one specific operator.

R7RS Large adds several more singular library names, but since it's not
yet finalized, this might still change?

Apart from the singular vs plural habit, RnRS and especially R7RS favors
short library names, just a single word. Many of the current, non-RnRS
SRFI library names are quite long by comparison. Personally, I much
prefer the short names, but it would be nice to come to a consensus here
as well.

If we manage to make a decision, ideally we can synchronize the R7RS
Large and SRFI library names, adhering to a consistent style in each.

### R6RS names

arithmetic bitwise
arithmetic fixnums [plural]
arithmetic flonums [plural]
bytevectors [plural]
conditions [plural]
control
enums [plural]
eval
exceptions [plural]
files [plural]
hashtables [plural]
io ports [plural]
io simple
lists [plural]
mutable-pairs [plural]
mutable-strings [plural]
programs [plural]
r5rs
records inspection [plural]
records procedural [plural]
records syntactic [plural]
sorting
syntax-case
unicode

### R7RS Small names

base
case-lambda
char [singular]
complex
cxr
eval
file [singular]
inexact
lazy
load
process-context
r5rs
read
repl
time
write

### R7RS Large names vs equivalent SRFI names

SRFI 1 -- list -- lists [singular vs plural]
SRFI 14 -- charset -- char-sets [singular vs plural]
SRFI 41 -- stream -- streams [singular vs plural]
SRFI 101 -- rlist -- N/A [singular]
SRFI 111 -- box -- N/A [singular]
SRFI 113 -- set -- N/A [singular]
SRFI 115 -- regex -- regex
SRFI 117 -- list-queue -- list-queues [singular vs plural]
SRFI 121 -- generator -- N/A [singular]
SRFI 124 -- ephemeron -- N/A [singular]
SRFI 125 -- hash-table -- hashtables [singular vs plural]
SRFI 127 -- lseq -- lazy-sequences [plural]
SRFI 128 -- comparator -- N/A
SRFI 132 -- sort -- sorting
SRFI 133 -- vector -- vectors [singular vs plural]
SRFI 134 -- ideque -- N/A [singular]
SRFI 135 -- text -- N/A [singular]
SRFI 141 -- division -- integer-division
SRFI 143 -- fixnum -- fixnums [singular vs plural]
SRFI 144 -- flonum -- N/A [singular]
SRFI 146 -- mapping -- N/A [singular]
SRFI 151 -- bitwise -- bitwise-operations
SRFI 158 -- generator -- generators-and-accumulators [singular vs plural]
SRFI 159 -- show -- N/A
SRFI 160 -- vector -- N/A [singular]

### Non R7RS Large SRFI names

SRFI 0 cond-expand
SRFI 2 and-let*
SRFI 4 numeric-vectors [plural]
SRFI 5 let
SRFI 6 basic-string-ports [plural]
SRFI 8 receive
SRFI 9 records [plural]
SRFI 11 let-values
SRFI 13 strings [plural]
SRFI 15 fluid-let
SRFI 16 case-lambda
SRFI 17 generalized-set!
SRFI 18 multithreading
SRFI 19 time
SRFI 21 real-time-multithreading
SRFI 23 error
SRFI 25 multi-dimensional-arrays [plural]
SRFI 26 cut
SRFI 27 random-bits [plural]
SRFI 28 basic-format-strings [plural]
SRFI 29 localization
SRFI 31 rec
SRFI 34 exception-handling
SRFI 35 conditions [plural]
SRFI 37 args-fold
SRFI 38 with-shared-structure
SRFI 39 parameters [plural]
SRFI 42 eager-comprehensions [plural]
SRFI 43 vectors [plural]
SRFI 44 collections [plural]
SRFI 45 lazy
SRFI 46 syntax-rules
SRFI 47 arrays [plural]
SRFI 48 intermediate-format-strings [plural]
SRFI 51 rest-values [plural]
SRFI 54 cat
SRFI 57 records [plural]
SRFI 59 vicinities [plural]
SRFI 60 integer-bits [plural]
SRFI 61 cond
SRFI 63 arrays [plural]
SRFI 64 testing
SRFI 66 octet-vectors [plural]
SRFI 67 compare-procedures [plural]
SRFI 69 basic-hash-tables [plural]
SRFI 71 let
SRFI 74 blobs [plural]
SRFI 78 lightweight-testing
SRFI 86 mu-and-nu
SRFI 87 case
SRFI 95 sorting-and-merging
SRFI 98 os-environment-variables [plural]
SRFI 99 records [plural]
SRFI 126 r6rs-hashtables [plural]
SRFI 128 comparators [plural]
SRFI 129 titlecase
SRFI 130 string-cursors [plural]
SRFI 131 records [plural]
SRFI 145 assume
SRFI 152 strings [plural]
SRFI 156 predicate-combiners [plural]
SRFI 175 ascii

### Summary of clearly singular names

char [R7RS Small]
file [R7RS Small]

list [R7RS Large]
charset [R7RS Large]
stream [R7RS Large]
rlist [R7RS Large]
box [R7RS Large]
set [R7RS Large]
list-queue [R7RS Large]
generator [R7RS Large]
ephemeron [R7RS Large]
hash-table [R7RS Large]
vector [R7RS Large]
ideque [R7RS Large]
text [R7RS Large]
fixnum [R7RS Large]
flonum [R7RS Large]
mapping [R7RS Large]
generator [R7RS Large]
vector [R7RS Large]

### Summary of clearly plural names

arithmetic fixnums [R6RS]
arithmetic flonums [R6RS]
bytevectors [R6RS]
conditions [R6RS]
enums [R6RS]
exceptions [R6RS]
files [R6RS]
hashtables [R6RS]
io ports [R6RS]
lists [R6RS]
mutable-pairs [R6RS]
mutable-strings [R6RS]
programs [R6RS]
records inspection [R6RS]
records procedural [R6RS]
records syntactic [R6RS]

lists [SRFI 1]
char-sets [SRFI 14]
streams [SRFI 41]
list-queues [SRFI 117]
hashtables [SRFI 125]
lazy-sequences [SRFI 127]
vectors [SRFI 133]
fixnums [SRFI 143]
generators-and-accumulators [SRFI 158]

numeric-vectors [SRFI 4]
basic-string-ports [SRFI 6]
records [SRFI 9]
strings [SRFI 13]
multi-dimensional-arrays [SRFI 25]
random-bits [SRFI 27]
basic-format-strings [SRFI 28]
conditions [SRFI 35]
parameters [SRFI 39]
eager-comprehensions [SRFI 42]
vectors [SRFI 43]
collections [SRFI 44]
arrays [SRFI 47]
intermediate-format-strings [SRFI 48]
rest-values [SRFI 51]
records [SRFI 57]
vicinities [SRFI 59]
integer-bits [SRFI 60]
arrays [SRFI 63]
octet-vectors [SRFI 66]
compare-procedures [SRFI 67]
basic-hash-tables [SRFI 69]
blobs [SRFI 74]
os-environment-variables [SRFI 98]
records [SRFI 99]
r6rs-hashtables [SRFI 126]
comparators [SRFI 128]
string-cursors [SRFI 130]
records [SRFI 131]
strings [SRFI 152]
predicate-combiners [SRFI 156]