Re: [Pharo-dev] [squeak-dev] Unicode Support
On 12/6/15, Levente Uzonyi <leves@caesar.elte.hu> wrote:
On Sat, 5 Dec 2015, Colin Putney wrote:
First, what's UTF-32? Second, we have the whole language tag thing that nobody else uses.
In Squeak, Strings use UTF-32 encoding[1]. It's straightforward to see for WideString, but ByteString is just a subset of WideString, so it uses the same encoding. We also use language tags, but that's a different story. Language tags make it possible to work around the problems introduced by the Han unification[2]. We shouldn't really use them for non-CJKV languages.
Finally, UTF-8 is a great encoding that certain kinds of applications really ought to use. Web apps, in particular, benefit from using UTF-8 so the don't have to decode and then re-encode strings coming in from the network. In DabbleDB we used UTF-8 encoded string in the image, and just ignored the fact that they were displayed incorrectly by inspectors. Having a proper UTF-8 string class would be useful.
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
This is not the case if you go for ropes https://github.com/KenDickey/Cuis-Smalltalk-Ropes
Levente
[1] https://en.wikipedia.org/wiki/UTF-32 [2] https://en.wikipedia.org/wiki/Han_unification
- Colin
On Dec 4, 2015, at 6:46 AM, Levente Uzonyi <leves@caesar.elte.hu> wrote:
Why would you want to have strings with UTF-8 or UTF-16 encoding in the image? What's wrong with the current UTF-32 representation?
Levente
On Fri, 4 Dec 2015, EuanM wrote:
I'm currently groping my way to seeing how feature-complete our Unicode support is. I am doing this to establish what still needs to be done to provide full Unicode support.
This seems to me to be an area where it would be best to write it once, and then have the same codebase incorporated into the Smalltalks that most share a common ancestry.
I am keen to get: equality-testing for strings; sortability for strings which have ligatures and diacritic characters; and correct round-tripping of data.
Call to action: ==========
If you have comments on these proposals - such as "but we already have that facility" or "the reason we do not have these facilities is because they are dog-slow" - please let me know them.
If you would like to help out, please let me know.
If you have Unicode experience and expertise, and would like to be, or would be willing to be, in the 'council of experts' for this project, please let me know.
If you have comments or ideas on anything mentioned in this email
In the first instance, the initiative's website will be: http://smalltalk.uk.to/unicode.html
I have created a SqueakSource.com project called UnicodeSupport
I want to avoid re-inventing any facilities which already exist. Except where they prevent us reaching the goals of: - sortable UTF8 strings - sortable UTF16 strings - equivalence testing of 2 UTF8 strings - equivalence testing of 2 UTF16 strings - round-tripping UTF8 strings through Smalltalk - roundtripping UTF16 strings through Smalltalk. As I understand it, we have limited Unicode support atm.
Current state of play =============== ByteString gets converted to WideString when need is automagically detected.
Is there anything else that currently exists?
Definition of Terms ============== A quick definition of terms before I go any further:
Standard terms from the Unicode standard =============================== a compatibility character : an additional encoding of a *normal* character, for compatibility and round-trip conversion purposes. For instance, a 1-byte encoding of a Latin character with a diacritic.
Made-up terms ============ a convenience codepoint : a single codepoint which represents an item that is also encoded as a string of codepoints.
(I tend to use the terms compatibility character and compatibility codepoint interchangably. The standard only refers to them as compatibility characters. However, the standard is determined to emphasise that characters are abstract and that codepoints are concrete. So I think it is often more useful and productive to think of compatibility or convenience codepoints).
a composed character : a character made up of several codepoints
Unicode encoding explained ===================== A convenience codepoint can therefore be thought of as a code point used for a character which also has a composed form.
The way Unicode works is that sometimes you can encode a character in one byte, sometimes not. Sometimes you can encode it in two bytes, sometimes not.
You can therefore have a long stream of ASCII which is single-byte Unicode. If there is an occasional Cyrillic or Greek character in the stream, it would be represented either by a compatibility character or by a multi-byte combination.
Using compatibility characters can prevent proper sorting and equivalence testing.
Using "pure" Unicode, ie. "normal encodings", can cause compatibility and round-tripping probelms. Although avoiding them can *also* cause compatibility issues and round-tripping problems.
Currently my thinking is:
a Utf8String class an Ordered collection, with 1 byte characters as the modal element, but short arrays of wider strings where necessary a Utf16String class an Ordered collection, with 2 byte characters as the modal element, but short arrays of wider strings beginning with a 2-byte endianness indicator.
Utf8Strings sometimes need to be sortable, and sometimes need to be compatible.
So my thinking is that Utf8String will contain convenience codepoints, for round-tripping. And where there are multiple convenience codepoints for a character, that it standardises on one.
And that there is a Utf8SortableString which uses *only* normal characters.
We then need methods to convert between the two.
aUtf8String asUtf8SortableString
and
aUtf8SortableString asUtf8String
Sort orders are culture and context dependent - Sweden and Germany have different sort orders for the same diacritic-ed characters. Some countries have one order in general usage, and another for specific usages, such as phone directories (e.g. UK and France)
Similarly for Utf16 : Utf16String and Utf16SortableString and conversion methods
A list of sorted words would be a SortedCollection, and there could be pre-prepared sortBlocks for them, e.g. frPhoneBookOrder, deOrder, seOrder, ukOrder, etc
along the lines of aListOfWords := SortedCollection sortBlock: deOrder
If a word is either a Utf8SortableString, or a well-formed Utf8String, then we can perform equivalence testing on them trivially.
To make sure a Utf8String is well formed, we would need to have a way of cleaning up any convenience codepoints which were valid, but which were for a character which has multiple equally-valid alternative convenience codepoints, and for which the string currently had the "wrong" convenience codepoint. (i.e for any character with valid alternative convenience codepoints, we would choose one to be in the well-formed Utf8String, and we would need a method for cleaning the alternative convenience codepoints out of the string, and replacing them with the chosen approved convenience codepoint.
aUtf8String cleanUtf8String
With WideString, a lot of the issues disappear - except round-tripping(although I'm sure I have seen something recently about 4-byte strings that also have an additional bit. Which would make some Unicode characters 5-bytes long.)
(I'm starting to zone out now - if I've overlooked anything - obvious, subtle, or somewhere in between, please let me know)
Cheers, Euan
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup) I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have. I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do. So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't. Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless. Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings. -Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess. Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
BTW, does anyone know of any programming language that did go that way or has a library that directly implements 'storing all strings as utf-8' ?
On 06 Dec 2015, at 18:45, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess.
Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
On 06/12/2015 19:08, Sven Van Caekenberghe wrote:
BTW, does anyone know of any programming language that did go that way or has a library that directly implements 'storing all strings as utf-8' ? Java is UTF-16
Python3, Go and Swift are UTF-8 as I suspect are other new languages not based on .Net or the JVM Mark
On 06 Dec 2015, at 18:45, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess.
Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
-- Mark
Ah yes, Go is a good example, thanks Mark. After reading these two blog articles: http://blog.golang.org/strings http://blog.golang.org/normalization And especially after looking through their libraries/APIs, the conclusion is: this is not simple. I am also not so sure they managed to offer such an API to their users so that it is easier for them not to make mistakes (given that they leave a lot of things 'open'). Note that they also say that "In practice, 99.98% of the web's HTML page content is in NFC form (not counting markup, in which case it would be more)." I must say that I have never come across anything else myself, let alone something that gave a problem, but that probably depends on the situation. @Max: you seem to suggest that you do see non-normalised unicode, where does it come from, how does it happen ? Sven
On 06 Dec 2015, at 20:27, Mark Bestley <st@bestley.co.uk> wrote:
On 06/12/2015 19:08, Sven Van Caekenberghe wrote:
BTW, does anyone know of any programming language that did go that way or has a library that directly implements 'storing all strings as utf-8' ? Java is UTF-16
Python3, Go and Swift are UTF-8 as I suspect are other new languages not based on .Net or the JVM
Mark
On 06 Dec 2015, at 18:45, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess.
Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
-- Mark
On 06 Dec 2015, at 22:07, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Ah yes, Go is a good example, thanks Mark.
After reading these two blog articles:
http://blog.golang.org/strings http://blog.golang.org/normalization
And especially after looking through their libraries/APIs, the conclusion is: this is not simple.
I am also not so sure they managed to offer such an API to their users so that it is easier for them not to make mistakes (given that they leave a lot of things 'open').
Note that they also say that "In practice, 99.98% of the web's HTML page content is in NFC form (not counting markup, in which case it would be more)." I must say that I have never come across anything else myself, let alone something that gave a problem, but that probably depends on the situation.
@Max: you seem to suggest that you do see non-normalised unicode, where does it come from, how does it happen ?
We do have problems occasionally with pasted strings that come, at least in the cases weâve been able to determine, from PDF documents (pasted into a web browser). Some generators apparently donât normalise UTF-8 and then we end up with characters (in our case those are mostly umlauts) that are made up of two distinct characters (e.g. âuâ + âcombining diaeresisâ). Max
Sven
On 06 Dec 2015, at 20:27, Mark Bestley <st@bestley.co.uk> wrote:
On 06/12/2015 19:08, Sven Van Caekenberghe wrote:
BTW, does anyone know of any programming language that did go that way or has a library that directly implements 'storing all strings as utf-8' ? Java is UTF-16
Python3, Go and Swift are UTF-8 as I suspect are other new languages not based on .Net or the JVM
Mark
On 06 Dec 2015, at 18:45, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess.
Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
-- Mark
As far as I know Dart also uses utf-16 for Strings On Dec 6, 2015 16:33, "Mark Bestley" <st@bestley.co.uk> wrote:
On 06/12/2015 19:08, Sven Van Caekenberghe wrote:
BTW, does anyone know of any programming language that did go that way or has a library that directly implements 'storing all strings as utf-8' ?
Java is UTF-16
Python3, Go and Swift are UTF-8 as I suspect are other new languages not based on .Net or the JVM
Mark
On 06 Dec 2015, at 18:45, Sven Van Caekenberghe <sven@stfx.eu> wrote:
Well written, Todd. I agree, the loss of indexing might not be that big a problem in practice. The only way to find out it to try an experiment I guess.
Sven
On 06 Dec 2015, at 17:37, Todd Blanchard <tblanchard@mac.com> wrote:
(Resent because of bounce notification (email handling in osx is really beginning to annoy me). Sorry if its a dup)
I used to worry a lot about strings being indexable. And then I eventually let go of that and realized that it isn't a particularly important property for them to have.
I think you will find that UTF8 is generally the most convenient for a lot of things but its a bit like light in that you treat it alternately as a wave or particle depending on what you are trying to do.
So goes strings - they can be treated alternately as streams or byte arrays (not character arrays - stop thinking in characters). In practice, this tends to not be a problem since a lot of the times when you want to replace a character or pick out the nth one you are doing something very computerish and the characters you are working with are the single byte (ASCII legacy) variety. You generally know when you can get away with that and when you can't.
Otherwise you are most likely doing things that are best dealt with in a streaming paradigm. For most computation, you come to realize you don't generally care how many characters but how much space (bytes) you need to store your chunk of text. Collation is tricky and complicated in unicode in general but it isn't any worse in UTF8 than any other encoding. You are still going to scan each sortable item from front to back to determine its order, regardless.
Most of the outside world has settled on UTF8 and any ASCII file is already UTF8 - which is why it ends up being so convenient. Most of our old text handling infrastructure can still handle UTF8 while it tends to choke on wider encodings.
-Todd Blanchard
On Dec 6, 2015, at 07:23, H. Hirzel <hannes.hirzel@gmail.com> wrote:
We do the same thing, but that doesn't mean it's a good idea to create
a new String-like class having its content encoded in UTF-8, because UTF-8-encoded strings can't be modified like regular strings. While it would be possible to implement all operations, such implementation would become the next SortedCollection (bad performance due to misuse).
-- Mark
participants (6)
-
Gabriel Cotelli -
H. Hirzel -
Mark Bestley -
Max Leske -
Sven Van Caekenberghe -
Todd Blanchard