{-# LANGUAGE NoImplicitPrelude #-}{-# LANGUAGE Trustworthy #-}{-# OPTIONS_HADDOCK not-home #-}------------------------------------------------------------------------------- |-- Module : GHC.Unicode-- Copyright : (c) The University of Glasgow, 2003-- License : see libraries/base/LICENSE---- Maintainer : cvs-ghc@haskell.org-- Stability : internal-- Portability : non-portable (GHC extensions)---- Implementations for the character predicates (isLower, isUpper, etc.)-- and the conversions (toUpper, toLower). The implementation uses-- libunicode on Unix systems if that is available.-------------------------------------------------------------------------------moduleGHC.Unicode(unicodeVersion ,GeneralCategory (..),generalCategory ,isAscii ,isLatin1 ,isControl ,isAsciiUpper ,isAsciiLower ,isPrint ,isSpace ,isUpper ,isUpperCase ,isLower ,isLowerCase ,isAlpha ,isDigit ,isOctDigit ,isHexDigit ,isAlphaNum ,isPunctuation ,isSymbol ,toUpper ,toLower ,toTitle )whereimportGHC.Base importGHC.Real importGHC.Enum (Enum (..),Bounded (..))importGHC.Ix (Ix (..))importGHC.Num importGHC.Unicode.Internal.Version importqualifiedGHC.Unicode.Internal.Char.DerivedCoreProperties asDCPimportqualifiedGHC.Unicode.Internal.Char.UnicodeData.GeneralCategory asGCimportqualifiedGHC.Unicode.Internal.Char.UnicodeData.SimpleLowerCaseMapping asCimportqualifiedGHC.Unicode.Internal.Char.UnicodeData.SimpleTitleCaseMapping asCimportqualifiedGHC.Unicode.Internal.Char.UnicodeData.SimpleUpperCaseMapping asC-- Data.Char.chr already imports this and we need to define a Show instance-- for GeneralCategoryimportGHC.Show (Show )-- $setup-- >>> import Prelude-- [NOTE] The constructors of 'GeneralCategory' must be in the same order they-- are listed in the Unicode Standard, because some functions-- (e.g. 'generalCategory') rely on the 'Enum' instance.-- | Unicode General Categories (column 2 of the UnicodeData table) in-- the order they are listed in the Unicode standard (the Unicode-- Character Database, in particular).---- ==== __Examples__---- Basic usage:---- >>> :t OtherLetter-- OtherLetter :: GeneralCategory---- 'Eq' instance:---- >>> UppercaseLetter == UppercaseLetter-- True-- >>> UppercaseLetter == LowercaseLetter-- False---- 'Ord' instance:---- >>> NonSpacingMark <= MathSymbol-- True---- 'Enum' instance:---- >>> enumFromTo ModifierLetter SpacingCombiningMark-- [ModifierLetter,OtherLetter,NonSpacingMark,SpacingCombiningMark]---- 'Text.Read.Read' instance:---- >>> read "DashPunctuation" :: GeneralCategory-- DashPunctuation-- >>> read "17" :: GeneralCategory-- *** Exception: Prelude.read: no parse---- 'Show' instance:---- >>> show EnclosingMark-- "EnclosingMark"---- 'Bounded' instance:---- >>> minBound :: GeneralCategory-- UppercaseLetter-- >>> maxBound :: GeneralCategory-- NotAssigned---- 'Ix' instance:---- >>> import Data.Ix ( index )-- >>> index (OtherLetter,Control) FinalQuote-- 12-- >>> index (OtherLetter,Control) Format-- *** Exception: Error in array index--dataGeneralCategory =UppercaseLetter -- ^ Lu: Letter, Uppercase|LowercaseLetter -- ^ Ll: Letter, Lowercase|TitlecaseLetter -- ^ Lt: Letter, Titlecase|ModifierLetter -- ^ Lm: Letter, Modifier|OtherLetter -- ^ Lo: Letter, Other|NonSpacingMark -- ^ Mn: Mark, Non-Spacing|SpacingCombiningMark -- ^ Mc: Mark, Spacing Combining|EnclosingMark -- ^ Me: Mark, Enclosing|DecimalNumber -- ^ Nd: Number, Decimal|LetterNumber -- ^ Nl: Number, Letter|OtherNumber -- ^ No: Number, Other|ConnectorPunctuation -- ^ Pc: Punctuation, Connector|DashPunctuation -- ^ Pd: Punctuation, Dash|OpenPunctuation -- ^ Ps: Punctuation, Open|ClosePunctuation -- ^ Pe: Punctuation, Close|InitialQuote -- ^ Pi: Punctuation, Initial quote|FinalQuote -- ^ Pf: Punctuation, Final quote|OtherPunctuation -- ^ Po: Punctuation, Other|MathSymbol -- ^ Sm: Symbol, Math|CurrencySymbol -- ^ Sc: Symbol, Currency|ModifierSymbol -- ^ Sk: Symbol, Modifier|OtherSymbol -- ^ So: Symbol, Other|Space -- ^ Zs: Separator, Space|LineSeparator -- ^ Zl: Separator, Line|ParagraphSeparator -- ^ Zp: Separator, Paragraph|Control -- ^ Cc: Other, Control|Format -- ^ Cf: Other, Format|Surrogate -- ^ Cs: Other, Surrogate|PrivateUse -- ^ Co: Other, Private Use|NotAssigned -- ^ Cn: Other, Not Assignedderiving(Int -> GeneralCategory -> ShowS [GeneralCategory] -> ShowS GeneralCategory -> String (Int -> GeneralCategory -> ShowS) -> (GeneralCategory -> String) -> ([GeneralCategory] -> ShowS) -> Show GeneralCategory forall a. (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a $cshowsPrec :: Int -> GeneralCategory -> ShowS showsPrec :: Int -> GeneralCategory -> ShowS $cshow :: GeneralCategory -> String show :: GeneralCategory -> String $cshowList :: [GeneralCategory] -> ShowS showList :: [GeneralCategory] -> ShowS Show -- ^ @since 2.01,GeneralCategory -> GeneralCategory -> Bool (GeneralCategory -> GeneralCategory -> Bool) -> (GeneralCategory -> GeneralCategory -> Bool) -> Eq GeneralCategory forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a $c== :: GeneralCategory -> GeneralCategory -> Bool == :: GeneralCategory -> GeneralCategory -> Bool $c/= :: GeneralCategory -> GeneralCategory -> Bool /= :: GeneralCategory -> GeneralCategory -> Bool Eq -- ^ @since 2.01,Eq GeneralCategory Eq GeneralCategory => (GeneralCategory -> GeneralCategory -> Ordering) -> (GeneralCategory -> GeneralCategory -> Bool) -> (GeneralCategory -> GeneralCategory -> Bool) -> (GeneralCategory -> GeneralCategory -> Bool) -> (GeneralCategory -> GeneralCategory -> Bool) -> (GeneralCategory -> GeneralCategory -> GeneralCategory) -> (GeneralCategory -> GeneralCategory -> GeneralCategory) -> Ord GeneralCategory GeneralCategory -> GeneralCategory -> Bool GeneralCategory -> GeneralCategory -> Ordering GeneralCategory -> GeneralCategory -> GeneralCategory forall a. Eq a => (a -> a -> Ordering) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> Bool) -> (a -> a -> a) -> (a -> a -> a) -> Ord a $ccompare :: GeneralCategory -> GeneralCategory -> Ordering compare :: GeneralCategory -> GeneralCategory -> Ordering $c< :: GeneralCategory -> GeneralCategory -> Bool < :: GeneralCategory -> GeneralCategory -> Bool $c<= :: GeneralCategory -> GeneralCategory -> Bool <= :: GeneralCategory -> GeneralCategory -> Bool $c> :: GeneralCategory -> GeneralCategory -> Bool > :: GeneralCategory -> GeneralCategory -> Bool $c>= :: GeneralCategory -> GeneralCategory -> Bool >= :: GeneralCategory -> GeneralCategory -> Bool $cmax :: GeneralCategory -> GeneralCategory -> GeneralCategory max :: GeneralCategory -> GeneralCategory -> GeneralCategory $cmin :: GeneralCategory -> GeneralCategory -> GeneralCategory min :: GeneralCategory -> GeneralCategory -> GeneralCategory Ord -- ^ @since 2.01,Int -> GeneralCategory GeneralCategory -> Int GeneralCategory -> [GeneralCategory] GeneralCategory -> GeneralCategory GeneralCategory -> GeneralCategory -> [GeneralCategory] GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] (GeneralCategory -> GeneralCategory) -> (GeneralCategory -> GeneralCategory) -> (Int -> GeneralCategory) -> (GeneralCategory -> Int) -> (GeneralCategory -> [GeneralCategory]) -> (GeneralCategory -> GeneralCategory -> [GeneralCategory]) -> (GeneralCategory -> GeneralCategory -> [GeneralCategory]) -> (GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory]) -> Enum GeneralCategory forall a. (a -> a) -> (a -> a) -> (Int -> a) -> (a -> Int) -> (a -> [a]) -> (a -> a -> [a]) -> (a -> a -> [a]) -> (a -> a -> a -> [a]) -> Enum a $csucc :: GeneralCategory -> GeneralCategory succ :: GeneralCategory -> GeneralCategory $cpred :: GeneralCategory -> GeneralCategory pred :: GeneralCategory -> GeneralCategory $ctoEnum :: Int -> GeneralCategory toEnum :: Int -> GeneralCategory $cfromEnum :: GeneralCategory -> Int fromEnum :: GeneralCategory -> Int $cenumFrom :: GeneralCategory -> [GeneralCategory] enumFrom :: GeneralCategory -> [GeneralCategory] $cenumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] $cenumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] $cenumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] Enum -- ^ @since 2.01,GeneralCategory GeneralCategory -> GeneralCategory -> Bounded GeneralCategory forall a. a -> a -> Bounded a $cminBound :: GeneralCategory minBound :: GeneralCategory $cmaxBound :: GeneralCategory maxBound :: GeneralCategory Bounded -- ^ @since 2.01,Ord GeneralCategory Ord GeneralCategory => ((GeneralCategory, GeneralCategory) -> [GeneralCategory]) -> ((GeneralCategory, GeneralCategory) -> GeneralCategory -> Int) -> ((GeneralCategory, GeneralCategory) -> GeneralCategory -> Int) -> ((GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool) -> ((GeneralCategory, GeneralCategory) -> Int) -> ((GeneralCategory, GeneralCategory) -> Int) -> Ix GeneralCategory (GeneralCategory, GeneralCategory) -> Int (GeneralCategory, GeneralCategory) -> [GeneralCategory] (GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int forall a. Ord a => ((a, a) -> [a]) -> ((a, a) -> a -> Int) -> ((a, a) -> a -> Int) -> ((a, a) -> a -> Bool) -> ((a, a) -> Int) -> ((a, a) -> Int) -> Ix a $crange :: (GeneralCategory, GeneralCategory) -> [GeneralCategory] range :: (GeneralCategory, GeneralCategory) -> [GeneralCategory] $cindex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int index :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int $cunsafeIndex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int unsafeIndex :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Int $cinRange :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool inRange :: (GeneralCategory, GeneralCategory) -> GeneralCategory -> Bool $crangeSize :: (GeneralCategory, GeneralCategory) -> Int rangeSize :: (GeneralCategory, GeneralCategory) -> Int $cunsafeRangeSize :: (GeneralCategory, GeneralCategory) -> Int unsafeRangeSize :: (GeneralCategory, GeneralCategory) -> Int Ix -- ^ @since 2.01)-- | The Unicode general category of the character. This relies on the-- 'Enum' instance of 'GeneralCategory', which must remain in the-- same order as the categories are presented in the Unicode-- standard.---- ==== __Examples__---- Basic usage:---- >>> generalCategory 'a'-- LowercaseLetter-- >>> generalCategory 'A'-- UppercaseLetter-- >>> generalCategory '0'-- DecimalNumber-- >>> generalCategory '%'-- OtherPunctuation-- >>> generalCategory '♥'-- OtherSymbol-- >>> generalCategory '31円'-- Control-- >>> generalCategory ' '-- Space--{-# INLINEgeneralCategory #-}generalCategory ::Char ->GeneralCategory generalCategory :: Char -> GeneralCategory generalCategory =Int -> GeneralCategory forall a. Enum a => Int -> a toEnum (Int -> GeneralCategory) -> (Char -> Int) -> Char -> GeneralCategory forall b c a. (b -> c) -> (a -> b) -> a -> c . Char -> Int GC.generalCategory -- | Selects the first 128 characters of the Unicode character set,-- corresponding to the ASCII character set.isAscii ::Char ->Bool isAscii :: Char -> Bool isAscii Char c =Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool < Char '\x80'-- | Selects the first 256 characters of the Unicode character set,-- corresponding to the ISO 8859-1 (Latin-1) character set.isLatin1 ::Char ->Bool isLatin1 :: Char -> Bool isLatin1 Char c =Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool <= Char '\xff'-- | Selects ASCII lower-case letters,-- i.e. characters satisfying both 'isAscii' and 'isLower'.isAsciiLower ::Char ->Bool isAsciiLower :: Char -> Bool isAsciiLower Char c =Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool >= Char 'a'Bool -> Bool -> Bool && Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool <= Char 'z'-- | Selects ASCII upper-case letters,-- i.e. characters satisfying both 'isAscii' and 'isUpper'.isAsciiUpper ::Char ->Bool isAsciiUpper :: Char -> Bool isAsciiUpper Char c =Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool >= Char 'A'Bool -> Bool -> Bool && Char c Char -> Char -> Bool forall a. Ord a => a -> a -> Bool <= Char 'Z'-- | Selects control characters, which are the non-printing characters of-- the Latin-1 subset of Unicode.isControl ::Char ->Bool -- Select characters with category 'Control'.-- By definition (https://www.unicode.org/reports/tr44/#General_Category_Values)-- “a C0 or C1 control code”, i.e. the 0x00-0x1f, 0x7f, and 0x80-0x9f.isControl :: Char -> Bool isControl Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory Control ->Bool True GeneralCategory _->Bool False -- | Selects printable Unicode characters-- (letters, numbers, marks, punctuation, symbols and spaces).isPrint ::Char ->Bool isPrint :: Char -> Bool isPrint Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory LineSeparator ->Bool False GeneralCategory ParagraphSeparator ->Bool False GeneralCategory Control ->Bool False GeneralCategory Format ->Bool False GeneralCategory Surrogate ->Bool False GeneralCategory PrivateUse ->Bool False GeneralCategory NotAssigned ->Bool False GeneralCategory _->Bool True -- | Returns 'True' for any Unicode space character, and the control-- characters @\\t@, @\\n@, @\\r@, @\\f@, @\\v@.isSpace ::Char ->Bool -- isSpace includes non-breaking space-- The magic 0x377 isn't really that magical. As of 2014, all the codepoints-- at or below 0x377 have been assigned, so we shouldn't have to worry about-- any new spaces appearing below there. It would probably be best to-- use branchless ||, but currently the eqLit transformation will undo that,-- so we'll do it like this until there's a way around that.isSpace :: Char -> Bool isSpace Char c |Word uc Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 0x377=Word uc Word -> Word -> Bool forall a. Eq a => a -> a -> Bool == Word 32Bool -> Bool -> Bool || Word uc Word -> Word -> Word forall a. Num a => a -> a -> a - Word 0x9Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 4Bool -> Bool -> Bool || Word uc Word -> Word -> Bool forall a. Eq a => a -> a -> Bool == Word 0xa0|Bool otherwise =Char -> GeneralCategory generalCategory Char c GeneralCategory -> GeneralCategory -> Bool forall a. Eq a => a -> a -> Bool == GeneralCategory Space whereuc :: Word uc =Int -> Word forall a b. (Integral a, Num b) => a -> b fromIntegral (Char -> Int ord Char c )::Word -- | Selects upper-case or title-case alphabetic Unicode characters (letters).-- Title case is used by a small number of letter ligatures like the-- single-character form of /Lj/.---- __Note:__ this predicate does /not/ work for letter-like characters such as:-- @\'Ⓐ\'@ (@U+24B6@ circled Latin capital letter A) and-- @\'Ⅳ\'@ (@U+2163@ Roman numeral four). This is due to selecting only-- characters with the 'GeneralCategory' 'UppercaseLetter' or 'TitlecaseLetter'.---- See 'isUpperCase' for a more intuitive predicate. Note that-- unlike 'isUpperCase', 'isUpper' does select /title-case/ characters such as-- @\'Dž\'@ (@U+01C5@ Latin capital letter d with small letter z with caron) or-- @\'ᾯ\'@ (@U+1FAF@ Greek capital letter omega with dasia and perispomeni and-- prosgegrammeni).isUpper ::Char ->Bool isUpper :: Char -> Bool isUpper Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory UppercaseLetter ->Bool True GeneralCategory TitlecaseLetter ->Bool True GeneralCategory _->Bool False -- | Selects upper-case Unicode letter-like characters.---- __Note:__ this predicate selects characters with the Unicode property-- @Uppercase@, which include letter-like characters such as:-- @\'Ⓐ\'@ (@U+24B6@ circled Latin capital letter A) and-- @\'Ⅳ\'@ (@U+2163@ Roman numeral four).---- See 'isUpper' for the legacy predicate. Note that-- unlike 'isUpperCase', 'isUpper' does select /title-case/ characters such as-- @\'Dž\'@ (@U+01C5@ Latin capital letter d with small letter z with caron) or-- @\'ᾯ\'@ (@U+1FAF@ Greek capital letter omega with dasia and perispomeni and-- prosgegrammeni).---- @since 4.18.0.0{-# INLINEisUpperCase #-}isUpperCase ::Char ->Bool isUpperCase :: Char -> Bool isUpperCase =Char -> Bool DCP.isUppercase -- | Selects lower-case alphabetic Unicode characters (letters).---- __Note:__ this predicate does /not/ work for letter-like characters such as:-- @\'ⓐ\'@ (@U+24D0@ circled Latin small letter a) and-- @\'ⅳ\'@ (@U+2173@ small Roman numeral four). This is due to selecting only-- characters with the 'GeneralCategory' 'LowercaseLetter'.---- See 'isLowerCase' for a more intuitive predicate.isLower ::Char ->Bool isLower :: Char -> Bool isLower Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory LowercaseLetter ->Bool True GeneralCategory _->Bool False -- | Selects lower-case Unicode letter-like characters.---- __Note:__ this predicate selects characters with the Unicode property-- @Lowercase@, which includes letter-like characters such as:-- @\'ⓐ\'@ (@U+24D0@ circled Latin small letter a) and-- @\'ⅳ\'@ (@U+2173@ small Roman numeral four).---- See 'isLower' for the legacy predicate.---- @since 4.18.0.0{-# INLINEisLowerCase #-}isLowerCase ::Char ->Bool isLowerCase :: Char -> Bool isLowerCase =Char -> Bool DCP.isLowercase -- | Selects alphabetic Unicode characters (lower-case, upper-case and-- title-case letters, plus letters of caseless scripts and modifiers letters).-- This function is equivalent to 'Data.Char.isLetter'.isAlpha ::Char ->Bool isAlpha :: Char -> Bool isAlpha Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory UppercaseLetter ->Bool True GeneralCategory LowercaseLetter ->Bool True GeneralCategory TitlecaseLetter ->Bool True GeneralCategory ModifierLetter ->Bool True GeneralCategory OtherLetter ->Bool True GeneralCategory _->Bool False -- | Selects alphabetic or numeric Unicode characters.---- Note that numeric digits outside the ASCII range, as well as numeric-- characters which aren't digits, are selected by this function but not by-- 'isDigit'. Such characters may be part of identifiers but are not used by-- the printer and reader to represent numbers.isAlphaNum ::Char ->Bool isAlphaNum :: Char -> Bool isAlphaNum Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory UppercaseLetter ->Bool True GeneralCategory LowercaseLetter ->Bool True GeneralCategory TitlecaseLetter ->Bool True GeneralCategory ModifierLetter ->Bool True GeneralCategory OtherLetter ->Bool True GeneralCategory DecimalNumber ->Bool True GeneralCategory LetterNumber ->Bool True GeneralCategory OtherNumber ->Bool True GeneralCategory _->Bool False -- | Selects ASCII digits, i.e. @\'0\'@..@\'9\'@.isDigit ::Char ->Bool isDigit :: Char -> Bool isDigit Char c =(Int -> Word forall a b. (Integral a, Num b) => a -> b fromIntegral (Char -> Int ord Char c Int -> Int -> Int forall a. Num a => a -> a -> a - Char -> Int ord Char '0')::Word )Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 9-- We use an addition and an unsigned comparison instead of two signed-- comparisons because it's usually faster and puts less strain on branch-- prediction. It likely also enables some CSE when combined with functions-- that follow up with an actual conversion.-- | Selects ASCII octal digits, i.e. @\'0\'@..@\'7\'@.isOctDigit ::Char ->Bool isOctDigit :: Char -> Bool isOctDigit Char c =(Int -> Word forall a b. (Integral a, Num b) => a -> b fromIntegral (Char -> Int ord Char c Int -> Int -> Int forall a. Num a => a -> a -> a - Char -> Int ord Char '0')::Word )Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 7-- | Selects ASCII hexadecimal digits,-- i.e. @\'0\'@..@\'9\'@, @\'a\'@..@\'f\'@, @\'A\'@..@\'F\'@.isHexDigit ::Char ->Bool isHexDigit :: Char -> Bool isHexDigit Char c =Char -> Bool isDigit Char c Bool -> Bool -> Bool || (Int -> Word forall a b. (Integral a, Num b) => a -> b fromIntegral (Char -> Int ord Char c Int -> Int -> Int forall a. Num a => a -> a -> a - Char -> Int ord Char 'A')::Word )Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 5Bool -> Bool -> Bool || (Int -> Word forall a b. (Integral a, Num b) => a -> b fromIntegral (Char -> Int ord Char c Int -> Int -> Int forall a. Num a => a -> a -> a - Char -> Int ord Char 'a')::Word )Word -> Word -> Bool forall a. Ord a => a -> a -> Bool <= Word 5-- | Selects Unicode punctuation characters, including various kinds-- of connectors, brackets and quotes.---- This function returns 'True' if its argument has one of the-- following 'GeneralCategory's, or 'False' otherwise:---- * 'ConnectorPunctuation'-- * 'DashPunctuation'-- * 'OpenPunctuation'-- * 'ClosePunctuation'-- * 'InitialQuote'-- * 'FinalQuote'-- * 'OtherPunctuation'---- These classes are defined in the-- <http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_Table Unicode Character Database>,-- part of the Unicode standard. The same document defines what is-- and is not a \"Punctuation\".---- ==== __Examples__---- Basic usage:---- >>> isPunctuation 'a'-- False-- >>> isPunctuation '7'-- False-- >>> isPunctuation '♥'-- False-- >>> isPunctuation '"'-- True-- >>> isPunctuation '?'-- True-- >>> isPunctuation '—'-- True--isPunctuation ::Char ->Bool isPunctuation :: Char -> Bool isPunctuation Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory ConnectorPunctuation ->Bool True GeneralCategory DashPunctuation ->Bool True GeneralCategory OpenPunctuation ->Bool True GeneralCategory ClosePunctuation ->Bool True GeneralCategory InitialQuote ->Bool True GeneralCategory FinalQuote ->Bool True GeneralCategory OtherPunctuation ->Bool True GeneralCategory _->Bool False -- | Selects Unicode symbol characters, including mathematical and-- currency symbols.---- This function returns 'True' if its argument has one of the-- following 'GeneralCategory's, or 'False' otherwise:---- * 'MathSymbol'-- * 'CurrencySymbol'-- * 'ModifierSymbol'-- * 'OtherSymbol'---- These classes are defined in the-- <http://www.unicode.org/reports/tr44/tr44-14.html#GC_Values_Table Unicode Character Database>,-- part of the Unicode standard. The same document defines what is-- and is not a \"Symbol\".---- ==== __Examples__---- Basic usage:---- >>> isSymbol 'a'-- False-- >>> isSymbol '6'-- False-- >>> isSymbol '='-- True---- The definition of \"math symbol\" may be a little-- counter-intuitive depending on one's background:---- >>> isSymbol '+'-- True-- >>> isSymbol '-'-- False--isSymbol ::Char ->Bool isSymbol :: Char -> Bool isSymbol Char c =caseChar -> GeneralCategory generalCategory Char c ofGeneralCategory MathSymbol ->Bool True GeneralCategory CurrencySymbol ->Bool True GeneralCategory ModifierSymbol ->Bool True GeneralCategory OtherSymbol ->Bool True GeneralCategory _->Bool False -- | Convert a letter to the corresponding upper-case letter, if any.-- Any other character is returned unchanged.{-# INLINEtoUpper #-}toUpper ::Char ->Char toUpper :: Char -> Char toUpper =Char -> Char C.toSimpleUpperCase -- | Convert a letter to the corresponding lower-case letter, if any.-- Any other character is returned unchanged.{-# INLINEtoLower #-}toLower ::Char ->Char toLower :: Char -> Char toLower =Char -> Char C.toSimpleLowerCase -- | Convert a letter to the corresponding title-case or upper-case-- letter, if any. (Title case differs from upper case only for a small-- number of ligature letters.)-- Any other character is returned unchanged.{-# INLINEtoTitle #-}toTitle ::Char ->Char toTitle :: Char -> Char toTitle =Char -> Char C.toSimpleTitleCase