I'm having lots of fun, and was very drawn to the "simplicity" of the
syntax. I like the "it just works" mentality. To quote the first
paragraph of the various RnRS reports:

"Programming languages should be designed not by piling
feature on top of feature, but by removing the weaknesses
and restrictions that make additional features appear necessary."

Unfortunately, I am disturbed by a trend that I am seeing in the newer
revisions of scheme. Here is what I mean:

The most recent report defines lists and vectors. It defines for-each
and map to work with lists, and vector-for-each and vector-map to work
with maps. It defines length to work with lists, and vector-length to
work with vectors.

Why have separate forms for vectors? Wouldn't it be simpler just to
have for-each, map, and length know that they are working with vectors
and "do the right thing"? Since data is typed, that should be easy.

Also, you have "> = < >= <=" for numbers, string=?, string<=?, etc. for
strings, char=?, char<=? for chars, etc.. Couldn't these also be folded
into a single set of forms?

So my question is: Are others disturbed by this "explosion of seemingly
unnecessary clutter" as well, or perhaps am I missing some "big
picture" that makes this all OK?

Brian.

Interesting observations.  I have nowhere near your
experience and am just learning Scheme.  Take my comments
within that context.

BTW - I really love Scheme.  I get frustrated a lot by
having to check the type of an object before applying a
procedure.  Even more so when some comparison operations
fall over (error) while others don't but then don't give the
result I was expecting.
(equal? 1 "1") ; ==> #f which is what I would expect
(eq? 1 "1") ; ==> #f which is what I expect
(equal? 1 #\1) ;==> #f what I'd expect since the first
argument is a numeric value while the second is a character.
(eq? "1" "1"); ==> #f what I now know but not what I first
expected.  I mean, these are the same string literals.

I'm not clever enough to know what is sitting under the hood
but to me, something simple like = should specifically mean
are these two things the same (irrespective of what type
they are).

=, eq? char=?, string=?, equal? etc ... from a coding
perspective I want to see if the two objects are the same,
nothing else.

Perhaps there are very good reasons for having each of these
different procedures but it escapes me.  Further, it makes
it a bit more difficult to write "once use many code" - but
that may have more to do with my skill with Scheme than the
language itself.

I'm guessing the reason for these different 'flavours' of
comparison operations lies in the history of the language
itself.  Even though I am relatively unskilled, I can see
that I can create very diverse object types on the fly.
Still, simplicity and clarity have value.  Irrespective of
the objects in question I want to know if object x is the
same as object y.  Nothing more.  I'll deal with the
contents of the objects in the code.

I'm not there yet, but I can see that it should be possible
to roll your own comparison procedures that do what I want.
And I can see that if '=' was really '= ' across all
objects, it may break previously working code.

So to answer your question - I can't be disturbed by an
explosion of anything when I have no other experience of
this language other than what I have now.  However, I'd
personally prefer some simplification of basic procedures so
they do what I want them too.  And I can also see the
potential harm that a change like this may have on
previously stable code. So ... not an answer but an
awareness that if this was really something I wanted, then I
need to roll my own comparison operations.

Kindest regards,