reiver
/
go-utf8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: reiver:161bc9a4ec5a9851ab847bd5b56cce61b9eb6545
Branches Tags
reiver:master
..
compare: reiver:2129573f6de09887658fc8c5b05937c8310655da
Branches Tags
reiver:master

No commits in common. "161bc9a4ec5a9851ab847bd5b56cce61b9eb6545" and "2129573f6de09887658fc8c5b05937c8310655da" have entirely different histories.
161bc9a4ec ... 2129573f6d

14 changed files with 153 additions and 155 deletions
Show Stats Expand all files Collapse all files

76
README.md
View File

@ -1,8 +1,7 @@
# go-utf8
Package **utf8** implements encoding and decoding of UTF-8, for the Go programming language.
Package **utf8** provides tools for working with Unicode encoded as UTF-8, for the Go programming language.
This package is meant to be a replacement for Go's built-in `"unicode/utf8"` package.
## Documention
@ -10,9 +9,8 @@ Online documentation, which includes examples, can be found at: http://godoc.org
[![GoDoc](https://godoc.org/github.com/reiver/go-utf8?status.svg)](https://godoc.org/github.com/reiver/go-utf8)
## Reading a Single UTF-8 Character
This is the simplest way of reading a single UTF-8 character.
## Example
```go
var reader io.Reader
@ -21,9 +19,6 @@ var reader io.Reader
r, n, err := utf8.ReadRune(reader)
```
## Write a Single UTF-8 Character
This is the simplest way of writing a single UTF-8 character.
```go
var writer io.Writer
@ -36,31 +31,25 @@ var r rune
n, err := utf8.WriteRune(w, r)
```
## io.RuneReader
This is how you can create an `io.RuneReader`:
```go
var reader io.Reader
// ...
var runeReader io.RuneReader = utf8.RuneReaderWrap(reader)
runeReader := utf8.NewRuneReader(reader)
// ...
r, n, err := runeReader.ReadRune()
```
## io.RuneScanner
This is how you can create an `io.RuneScanner`:
```go
var reader io.Reader
// ...
var runeScanner io.RuneScanner := utf8.RuneScannerWrap(reader)
runeScanner := utf8.NewRuneScanner(reader)
// ...
@ -70,60 +59,3 @@ r, n, err := runeScanner.ReadRune()
err = runeScanner.UnreadRune()
```
## UTF-8
UTF-8 is a variable length encoding of Unicode.
An encoding of a single Unicode code point can be from 1 to 4 bytes longs.
Some examples of UTF-8 encoding of Unicode code points are:
```
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ UTF-8 encoding ┃ ┃ ┃ ┃ ┃ ┃
┣━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┫ ┃ ┃ ┃ ┃ ┃
┃ byte 1 ┋ byte 2 ┋ byte 3 ┋ byte 4 ┃ value ┃ code point ┃ decimal ┃ binary ┃ name ┃
┡━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ 0b0,1000001 ┊ ┊ ┊ │ A │ U+0041 │ 65 │ 0b0000,0000,0100,0001 │ LATIN CAPITAL LETTER A │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b0,1110010 ┊ ┊ ┊ │ r │ U+0072 │ 114 │ 0b0000,0000,0111,0010 │ LATIN SMALL LETTER R │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b110,00010 ┊ 0b10,100001 ┊ ┊ │ ¡ │ U+00A1 │ 161 │ 0b0000,0000,1010,0001 │ INVERTED EXCLAMATION MARK │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b110,11011 ┊ 0b10,110101 ┊ ┊ │ ۵ │ U+06F5 │ 1781 │ 0b0000,0110,1111,0101 │ EXTENDED ARABIC-INDIC DIGIT FIVE │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b1110,0010 ┊ 0b10,000000 ┊ 0b10,110001 ┊ │ ‱ │ U+2031 │ 8241 │ 0b0010,0000,0011,0001 │ PER TEN THOUSAND SIGN │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b1110,0010 ┊ 0b10,001001 ┊ 0b10,100001 ┊ │ ≡ │ U+2261 │ 8801 │ 0b0010,0010,0110,0001 │ IDENTICAL TO │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b11110,000 ┊ 0b10,010000 ┊ 0b10,001111 ┊ 0b10,010101 │ 𐏕 │ U+000103D5 │ 66517 │ 0b0001,0000,0011,1101,0101 │ OLD PERSIAN NUMBER HUNDRED │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b11110,000 ┊ 0b10,011111 ┊ 0b10,011001 ┊ 0b10,000010 │ 🙂 │ U+0001F642 │ 128578 │ 0b0001,1111,0110,0100,0010 │ SLIGHTLY SMILING FACE │
└─────────────┴─────────────┴─────────────┴─────────────┴───────┴────────────┴─────────┴────────────────────────────┴──────────────────────────────────┘
```
## UTF-8 Versus ASCII
UTF-8 was (partially) designed to be backwards compatible with 7-bit ASCII.
Thus, all 7-bit ASCII is valid UTF-8.
## UTF-8 Encoding
Since, at least as of 2003, Unicode fits into 21 bits, and thus UTF-8 was designed to support at most 21 bits of information.
This is done as described in the following table:
```
┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓
┃ # of bytes ┃ # bits for code point ┃ 1st code point ┃ last code point ┃ byte 1 ┃ byte 2 ┃ byte 3 ┃ byte 4 ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩
│ 1 │ 7 │ U+000000 │ U+00007F │ 0xxxxxxx │ │ │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 2 │ 11 │ U+000080 │ U+0007FF │ 110xxxxx │ 10xxxxxx │ │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 3 │ 16 │ U+000800 │ U+00FFFF │ 1110xxxx │ 10xxxxxx │ 10xxxxxx │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 4 │ 21 │ U+010000 │ U+10FFFF │ 11110xxx │ 10xxxxxx │ 10xxxxxx │ 10xxxxxx │
└────────────┴───────────────────────┴────────────────┴──────────────────┴──────────┴──────────┴──────────┴──────────┘
```

123
doc.go 100644
View File

@ -0,0 +1,123 @@
/*
Package utf8 provides tools for working with Unicode encoded as UTF-8.
Example
var reader io.Reader
// ...
r, n, err := utf8.ReadRune(reader)
Example
var writer io.Writer
// ...
var r rune
// ...
n, err := utf8.WriteRune(w, r)
Example
var reader io.Reader
// ...
runeReader := utf8.NewRuneReader(reader)
// ..
r, n, err := runeReader.ReadRune()
Example
var reader io.Reader
// ...
runeScanner := utf8.NewRuneScanner(reader)
// ...
r, n, err := runeScanner.ReadRune()
// ...
err = runeScanner.UnreadRune()
Example
var r rune
// ...
s := utfs.FormatBinary(r)
fmt.Printf("%q encoded in UTF-8 as binary is %s \n", r, s)
UTF-8
UTF-8 is a variable length encoding of Unicode. An encoding of a single Unicode code point can be from 1 to 4 bytes longs.
Some examples of UTF-8 encoding of Unicode code points are:
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ UTF-8 encoding ┃ ┃ ┃ ┃ ┃ ┃
┣━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━┫ ┃ ┃ ┃ ┃ ┃
┃ byte 1 ┋ byte 2 ┋ byte 3 ┋ byte 4 ┃ value ┃ code point ┃ decimal ┃ binary ┃ name ┃
┡━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ 0b0,1000001 ┊ ┊ ┊ │ A │ U+0041 │ 65 │ 0b0000,0000,0100,0001 │ LATIN CAPITAL LETTER A │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b0,1110010 ┊ ┊ ┊ │ r │ U+0072 │ 114 │ 0b0000,0000,0111,0010 │ LATIN SMALL LETTER R │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b110,00010 ┊ 0b10,100001 ┊ ┊ │ ¡ │ U+00A1 │ 161 │ 0b0000,0000,1010,0001 │ INVERTED EXCLAMATION MARK │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b110,11011 ┊ 0b10,110101 ┊ ┊ │ ۵ │ U+06F5 │ 1781 │ 0b0000,0110,1111,0101 │ EXTENDED ARABIC-INDIC DIGIT FIVE │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b1110,0010 ┊ 0b10,000000 ┊ 0b10,110001 ┊ │ ‱ │ U+2031 │ 8241 │ 0b0010,0000,0011,0001 │ PER TEN THOUSAND SIGN │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b1110,0010 ┊ 0b10,001001 ┊ 0b10,100001 ┊ │ ≡ │ U+2261 │ 8801 │ 0b0010,0010,0110,0001 │ IDENTICAL TO │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b11110,000 ┊ 0b10,010000 ┊ 0b10,001111 ┊ 0b10,010101 │ 𐏕 │ U+000103D5 │ 66517 │ 0b0001,0000,0011,1101,0101 │ OLD PERSIAN NUMBER HUNDRED │
├─────────────┼─────────────┼─────────────┼─────────────┼───────┼────────────┼─────────┼────────────────────────────┼──────────────────────────────────┤
│ 0b11110,000 ┊ 0b10,011111 ┊ 0b10,011001 ┊ 0b10,000010 │ 🙂 │ U+0001F642 │ 128578 │ 0b0001,1111,0110,0100,0010 │ SLIGHTLY SMILING FACE │
└─────────────┴─────────────┴─────────────┴─────────────┴───────┴────────────┴─────────┴────────────────────────────┴──────────────────────────────────┘
UTF-8 Versus ASCII
UTF-8 was (partially) designed to be backwards compatible with 7-bit ASCII.
Thus, all 7-bit ASCII is valid UTF-8.
UTF-8 Encoding
Since, at least as of 2003, Unicode fit into 21 bits, UTF-8 was designed to support at most 21 bits of information.
This is done as described in the following table:
┏━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━┓
┃ # of bytes ┃ # bits for code point ┃ 1st code point ┃ last code point ┃ byte 1 ┃ byte 2 ┃ byte 3 ┃ byte 4 ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━┩
│ 1 │ 7 │ U+000000 │ U+00007F │ 0xxxxxxx │ │ │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 2 │ 11 │ U+000080 │ U+0007FF │ 110xxxxx │ 10xxxxxx │ │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 3 │ 16 │ U+000800 │ U+00FFFF │ 1110xxxx │ 10xxxxxx │ 10xxxxxx │ │
├────────────┼───────────────────────┼────────────────┼──────────────────┼──────────┼──────────┼──────────┼──────────┤
│ 4 │ 21 │ U+010000 │ U+10FFFF │ 11110xxx │ 10xxxxxx │ 10xxxxxx │ 10xxxxxx │
└────────────┴───────────────────────┴────────────────┴──────────────────┴──────────┴──────────┴──────────┴──────────┘
*/
package utf8

16
invalidutf8.go
View File

@ -1,21 +1,5 @@
package utf8
// InvalidUTF8Complainer is a type of error that could be returned
// by the utf8.ReadRune() function,
// by the utf8.RuneReader.ReadRune() method, and
// by the utf8.RuneScanner.ReadRune() method.
//
// Here is how one might use this type:
//
// r, n, err := utf8.ReadRune(reader)
// if nil != err {
// switch {
// case utf8.InvalidUTF8Complainer:
// //@TODO
// default:
// //@TODO
// }
// }
type InvalidUTF8Complainer interface {
error
InvalidUTF8Complainer()

12
runelength.go → len.go
View File

@ -1,31 +1,31 @@
package utf8
// RuneLength returns the number of bytes in a UTF-8 encoding of this Unicode code point.
// Len returns the number of bytes in a UTF-8 encoding of this Unicode code point.
//
// Example
//
// length := utf8.RuneLength('A')
// length := utf8.Len('A')
//
// // length == 1
//
// Example
//
// length := utf8.RuneLength('r')
// length := utf8.Len('r')
//
// // length == 1
//
// Example
//
// length := utf8.RuneLength('¡')
// length := utf8.Len('¡')
//
// // length == 2
//
// Example
//
// length := utf8.RuneLength('۵')
// length := utf8.Len('۵')
//
// // length == 2
func RuneLength(r rune) int {
func Len(r rune) int {
switch {
case 127 >= r:

4
runelength_test.go → len_test.go
View File

@ -4,7 +4,7 @@ import (
"testing"
)
func TestRuneLength(t *testing.T) {
func TestLen(t *testing.T) {
tests := []struct{
Datum rune
@ -123,7 +123,7 @@ func TestRuneLength(t *testing.T) {
for testNumber, test := range tests {
actual := RuneLength(test.Datum)
actual := Len(test.Datum)
if expected := test.Expected; expected != actual {
t.Errorf("For test #%d, expected %d, but actually got %d.", testNumber, expected, actual)
continue

24
readrune.go
View File

@ -7,30 +7,6 @@ import (
// ReadRune reads a single UTF-8 encoded Unicode character from an io.Reader,
// and returns the Unicode character (as a Go rune) and the number of bytes read.
//
// If ‘reader’ is nil then ReaderRune will return an error that matches utf8.NilReaderComplainer.
//
// Example
//
// Here is an example usage of ReadRune:
//
// r, n, err := utf8.ReadRune(reader)
// if nil != err {
//
// switch err.(type) {
// case utf8.NilReaderComplainer:
// //@TODO
// case utf8.InvalidUTF8Complainer:
// //@TODO
// default:
// //TODO
// }
// }
// if utf8.RuneError == r {
// //@TODO
// }
//
// Number Of Bytes
//
// Note that a single UTF-8 encoded Unicode character could be more than one byte.
//
// For example, the Unicode "≡" (IDENTICAL TO) character gets encoded using 3 bytes under UTF-8.

2
readrune_test.go
View File

@ -601,7 +601,7 @@ func TestReadRunes(t *testing.T) {
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))
continue TestLoop
}
if expected, actual := RuneLength(test.Expected[runeNumber]), actualInt; expected != actual {
if expected, actual := Len(test.Expected[runeNumber]), actualInt; expected != actual {
t.Errorf("For test #%d and rune #%d, expected %d, but actually got %d.", testNumber, runeNumber, expected, actual)
t.Errorf("\tEXPECTED: %s", FormatBinary(test.Expected[runeNumber]))
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))

4
runereader.go
View File

@ -9,8 +9,8 @@ type RuneReader struct {
reader io.Reader
}
func RuneReaderWrap(reader io.Reader) RuneReader {
return RuneReader{
func NewRuneReader(reader io.Reader) *RuneReader {
return &RuneReader{
reader: reader,
}
}

6
runereader_test.go
View File

@ -295,7 +295,7 @@ func TestRuneReader(t *testing.T) {
for testNumber, test := range tests {
runeReader := RuneReaderWrap(test.Reader)
runeReader := NewRuneReader(test.Reader)
actualRune, actualInt, err := runeReader.ReadRune()
if nil != err {
@ -563,7 +563,7 @@ func TestRuneReaders(t *testing.T) {
var runeNumber int
for {
runeReader := RuneReaderWrap(test.Reader)
runeReader := NewRuneReader(test.Reader)
actualRune, actualInt, err := runeReader.ReadRune()
if nil != err && io.EOF != err {
@ -585,7 +585,7 @@ func TestRuneReaders(t *testing.T) {
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))
continue TestLoop
}
if expected, actual := RuneLength(test.Expected[runeNumber]), actualInt; expected != actual {
if expected, actual := Len(test.Expected[runeNumber]), actualInt; expected != actual {
t.Errorf("For test #%d and rune #%d, expected %d, but actually got %d.", testNumber, runeNumber, expected, actual)
t.Errorf("\tEXPECTED: %s", FormatBinary(test.Expected[runeNumber]))
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))

4
runescanner.go
View File

@ -15,8 +15,8 @@ type RuneScanner struct {
peeked bool
}
func RuneScannerWrap(reader io.Reader) RuneScanner {
return RuneScanner{
func NewRuneScanner(reader io.Reader) *RuneScanner {
return &RuneScanner{
reader: reader,
}
}

8
runescanner_test.go
View File

@ -295,7 +295,7 @@ func TestRuneScanner(t *testing.T) {
for testNumber, test := range tests {
runeReader := RuneScannerWrap(test.Reader)
runeReader := NewRuneScanner(test.Reader)
actualRune, actualInt, err := runeReader.ReadRune()
if nil != err {
@ -563,7 +563,7 @@ func TestRuneScanners(t *testing.T) {
var runeNumber int
for {
runeReader := RuneScannerWrap(test.Reader)
runeReader := NewRuneScanner(test.Reader)
actualRune, actualInt, err := runeReader.ReadRune()
if nil != err && io.EOF != err {
@ -585,7 +585,7 @@ func TestRuneScanners(t *testing.T) {
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))
continue TestLoop
}
if expected, actual := RuneLength(test.Expected[runeNumber]), actualInt; expected != actual {
if expected, actual := Len(test.Expected[runeNumber]), actualInt; expected != actual {
t.Errorf("For test #%d and rune #%d, expected %d, but actually got %d.", testNumber, runeNumber, expected, actual)
t.Errorf("\tEXPECTED: %s", FormatBinary(test.Expected[runeNumber]))
t.Errorf("\tACTUAL: %s", FormatBinary(actualRune))
@ -616,7 +616,7 @@ func TestRuneScannerUnread(t *testing.T) {
TestLoop: for testNumber, test := range tests {
runeScanner := RuneScannerWrap(test.Reader)
runeScanner := NewRuneScanner(test.Reader)
var readCount int
for instructionNumber, instruction := range test.Instructions {

6
runewriter.go
View File

@ -9,9 +9,9 @@ type RuneWriter struct {
writer io.Writer
}
// RuneWriterWrap wraps an io.Writer and returns a RuneWriter.
func RuneWriterWrap(writer io.Writer) RuneWriter {
return RuneWriter{
// NewRuneWriter wraps an io.Writer and returns a RuneWriter.
func NewRuneWriter(writer io.Writer) *RuneWriter {
return &RuneWriter{
writer: writer,
}
}

4
runewriter_test.go
View File

@ -58,7 +58,7 @@ func TestRuneWriter(t *testing.T) {
var buffer strings.Builder
var total int
runeWriter := utf8.RuneWriterWrap(&buffer)
runeWriter := utf8.NewRuneWriter(&buffer)
for runeNumber, r := range test.Runes {
@ -73,7 +73,7 @@ func TestRuneWriter(t *testing.T) {
continue TestLoop
}
if expected, actual := n, utf8.RuneLength(r); expected != actual {
if expected, actual := n, utf8.Len(r); expected != actual {
t.Errorf("For test #%d and rune #%d, expected a certain number of bytes to be written, but actually wasn't.", testNumber, runeNumber)
for i, rr := range test.Runes {
t.Logf("\t[%d] %q (%d)", i, string(rr), rr)

19
writerune.go
View File

@ -5,24 +5,6 @@ import (
)
// WriteRune writes a single UTF-8 encoded Unicode character and returns the number of bytes written.
//
// If ‘writer’ is nil then WriteRune will return an error that matches utf8.NilWriterComplainer.
//
// Example
//
// Here is an example usage of WriteRune:
//
// n, err := utf8.WriteRune(writer, r)
// if nil != err {
//
// switch err.(type) {
// case utf8.NilWriterComplainer:
// //@TODO
// default:
// //TODO
// }
//
// }
func WriteRune(writer io.Writer, r rune) (int, error) {
if nil == writer {
return 0, errNilWriter
@ -74,4 +56,5 @@ func WriteRune(writer io.Writer, r rune) (int, error) {
default:
return 0, errInternalError
}
}