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

Re: the discussion so far

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.