module ASCII.TemplateHaskell
(
charExp, charPat,
charListExp, charListPat,
caselessListExp, caselessListPat,
isCharExp, isCharPat,
isStringExp, isStringPat,
caselessIsStringPat,
upperStringExp, lowerStringExp,
)
where
import qualified ASCII.Char as ASCII
import qualified ASCII.Superset as S
import ASCII.Case (Case (..))
import ASCII.Caseless (CaselessChar)
import Data.Data (Data)
import Data.Maybe (Maybe (..))
import Language.Haskell.TH.Syntax (Exp, Pat, Q, dataToExpQ, dataToPatQ)
exp :: Data a => a -> Q Exp
exp :: forall a. Data a => a -> Q Exp
exp = forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Exp)) -> a -> m Exp
dataToExpQ (\b
_ -> forall a. Maybe a
Nothing)
pat :: Data a => a -> Q Pat
pat :: forall a. Data a => a -> Q Pat
pat = forall (m :: * -> *) a.
(Quote m, Data a) =>
(forall b. Data b => b -> Maybe (m Pat)) -> a -> m Pat
dataToPatQ (\b
_ -> forall a. Maybe a
Nothing)
charExp :: ASCII.Char -> Q Exp
charExp :: Char -> Q Exp
charExp = forall a. Data a => a -> Q Exp
exp
charPat :: ASCII.Char -> Q Pat
charPat :: Char -> Q Pat
charPat = forall a. Data a => a -> Q Pat
pat
charListExp :: [ASCII.Char] -> Q Exp
charListExp :: [Char] -> Q Exp
charListExp = forall a. Data a => a -> Q Exp
exp
charListPat :: [ASCII.Char] -> Q Pat
charListPat :: [Char] -> Q Pat
charListPat = forall a. Data a => a -> Q Pat
pat
caselessListExp :: [CaselessChar] -> Q Exp
caselessListExp :: [CaselessChar] -> Q Exp
caselessListExp = forall a. Data a => a -> Q Exp
exp
caselessListPat :: [CaselessChar] -> Q Pat
caselessListPat :: [CaselessChar] -> Q Pat
caselessListPat = forall a. Data a => a -> Q Pat
pat
isCharExp :: ASCII.Char -> Q Exp
isCharExp :: Char -> Q Exp
isCharExp Char
x = [| S.fromChar $(charExp x) |]
isCharPat :: ASCII.Char -> Q Pat
isCharPat :: Char -> Q Pat
isCharPat Char
x = [p| (S.toCharMaybe -> Just $(charPat x)) |]
isStringExp :: [ASCII.Char] -> Q Exp
isStringExp :: [Char] -> Q Exp
isStringExp [Char]
xs = [| S.fromCharList $(charListExp xs) |]
isStringPat :: [ASCII.Char] -> Q Pat
isStringPat :: [Char] -> Q Pat
isStringPat [Char]
xs = [p| (S.toCharListMaybe -> Just $(charListPat xs)) |]
caselessIsStringPat :: [CaselessChar] -> Q Pat
caselessIsStringPat :: [CaselessChar] -> Q Pat
caselessIsStringPat [CaselessChar]
xs = [p| (S.toCaselessCharListMaybe -> Just $(caselessListPat xs)) |]
upperStringExp :: [CaselessChar] -> Q Exp
upperStringExp :: [CaselessChar] -> Q Exp
upperStringExp [CaselessChar]
xs = [| toUpper $(caselessListExp xs) |]
lowerStringExp :: [CaselessChar] -> Q Exp
lowerStringExp :: [CaselessChar] -> Q Exp
lowerStringExp [CaselessChar]
xs = [| toLower $(caselessListExp xs) |]
toUpper :: S.ToCasefulString 'UpperCase string => [CaselessChar] -> string
toUpper :: forall string.
ToCasefulString 'UpperCase string =>
[CaselessChar] -> string
toUpper = forall (letterCase :: Case) string.
ToCasefulString letterCase string =>
[CaselessChar] -> string
S.toCasefulString @'UpperCase
toLower :: S.ToCasefulString 'LowerCase string => [CaselessChar] -> string
toLower :: forall string.
ToCasefulString 'LowerCase string =>
[CaselessChar] -> string
toLower = forall (letterCase :: Case) string.
ToCasefulString letterCase string =>
[CaselessChar] -> string
S.toCasefulString @'LowerCase