[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: the discussion so far

This page is part of the web mail archives of SRFI 75 from before July 7th, 2015. The new archives for SRFI 75 contain all messages, not just those from before July 7th, 2015.

Matthew Flatt <mflatt@xxxxxxxxxxx> writes:

> The biggest piece of implicit feedback is that the SRFI does not really
> make the editors' goal clear. The goal is not to finally get strings
> "right", or even to be Unicode-compliant. The goal is simply to make
> Scheme programs more portable.

Can we at least not start specifying things that *preclude* people
from getting strings right?

If you don't want to get them right, fine, but PLEASE don't start
standardizing in a way which makes it *impossible* for so-inclined
sytesms to get it right.

> Keeping in mind that the goal is portability, the question with respect
> `char-upcase', `string-ci=?', etc. is not whether they do the "right"
> thing with respect to Unicode or natural language, but whether they are
> needed to write portable programs, whether they are so common that we
> should give them names to avoid gratuitous incompatibility, whether
> they are sufficiently simple to implement that we should impose them as
> a requirement on all Scheme systems, and whether the set of standardize
> operations is reasonably consistent.

We already know that char-upcase is not needed for portable programs.
We also know that if it is required, then the system using it *cannot*
implement Unicode correctly.

I understand if you don't care about implementing Unicode correctly.
Can you *please* then get out of the way of those of us who do?

> I am personally convinced (by this discussion and by past experience)
> that `string-ci=?' as defined in the SRFI is not what you really want
> under most circumstances. But it's often a good approximation. I think
> that Scheme needs at least an operation like `string-ci=?' for portable
> programs, something like it will exist in most implementations, it's
> simple to implement, and it's consistent with the rest of the proposal
> ---- so it still seems right to me to put it in the SRFI, despite its
> many flaws.

string-ci=? is harmless.  *String* based operations are ok;
*character* based ones are not.