{-|
Module      : Z.Data.ASCII
Description : ASCII chars
Copyright   : (c) Dong Han, 2020
License     : BSD
Maintainer  : [email protected]
Stability   : experimental
Portability : non-portable

ASCII Chars utility.

-}

module Z.Data.ASCII where

import GHC.Word
import GHC.Exts

-- | Conversion between 'Word8' and 'Char'. Should compile to a no-op.
--
w2c :: Word8 -> Char
{-# INLINE w2c #-}
w2c :: Word8 -> Char
w2c (W8# Word8#
w#) = Char# -> Char
C# (Int# -> Char#
chr# (Word# -> Int#
word2Int# (Word8# -> Word#
word8ToWord# Word8#
w#)))

-- | Unsafe conversion between 'Char' and 'Word8'. This is a no-op and
-- silently truncates to 8 bits Chars > @\\255@.
c2w :: Char -> Word8
{-# INLINE c2w #-}
c2w :: Char -> Word8
c2w (C# Char#
c#) = Word8# -> Word8
W8# (Word# -> Word8#
wordToWord8# (Int# -> Word#
int2Word# (Char# -> Int#
ord# Char#
c#)))

-- | @\\NUL <= w && w <= \\DEL@
isASCII :: Word8 -> Bool
{-# INLINE isASCII #-}
isASCII :: Word8 -> Bool
isASCII Word8
w = Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
DEL

-- | @A ~ Z@
isUpper :: Word8 -> Bool
{-# INLINE isUpper #-}
isUpper :: Word8 -> Bool
isUpper Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
LETTER_A Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
25

-- | @a ~ z@
isLower :: Word8 -> Bool
{-# INLINE isLower #-}
isLower :: Word8 -> Bool
isLower Word8
w =  Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
LETTER_a Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
25

-- | @A ~ Z@ => @a ~ z@
toLower :: Word8 -> Word8
{-# INLINE toLower #-}
toLower :: Word8 -> Word8
toLower Word8
w
  | Word8
65 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<=  Word8
90 = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
32
  | Bool
otherwise           = Word8
w

-- | @a ~ z@ => @A ~ Z@
toUpper :: Word8 -> Word8
{-# INLINE toUpper #-}
toUpper :: Word8 -> Word8
toUpper Word8
w
  | Word8
97 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
122 = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
32
  | Bool
otherwise           = Word8
w

-- | @A ~ Z@ => @a ~ z@, @À ~ Ö@ => @à ~ ö@, @Ø ~ Þ@ => @ø ~ þ@
toLowerLatin :: Word8 -> Word8
{-# INLINE toLowerLatin #-}
toLowerLatin :: Word8 -> Word8
toLowerLatin Word8
w
  |  Word8
65 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<=  Word8
90 Bool -> Bool -> Bool
||
    Word8
192 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
214 Bool -> Bool -> Bool
||
    Word8
216 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
222 = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
+ Word8
32
  | Bool
otherwise            = Word8
w

-- | @a ~ z@ => @A ~ Z@, @à ~ ö@ => @À ~ Ö@, @ø ~ þ@ => @Ø ~ Þ@
toUpperLatin :: Word8 -> Word8
{-# INLINE toUpperLatin #-}
toUpperLatin :: Word8 -> Word8
toUpperLatin Word8
w
  | Word8
97  Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
122 Bool -> Bool -> Bool
||
    Word8
224 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
246 Bool -> Bool -> Bool
||
    Word8
248 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
w Bool -> Bool -> Bool
&& Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
254 = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
32
  | Bool
otherwise            = Word8
w

-- | @ISO-8859-1@ control letter.
isControl :: Word8 -> Bool
{-# INLINE isControl #-}
isControl :: Word8 -> Bool
isControl Word8
w = Word8
w Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
0x1f Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
DEL Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
32

-- | @ISO-8859-1@ space letter.
isSpace :: Word8 -> Bool
{-# INLINE isSpace #-}
isSpace :: Word8 -> Bool
isSpace Word8
w = Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
SPACE Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
TAB Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
4 Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0xa0

-- | @0 ~ 9@
isDigit :: Word8 -> Bool
{-# INLINE isDigit #-}
isDigit :: Word8 -> Bool
isDigit Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
DIGIT_0 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
9

-- | @0 ~ 7@
isOctDigit :: Word8 -> Bool
{-# INLINE isOctDigit #-}
isOctDigit :: Word8 -> Bool
isOctDigit Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
DIGIT_0 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
7

-- | @0 ~ 9, A ~ F, a ~ f@
isHexDigit :: Word8 -> Bool
{-# INLINE isHexDigit #-}
isHexDigit :: Word8 -> Bool
isHexDigit Word8
w = Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
DIGIT_0 Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
9 Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
LETTER_A Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
5 Bool -> Bool -> Bool
|| Word8
w Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
- Word8
LETTER_a Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
<= Word8
5

----------------------------------------------------------------

-- | @\\NUL@
pattern NUL :: Word8
pattern $mNUL :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNUL :: Word8
NUL          = 0x00
-- | Start of Heading
pattern SOH :: Word8
pattern $mSOH :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSOH :: Word8
SOH          = 0x01
-- | Start of Text
pattern STX :: Word8
pattern $mSTX :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSTX :: Word8
STX          = 0x02
-- | End of Text
pattern ETX :: Word8
pattern $mETX :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bETX :: Word8
ETX          = 0x03
-- | End of Transmission
pattern EOT :: Word8
pattern $mEOT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bEOT :: Word8
EOT          = 0x04
-- | Enquiry
pattern ENQ :: Word8
pattern $mENQ :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bENQ :: Word8
ENQ          = 0x05
-- | Acknowledgment
pattern ACK :: Word8
pattern $mACK :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bACK :: Word8
ACK          = 0x06
-- | Bell
pattern BEL :: Word8
pattern $mBEL :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBEL :: Word8
BEL          = 0x07
-- | Back Space
pattern BS :: Word8
pattern $mBS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBS :: Word8
BS          = 0x08
-- | @\\t@
pattern TAB :: Word8
pattern $mTAB :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAB :: Word8
TAB          = 0x09
-- | @\\n@
pattern NEWLINE :: Word8
pattern $mNEWLINE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNEWLINE :: Word8
NEWLINE      = 0x0a
-- | @\\v@
pattern VERTICAL_TAB :: Word8
pattern $mVERTICAL_TAB :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVERTICAL_TAB :: Word8
VERTICAL_TAB = 0x0b
-- | @\\f@
pattern FORM_FEED :: Word8
pattern $mFORM_FEED :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bFORM_FEED :: Word8
FORM_FEED    = 0x0c
-- | @\\r@
pattern CARRIAGE_RETURN :: Word8
pattern $mCARRIAGE_RETURN :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCARRIAGE_RETURN :: Word8
CARRIAGE_RETURN = 0x0d
-- |  Shift Out / X-On
pattern SO :: Word8
pattern $mSO :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSO :: Word8
SO = 0x0e
-- |  Shift In / X-Off
pattern SI :: Word8
pattern $mSI :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSI :: Word8
SI = 0x0f
-- | Data Line Escape
pattern DLE :: Word8
pattern $mDLE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDLE :: Word8
DLE = 0x10
-- | Device Control 1 (oft. XON)
pattern DC1 :: Word8
pattern $mDC1 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDC1 :: Word8
DC1 = 0x11
-- | Device Control 2
pattern DC2 :: Word8
pattern $mDC2 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDC2 :: Word8
DC2 = 0x12
-- | Device Control 3 (oft. XOFF)
pattern DC3 :: Word8
pattern $mDC3 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDC3 :: Word8
DC3 = 0x13
-- | Device Control 4
pattern DC4 :: Word8
pattern $mDC4 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDC4 :: Word8
DC4 = 0x14
-- | Negative Acknowledgement
pattern NAK :: Word8
pattern $mNAK :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNAK :: Word8
NAK = 0x15
-- | Synchronous Idle
pattern SYN :: Word8
pattern $mSYN :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSYN :: Word8
SYN = 0x16
-- | End of Transmit Block
pattern ETB :: Word8
pattern $mETB :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bETB :: Word8
ETB = 0x17
-- | Cancel
pattern CAN :: Word8
pattern $mCAN :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCAN :: Word8
CAN = 0x18
-- |  End of Medium
pattern EM :: Word8
pattern $mEM :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bEM :: Word8
EM = 0x19
-- | Substitute
pattern SUB :: Word8
pattern $mSUB :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSUB :: Word8
SUB = 0x1a
-- | Escape
pattern ESC :: Word8
pattern $mESC :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bESC :: Word8
ESC = 0x1b
-- |  File Separator
pattern FS :: Word8
pattern $mFS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bFS :: Word8
FS = 0x1c
-- |  Group Separator
pattern GS :: Word8
pattern $mGS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bGS :: Word8
GS = 0x1d
-- |  Record Separator
pattern RS :: Word8
pattern $mRS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bRS :: Word8
RS = 0x1e
-- |  Unit Separator
pattern US :: Word8
pattern $mUS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bUS :: Word8
US = 0x1f
-- | @\' \'@
pattern SPACE :: Word8
pattern $mSPACE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSPACE :: Word8
SPACE        = 0x20
-- | @\!@
pattern EXCLAM :: Word8
pattern $mEXCLAM :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bEXCLAM :: Word8
EXCLAM       = 0x21
-- | @\"@
pattern DOUBLE_QUOTE :: Word8
pattern $mDOUBLE_QUOTE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDOUBLE_QUOTE :: Word8
DOUBLE_QUOTE = 0x22
-- | @\#@
pattern HASH :: Word8
pattern $mHASH :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHASH :: Word8
HASH         = 0x23
-- | @\#@
pattern NUMBER_SIGN :: Word8
pattern $mNUMBER_SIGN :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNUMBER_SIGN :: Word8
NUMBER_SIGN  = 0x23
-- | @\$@
pattern DOLLAR :: Word8
pattern $mDOLLAR :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDOLLAR :: Word8
DOLLAR       = 0x24
-- | @\%@
pattern PERCENT :: Word8
pattern $mPERCENT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPERCENT :: Word8
PERCENT      = 0x25
-- | @\&@
pattern AMPERSAND :: Word8
pattern $mAMPERSAND :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAMPERSAND :: Word8
AMPERSAND    = 0x26
-- | @\&@
pattern AND :: Word8
pattern $mAND :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAND :: Word8
AND          = 0x26
-- | @\'@
pattern SINGLE_QUOTE :: Word8
pattern $mSINGLE_QUOTE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSINGLE_QUOTE :: Word8
SINGLE_QUOTE = 0x27
-- | @(@
pattern PAREN_LEFT :: Word8
pattern $mPAREN_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPAREN_LEFT :: Word8
PAREN_LEFT   = 0x28
-- | @)@
pattern PAREN_RIGHT :: Word8
pattern $mPAREN_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPAREN_RIGHT :: Word8
PAREN_RIGHT  = 0x29
-- | @*@
pattern ASTERISK :: Word8
pattern $mASTERISK :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bASTERISK :: Word8
ASTERISK     = 0x2a
-- | @+@
pattern PLUS :: Word8
pattern $mPLUS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPLUS :: Word8
PLUS         = 0x2b
-- | @,@
pattern COMMA :: Word8
pattern $mCOMMA :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCOMMA :: Word8
COMMA        = 0x2c
-- | @-@
pattern HYPHEN :: Word8
pattern $mHYPHEN :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bHYPHEN :: Word8
HYPHEN       = 0x2d
-- | @-@
pattern MINUS :: Word8
pattern $mMINUS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMINUS :: Word8
MINUS        = 0x2d
-- | @.@
pattern PERIOD :: Word8
pattern $mPERIOD :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPERIOD :: Word8
PERIOD       = 0x2e
-- | @.@
pattern DOT :: Word8
pattern $mDOT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDOT :: Word8
DOT          = 0x2e
-- | @\/@
pattern SLASH :: Word8
pattern $mSLASH :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSLASH :: Word8
SLASH        = 0x2f

pattern DIGIT_0 :: Word8
pattern $mDIGIT_0 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_0 :: Word8
DIGIT_0      = 0x30
pattern DIGIT_1 :: Word8
pattern $mDIGIT_1 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_1 :: Word8
DIGIT_1      = 0x31
pattern DIGIT_2 :: Word8
pattern $mDIGIT_2 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_2 :: Word8
DIGIT_2      = 0x32
pattern DIGIT_3 :: Word8
pattern $mDIGIT_3 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_3 :: Word8
DIGIT_3      = 0x33
pattern DIGIT_4 :: Word8
pattern $mDIGIT_4 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_4 :: Word8
DIGIT_4      = 0x34
pattern DIGIT_5 :: Word8
pattern $mDIGIT_5 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_5 :: Word8
DIGIT_5      = 0x35
pattern DIGIT_6 :: Word8
pattern $mDIGIT_6 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_6 :: Word8
DIGIT_6      = 0x36
pattern DIGIT_7 :: Word8
pattern $mDIGIT_7 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_7 :: Word8
DIGIT_7      = 0x37
pattern DIGIT_8 :: Word8
pattern $mDIGIT_8 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_8 :: Word8
DIGIT_8      = 0x38
pattern DIGIT_9 :: Word8
pattern $mDIGIT_9 :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDIGIT_9 :: Word8
DIGIT_9      = 0x39

-- | @:@
pattern COLON :: Word8
pattern $mCOLON :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCOLON :: Word8
COLON        = 0x3a
-- | @;@
pattern SEMICOLON :: Word8
pattern $mSEMICOLON :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSEMICOLON :: Word8
SEMICOLON    = 0x3b
-- | @<@
pattern LESS :: Word8
pattern $mLESS :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLESS :: Word8
LESS         = 0x3c
-- | @<@
pattern ANGLE_LEFT :: Word8
pattern $mANGLE_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bANGLE_LEFT :: Word8
ANGLE_LEFT   = 0x3c
-- | @=@
pattern EQUAL :: Word8
pattern $mEQUAL :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bEQUAL :: Word8
EQUAL        = 0x3d
-- | @>@
pattern GREATER :: Word8
pattern $mGREATER :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bGREATER :: Word8
GREATER      = 0x3e
-- | @>@
pattern ANGLE_RIGHT :: Word8
pattern $mANGLE_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bANGLE_RIGHT :: Word8
ANGLE_RIGHT  = 0x3e
-- | @\?@
pattern QUESTION :: Word8
pattern $mQUESTION :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bQUESTION :: Word8
QUESTION     = 0x3f
-- | @\@@
pattern AT :: Word8
pattern $mAT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bAT :: Word8
AT           = 0x40

pattern LETTER_A :: Word8
pattern $mLETTER_A :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_A :: Word8
LETTER_A     = 0x41
pattern LETTER_B :: Word8
pattern $mLETTER_B :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_B :: Word8
LETTER_B     = 0x42
pattern LETTER_C :: Word8
pattern $mLETTER_C :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_C :: Word8
LETTER_C     = 0x43
pattern LETTER_D :: Word8
pattern $mLETTER_D :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_D :: Word8
LETTER_D     = 0x44
pattern LETTER_E :: Word8
pattern $mLETTER_E :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_E :: Word8
LETTER_E     = 0x45
pattern LETTER_F :: Word8
pattern $mLETTER_F :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_F :: Word8
LETTER_F     = 0x46
pattern LETTER_G :: Word8
pattern $mLETTER_G :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_G :: Word8
LETTER_G     = 0x47
pattern LETTER_H :: Word8
pattern $mLETTER_H :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_H :: Word8
LETTER_H     = 0x48
pattern LETTER_I :: Word8
pattern $mLETTER_I :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_I :: Word8
LETTER_I     = 0x49
pattern LETTER_J :: Word8
pattern $mLETTER_J :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_J :: Word8
LETTER_J     = 0x4a
pattern LETTER_K :: Word8
pattern $mLETTER_K :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_K :: Word8
LETTER_K     = 0x4b
pattern LETTER_L :: Word8
pattern $mLETTER_L :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_L :: Word8
LETTER_L     = 0x4c
pattern LETTER_M :: Word8
pattern $mLETTER_M :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_M :: Word8
LETTER_M     = 0x4d
pattern LETTER_N :: Word8
pattern $mLETTER_N :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_N :: Word8
LETTER_N     = 0x4e
pattern LETTER_O :: Word8
pattern $mLETTER_O :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_O :: Word8
LETTER_O     = 0x4f
pattern LETTER_P :: Word8
pattern $mLETTER_P :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_P :: Word8
LETTER_P     = 0x50
pattern LETTER_Q :: Word8
pattern $mLETTER_Q :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_Q :: Word8
LETTER_Q     = 0x51
pattern LETTER_R :: Word8
pattern $mLETTER_R :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_R :: Word8
LETTER_R     = 0x52
pattern LETTER_S :: Word8
pattern $mLETTER_S :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_S :: Word8
LETTER_S     = 0x53
pattern LETTER_T :: Word8
pattern $mLETTER_T :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_T :: Word8
LETTER_T     = 0x54
pattern LETTER_U :: Word8
pattern $mLETTER_U :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_U :: Word8
LETTER_U     = 0x55
pattern LETTER_V :: Word8
pattern $mLETTER_V :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_V :: Word8
LETTER_V     = 0x56
pattern LETTER_W :: Word8
pattern $mLETTER_W :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_W :: Word8
LETTER_W     = 0x57
pattern LETTER_X :: Word8
pattern $mLETTER_X :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_X :: Word8
LETTER_X     = 0x58
pattern LETTER_Y :: Word8
pattern $mLETTER_Y :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_Y :: Word8
LETTER_Y     = 0x59
pattern LETTER_Z :: Word8
pattern $mLETTER_Z :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_Z :: Word8
LETTER_Z     = 0x5a

-- | @[@
pattern BRACKET_LEFT :: Word8
pattern $mBRACKET_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBRACKET_LEFT :: Word8
BRACKET_LEFT = 0x5b
-- | @[@
pattern SQUARE_LEFT :: Word8
pattern $mSQUARE_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSQUARE_LEFT :: Word8
SQUARE_LEFT = 0x5b
-- | @\\@
pattern BACKSLASH :: Word8
pattern $mBACKSLASH :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBACKSLASH :: Word8
BACKSLASH    = 0x5c
-- | @]@
pattern BRACKET_RIGHT :: Word8
pattern $mBRACKET_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBRACKET_RIGHT :: Word8
BRACKET_RIGHT = 0x5d
-- | @]@
pattern SQUARE_RIGHT :: Word8
pattern $mSQUARE_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSQUARE_RIGHT :: Word8
SQUARE_RIGHT = 0x5d
-- | @^@
pattern CIRCUM :: Word8
pattern $mCIRCUM :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCIRCUM :: Word8
CIRCUM       = 0x5e
-- | @_@
pattern UNDERSCORE :: Word8
pattern $mUNDERSCORE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bUNDERSCORE :: Word8
UNDERSCORE   = 0x5f
-- | @`@
pattern GRAVE :: Word8
pattern $mGRAVE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bGRAVE :: Word8
GRAVE        = 0x60

pattern LETTER_a :: Word8
pattern $mLETTER_a :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_a :: Word8
LETTER_a     = 0x61
pattern LETTER_b :: Word8
pattern $mLETTER_b :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_b :: Word8
LETTER_b     = 0x62
pattern LETTER_c :: Word8
pattern $mLETTER_c :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_c :: Word8
LETTER_c     = 0x63
pattern LETTER_d :: Word8
pattern $mLETTER_d :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_d :: Word8
LETTER_d     = 0x64
pattern LETTER_e :: Word8
pattern $mLETTER_e :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_e :: Word8
LETTER_e     = 0x65
pattern LETTER_f :: Word8
pattern $mLETTER_f :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_f :: Word8
LETTER_f     = 0x66
pattern LETTER_g :: Word8
pattern $mLETTER_g :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_g :: Word8
LETTER_g     = 0x67
pattern LETTER_h :: Word8
pattern $mLETTER_h :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_h :: Word8
LETTER_h     = 0x68
pattern LETTER_i :: Word8
pattern $mLETTER_i :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_i :: Word8
LETTER_i     = 0x69
pattern LETTER_j :: Word8
pattern $mLETTER_j :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_j :: Word8
LETTER_j     = 0x6a
pattern LETTER_k :: Word8
pattern $mLETTER_k :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_k :: Word8
LETTER_k     = 0x6b
pattern LETTER_l :: Word8
pattern $mLETTER_l :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_l :: Word8
LETTER_l     = 0x6c
pattern LETTER_m :: Word8
pattern $mLETTER_m :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_m :: Word8
LETTER_m     = 0x6d
pattern LETTER_n :: Word8
pattern $mLETTER_n :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_n :: Word8
LETTER_n     = 0x6e
pattern LETTER_o :: Word8
pattern $mLETTER_o :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_o :: Word8
LETTER_o     = 0x6f
pattern LETTER_p :: Word8
pattern $mLETTER_p :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_p :: Word8
LETTER_p     = 0x70
pattern LETTER_q :: Word8
pattern $mLETTER_q :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_q :: Word8
LETTER_q     = 0x71
pattern LETTER_r :: Word8
pattern $mLETTER_r :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_r :: Word8
LETTER_r     = 0x72
pattern LETTER_s :: Word8
pattern $mLETTER_s :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_s :: Word8
LETTER_s     = 0x73
pattern LETTER_t :: Word8
pattern $mLETTER_t :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_t :: Word8
LETTER_t     = 0x74
pattern LETTER_u :: Word8
pattern $mLETTER_u :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_u :: Word8
LETTER_u     = 0x75
pattern LETTER_v :: Word8
pattern $mLETTER_v :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_v :: Word8
LETTER_v     = 0x76
pattern LETTER_w :: Word8
pattern $mLETTER_w :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_w :: Word8
LETTER_w     = 0x77
pattern LETTER_x :: Word8
pattern $mLETTER_x :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_x :: Word8
LETTER_x     = 0x78
pattern LETTER_y :: Word8
pattern $mLETTER_y :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_y :: Word8
LETTER_y     = 0x79
pattern LETTER_z :: Word8
pattern $mLETTER_z :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bLETTER_z :: Word8
LETTER_z     = 0x7a

-- | @{@
pattern BRACE_LEFT :: Word8
pattern $mBRACE_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBRACE_LEFT :: Word8
BRACE_LEFT   = 0x7b
-- | @{@
pattern CURLY_LEFT :: Word8
pattern $mCURLY_LEFT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCURLY_LEFT :: Word8
CURLY_LEFT   = 0x7b
-- | @|@
pattern BAR :: Word8
pattern $mBAR :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBAR :: Word8
BAR          = 0x7c
-- | @|@
pattern OR :: Word8
pattern $mOR :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bOR :: Word8
OR           = 0x7c
-- | @}@
pattern BRACE_RIGHT :: Word8
pattern $mBRACE_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBRACE_RIGHT :: Word8
BRACE_RIGHT  = 0x7d
-- | @}@
pattern CURLY_RIGHT :: Word8
pattern $mCURLY_RIGHT :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCURLY_RIGHT :: Word8
CURLY_RIGHT  = 0x7d
-- | @~@
pattern TILDE :: Word8
pattern $mTILDE :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bTILDE :: Word8
TILDE        = 0x7e
-- | @\\DEL@
pattern DEL :: Word8
pattern $mDEL :: forall {r}. Word8 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDEL :: Word8
DEL          = 0x7f