code review 4526095: unicode: add the first few property tests for printing.

src/pkg/unicode/letter.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Package unicode provides data and functions to test some properties of
 // Unicode code points.
 package unicode
 
 const (
         MaxRune         = 0x10FFFF // Maximum valid Unicode code point.
@@ skipping 128 matching lines @@
         if len(r16) > 0 && rune <= int(r16[len(r16)-1].Hi) {
                 return is16(r16, uint16(rune))
         }
         r32 := rangeTab.R32
         if len(r32) > 0 && rune >= int(r32[0].Lo) {
                 return is32(r32, uint32(rune))
         }
         return false
 }
 
 // IsUpper reports whether the rune is an upper case letter.

[rsc, 2011/06/03 05:29:30]

is the plan to use the table for these too?

 func IsUpper(rune int) bool {
         if rune < 0x80 { // quick ASCII check
                 return 'A' <= rune && rune <= 'Z'
         }
         return Is(Upper, rune)
 }
 
 // IsLower reports whether the rune is a lower case letter.
 func IsLower(rune int) bool {
         if rune < 0x80 { // quick ASCII check
                 return 'a' <= rune && rune <= 'z'
         }
         return Is(Lower, rune)
 }
 
 // IsTitle reports whether the rune is a title case letter.
 func IsTitle(rune int) bool {
         if rune < 0x80 { // quick ASCII check
                 return false
         }
         return Is(Title, rune)
 }
 
-// IsLetter reports whether the rune is a letter.
-func IsLetter(rune int) bool {
-        if rune < 0x80 { // quick ASCII check
-                rune &^= 'a' - 'A'
-                return 'A' <= rune && rune <= 'Z'
-        }
-        return Is(Letter, rune)
-}
-
-// IsSpace reports whether the rune is a white space character.
-func IsSpace(rune int) bool {
-        if rune <= 0xFF { // quick Latin-1 check
-                switch rune {
-                case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0:
-                        return true
-                }
-                return false
-        }
-        return Is(White_Space, rune)
-}
-
 // to maps the rune using the specified case mapping.
 func to(_case int, rune int, caseRange []CaseRange) int {
         if _case < 0 || MaxCase <= _case {
                 return ReplacementChar // as reasonable an error as any
         }
         // binary search over ranges
         lo := 0
         hi := len(caseRange)
         for lo < hi {
                 m := lo + (hi-lo)/2
@@ skipping 81 matching lines @@
 }
 
 // ToLower maps the rune to lower case giving priority to the special mapping.
 func (special SpecialCase) ToLower(rune int) int {
         r := to(LowerCase, rune, []CaseRange(special))
         if r == rune {
                 r = ToLower(rune)
         }
         return r
 }