Safe Haskell	None
Language	Haskell2010

Data.Char.Cases

Description

Exposes subspecies types of Char. e.g. [a-z], [A-Z], and [0-9].

Synopsis

dual :: Ord a => Map k a -> Map a k
data AlphaNumChar
- = AlphaNumAlpha AlphaChar
- | AlphaNumDigit DigitChar
alphaNumToChar :: AlphaNumChar -> Char
alphaNumChar :: CodeParsing m => m AlphaNumChar
charToAlphaNum :: Char -> Maybe AlphaNumChar
alphaNumCharQ :: QuasiQuoter
data AlphaChar
- = AlphaLower LowerChar
- | AlphaUpper UpperChar
alphaToChar :: AlphaChar -> Char
charToAlpha :: Char -> Maybe AlphaChar
alphaChar :: CodeParsing m => m AlphaChar
alphaCharQ :: QuasiQuoter
data UpperChar
- = A
- | B
- | C
- | D
- | E
- | F
- | G
- | H
- | I
- | J
- | K
- | L
- | M
- | N
- | O
- | P
- | Q
- | R
- | S
- | T
- | U
- | V
- | W
- | X
- | Y
- | Z
upperToChar :: UpperChar -> Char
uppers :: Map UpperChar Char
upperChar :: CodeParsing m => m UpperChar
charToUpper :: Char -> Maybe UpperChar
upperCharQ :: QuasiQuoter
data LowerChar
- = A_
- | B_
- | C_
- | D_
- | E_
- | F_
- | G_
- | H_
- | I_
- | J_
- | K_
- | L_
- | M_
- | N_
- | O_
- | P_
- | Q_
- | R_
- | S_
- | T_
- | U_
- | V_
- | W_
- | X_
- | Y_
- | Z_
lowerToChar :: LowerChar -> Char
lowers :: Map LowerChar Char
lowerChar :: CodeParsing m => m LowerChar
charToLower :: Char -> Maybe LowerChar
lowerCharQ :: QuasiQuoter
data DigitChar
- = D0
- | D1
- | D2
- | D3
- | D4
- | D5
- | D6
- | D7
- | D8
- | D9
digitToChar :: DigitChar -> Char
digits :: Map DigitChar Char
digitChar :: CodeParsing m => m DigitChar
charToDigit :: Char -> Maybe DigitChar
digitCharQ :: QuasiQuoter
data SneakChar
- = SneakUnderscore
- | SneakAlphaNum AlphaNumChar
unSneakChar :: SneakChar -> Char
sneakChar :: CodeParsing m => m SneakChar
charToSneak :: Char -> Maybe SneakChar
sneakCharQ :: QuasiQuoter
data SneakHeadChar
- = SneakHeadUnderscore
- | SneakHeadAlpha AlphaChar
unSneakHeadChar :: SneakHeadChar -> Char
sneakHeadChar :: CodeParsing m => m SneakHeadChar
charToSneakHead :: Char -> Maybe SneakHeadChar
sneakHeadCharQ :: QuasiQuoter

Documentation

>>> :set -XQuasiQuotes

dual :: Ord a => Map k a -> Map a k Source #

data AlphaNumChar Source #

Constructors

AlphaNumAlpha AlphaChar
AlphaNumDigit DigitChar

Instances

Eq AlphaNumChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: AlphaNumChar -> AlphaNumChar -> Bool # (/=) :: AlphaNumChar -> AlphaNumChar -> Bool #
Ord AlphaNumChar Source #
Instance details Defined in Data.Char.Cases Methods compare :: AlphaNumChar -> AlphaNumChar -> Ordering # (<) :: AlphaNumChar -> AlphaNumChar -> Bool # (<=) :: AlphaNumChar -> AlphaNumChar -> Bool # (>) :: AlphaNumChar -> AlphaNumChar -> Bool # (>=) :: AlphaNumChar -> AlphaNumChar -> Bool # max :: AlphaNumChar -> AlphaNumChar -> AlphaNumChar # min :: AlphaNumChar -> AlphaNumChar -> AlphaNumChar #
Show AlphaNumChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> AlphaNumChar -> ShowS # show :: AlphaNumChar -> String # showList :: [AlphaNumChar] -> ShowS #

