Add single-character toUpper/toLower/toFold to tango.text.Unicode

there's this problem where the upper- or lower-case of a character can actually be an array of them, instead of just one. So there's still that to deal with ...

Ooh, scary. Course, dchar > dchar isn't an issue. But maybe for the others, you could pass in a wchar[2] or char[4] and it'd return a slice.

for uppercase of a single dchar, the result can be multiple dchars. Weird, I know :)

ping Peter ... hope the ticket notification is working again

Replying to kris: Unicode has actually two kinds of mapping the "complete" and the "simple" I could add methods for simple mapping, too.

Then a

   dchar toUpper(dchar ch);

would be possible.

I'll look into it.

I will add simpleToUpper simpleToLower and simpleToFold functions that use the simple Unicode Mapping that doesn't change the size.

I'll try to fix it in time for the 99.4 release. Although I cant promise

I've implemented this, but I'm wondering what your thoughts are for what the simpleTo* functions should do in the case that the "full" mapping is more or less than 1 character. In these cases I have the functions simply return the original character. If the full mapping is exactly 1 character, or if there is only a simple mapping, it returns that character. I suppose this is fine, since Unicode does allow "simple" mappings as a non-error case, or it seems to anyway. I feel like having these functions possibly throw an exception would be overkill, since they'd probably be used for cases where correctness is not important anyway (i.e. trying not to allocate anything on the heap).

Hai Jarrett - you have these functions for perusal?

I believe I doooo somewhere. I think they're on my desktop. I may have nuked them though because it didn't look like this was going anywhere, but if I did, they're trivial to reimplement.

It appears that your comment slipped between a few set of chairs, sorry - we really should complete this set of functionality.

Here is a very simple wrapper for toLower, maybe it's an option?

dchar toSimpleLower(dchar c)
{
	dchar[1] ca = c;
	dchar[8] buf = void; //should be enough, no?
	return toLower(ca, buf)[0];
}

I've added a patch as suggestion for an implementation. Not completely sure if it's correct.

thanks doob and mwarning. The tricky thing about these conversions is that sometimes the result will be two (perhaps more?) characters instead. That's why these functions didn't exist to begin with, though they're certainly handy for those cases where the output is a single T rather than a T[]

Any ideas how to address this dilemma? Should we have some "simple" char converters such as those in the patch, and maybe add the complex cases later which return a T[] instead?

(I'm not very keen on special-cases, fwiw)

I think we can have simple char converters. There aren't that many special cases, this link lists all special cases (if I've understood everything correctly) http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt. I counted to 119 special cases.

perhaps the api should be something like:

bool toLower (T src, ref dchar dst)

where the return value indicates whether 'src' is a special-case and populates 'dst' when it's not special? This would at least indicate to the caller that a T[] toLower() is required at that point?

or a set of methods?

dchar toLower(T src);                      // returns dchar.init for special-char
dchar toLower(T src, ref bool isSpecial);  // sets a flag for special-char
dchar[] toLowerEx(T src);                  // returns special-char expansion

A set of methods sounds like a good idea. I like to have a simple function that doesn't require one to add an extra parameter. Is it better to return dchar.init than the original char (src)?

Replying to doob:

Is it better to return dchar.init than the original char (src)?

At least returning dchar.init would indicate something is awry and, in this case, likely means toLowerEx() is required?

Actually I don't know that would be the best, I'm leaving that decision for you.