alphaNumToChar :: AlphaNumChar -> Char Source #

alphaNumChar :: CodeParsing m => m AlphaNumChar Source #

charToAlphaNum :: Char -> Maybe AlphaNumChar Source #

alphaNumCharQ :: QuasiQuoter Source #

Simular to alphaCharQ and digitCharQ.

>>> [alphaNumCharQ|x|]
AlphaNumAlpha (AlphaLower X_)

>>> [alphaNumCharQ|X|]
AlphaNumAlpha (AlphaUpper X)

>>> [alphaNumCharQ|1|]
AlphaNumDigit D1

data AlphaChar Source #

Constructors

AlphaLower LowerChar
AlphaUpper UpperChar

Instances

Eq AlphaChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: AlphaChar -> AlphaChar -> Bool # (/=) :: AlphaChar -> AlphaChar -> Bool #
Ord AlphaChar Source #
Instance details Defined in Data.Char.Cases Methods compare :: AlphaChar -> AlphaChar -> Ordering # (<) :: AlphaChar -> AlphaChar -> Bool # (<=) :: AlphaChar -> AlphaChar -> Bool # (>) :: AlphaChar -> AlphaChar -> Bool # (>=) :: AlphaChar -> AlphaChar -> Bool # max :: AlphaChar -> AlphaChar -> AlphaChar # min :: AlphaChar -> AlphaChar -> AlphaChar #
Show AlphaChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> AlphaChar -> ShowS # show :: AlphaChar -> String # showList :: [AlphaChar] -> ShowS #

alphaToChar :: AlphaChar -> Char Source #

charToAlpha :: Char -> Maybe AlphaChar Source #

alphaChar :: CodeParsing m => m AlphaChar Source #

alphaCharQ :: QuasiQuoter Source #

Simular to lowerCharQ and upperCharQ.

data UpperChar Source #

Constructors

A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z

Instances

Eq UpperChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: UpperChar -> UpperChar -> Bool # (/=) :: UpperChar -> UpperChar -> Bool #
Ord UpperChar Source #
Instance details Defined in Data.Char.Cases Methods compare :: UpperChar -> UpperChar -> Ordering # (<) :: UpperChar -> UpperChar -> Bool # (<=) :: UpperChar -> UpperChar -> Bool # (>) :: UpperChar -> UpperChar -> Bool # (>=) :: UpperChar -> UpperChar -> Bool # max :: UpperChar -> UpperChar -> UpperChar # min :: UpperChar -> UpperChar -> UpperChar #
Show UpperChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> UpperChar -> ShowS # show :: UpperChar -> String # showList :: [UpperChar] -> ShowS #

upperToChar :: UpperChar -> Char Source #

uppers :: Map UpperChar Char Source #

upperChar :: CodeParsing m => m UpperChar Source #

charToUpper :: Char -> Maybe UpperChar Source #

upperCharQ :: QuasiQuoter Source #

Extracts a Char of [A-Z]. Also throws compile error if non [A-Z] is passed.

>>> [upperCharQ|X|]
X

>>> [upperCharQ|Y|]
Y

data LowerChar Source #

Constructors

A_
B_
C_
D_
E_
F_
G_
H_
I_
J_
K_
L_
M_
N_
O_
P_
Q_
R_
S_
T_
U_
V_
W_
X_
Y_
Z_

Instances

Eq LowerChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: LowerChar -> LowerChar -> Bool # (/=) :: LowerChar -> LowerChar -> Bool #
Ord LowerChar Source #
Instance details Defined in Data.Char.Cases Methods compare :: LowerChar -> LowerChar -> Ordering # (<) :: LowerChar -> LowerChar -> Bool # (<=) :: LowerChar -> LowerChar -> Bool # (>) :: LowerChar -> LowerChar -> Bool # (>=) :: LowerChar -> LowerChar -> Bool # max :: LowerChar -> LowerChar -> LowerChar # min :: LowerChar -> LowerChar -> LowerChar #
Show LowerChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> LowerChar -> ShowS # show :: LowerChar -> String # showList :: [LowerChar] -> ShowS #

lowerToChar :: LowerChar -> Char Source #

lowers :: Map LowerChar Char Source #

lowerChar :: CodeParsing m => m LowerChar Source #

charToLower :: Char -> Maybe LowerChar Source #

lowerCharQ :: QuasiQuoter Source #

Extracts a Char of [a-z]. Also throws compile error if non [a-z] is passed.

>>> [lowerCharQ|x|]
X_

>>> [lowerCharQ|y|]
Y_

data DigitChar Source #

0-9

Constructors

D0
D1
D2
D3
D4
D5
D6
D7
D8
D9

Instances

Eq DigitChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: DigitChar -> DigitChar -> Bool # (/=) :: DigitChar -> DigitChar -> Bool #
Ord DigitChar Source #
Instance details Defined in Data.Char.Cases Methods compare :: DigitChar -> DigitChar -> Ordering # (<) :: DigitChar -> DigitChar -> Bool # (<=) :: DigitChar -> DigitChar -> Bool # (>) :: DigitChar -> DigitChar -> Bool # (>=) :: DigitChar -> DigitChar -> Bool # max :: DigitChar -> DigitChar -> DigitChar # min :: DigitChar -> DigitChar -> DigitChar #
Show DigitChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> DigitChar -> ShowS # show :: DigitChar -> String # showList :: [DigitChar] -> ShowS #

digitToChar :: DigitChar -> Char Source #

digits :: Map DigitChar Char Source #

digitChar :: CodeParsing m => m DigitChar Source #

charToDigit :: Char -> Maybe DigitChar Source #

digitCharQ :: QuasiQuoter Source #

Extracts a Char of [0-9]. Also throws compile error if non [a-z] is passed.

>>> [digitCharQ|0|]
D0

>>> [digitCharQ|9|]
D9

data SneakChar Source #

a-zA-Z0-9_

Please see Sneak.

Constructors

SneakUnderscore	_
SneakAlphaNum AlphaNumChar	a-zA-Z0-9

Instances

Eq SneakChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: SneakChar -> SneakChar -> Bool # (/=) :: SneakChar -> SneakChar -> Bool #
Show SneakChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> SneakChar -> ShowS # show :: SneakChar -> String # showList :: [SneakChar] -> ShowS #

unSneakChar :: SneakChar -> Char Source #

sneakChar :: CodeParsing m => m SneakChar Source #

charToSneak :: Char -> Maybe SneakChar Source #

sneakCharQ :: QuasiQuoter Source #

Extracts a Char of [a-zA-Z0-9_]. Also throws compile error if non [a-zA-Z0-9_] is passed.

>>> [sneakCharQ|x|]
SneakAlphaNum (AlphaNumAlpha (AlphaLower X_))

>>> [sneakCharQ|X|]
SneakAlphaNum (AlphaNumAlpha (AlphaUpper X))

>>> [sneakCharQ|_|]
SneakUnderscore

>>> [sneakCharQ|9|]
SneakAlphaNum (AlphaNumDigit D9)

data SneakHeadChar Source #

a-zA-Z_

Please see Sneak.

Constructors

SneakHeadUnderscore
SneakHeadAlpha AlphaChar

Instances

Eq SneakHeadChar Source #
Instance details Defined in Data.Char.Cases Methods (==) :: SneakHeadChar -> SneakHeadChar -> Bool # (/=) :: SneakHeadChar -> SneakHeadChar -> Bool #
Show SneakHeadChar Source #
Instance details Defined in Data.Char.Cases Methods showsPrec :: Int -> SneakHeadChar -> ShowS # show :: SneakHeadChar -> String # showList :: [SneakHeadChar] -> ShowS #

unSneakHeadChar :: SneakHeadChar -> Char Source #

sneakHeadChar :: CodeParsing m => m SneakHeadChar Source #

charToSneakHead :: Char -> Maybe SneakHeadChar Source #

sneakHeadCharQ :: QuasiQuoter Source #

Extracts a Char of [a-zA-Z_]. Also throws compile error if non [a-zA-Z_] is passed.

>>> [sneakHeadCharQ|x|]
SneakHeadAlpha (AlphaLower X_)

>>> [sneakHeadCharQ|X|]
SneakHeadAlpha (AlphaUpper X)

>>> [sneakHeadCharQ|_|]
SneakHeadUnderscore