module ASCII.QuasiQuoters
(
char,
string,
caseless,
upper,
lower,
)
where
import ASCII.Case (Case (..))
import ASCII.Caseless (CaselessChar)
import ASCII.Char (Char)
import Control.Monad (return, (>=>))
import Control.Monad.Fail (MonadFail, fail)
import Data.Maybe (Maybe (..))
import Language.Haskell.TH.Quote (QuasiQuoter (..))
import Language.Haskell.TH.Syntax (Exp, Pat, Q)
import qualified ASCII.Superset as S
import qualified ASCII.TemplateHaskell as TH
import qualified Data.Char as Unicode
import qualified Data.String as Unicode
char :: QuasiQuoter
char :: QuasiQuoter
char = forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q Char
requireOneAscii Char -> Q Exp
TH.isCharExp Char -> Q Pat
TH.isCharPat
string :: QuasiQuoter
string :: QuasiQuoter
string = forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q [Char]
requireAsciiList [Char] -> Q Exp
TH.isStringExp [Char] -> Q Pat
TH.isStringPat
caseless :: QuasiQuoter
caseless :: QuasiQuoter
caseless = forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q [CaselessChar]
requireAsciiListCI [CaselessChar] -> Q Exp
TH.caselessListExp [CaselessChar] -> Q Pat
TH.caselessIsStringPat
lower :: QuasiQuoter
lower :: QuasiQuoter
lower = forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q [CaselessChar]
requireAsciiListCI [CaselessChar] -> Q Exp
TH.lowerStringExp
(\[CaselessChar]
x -> [Char] -> Q Pat
TH.isStringPat (forall (letterCase :: Case) string.
ToCasefulString letterCase string =>
[CaselessChar] -> string
S.toCasefulString @'LowerCase [CaselessChar]
x))
upper :: QuasiQuoter
upper :: QuasiQuoter
upper = forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q [CaselessChar]
requireAsciiListCI [CaselessChar] -> Q Exp
TH.upperStringExp
(\[CaselessChar]
x -> [Char] -> Q Pat
TH.isStringPat (forall (letterCase :: Case) string.
ToCasefulString letterCase string =>
[CaselessChar] -> string
S.toCasefulString @'UpperCase [CaselessChar]
x))
requireOneAscii :: Unicode.String -> Q Char
requireOneAscii :: String -> Q Char
requireOneAscii = String -> Q Char
requireOne forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Char -> Q Char
requireAscii
oneMaybe :: [a] -> Maybe a
oneMaybe :: forall a. [a] -> Maybe a
oneMaybe [a]
xs = case [a]
xs of [a
x] -> forall a. a -> Maybe a
Just a
x; [a]
_ -> forall a. Maybe a
Nothing
requireOne :: Unicode.String -> Q Unicode.Char
requireOne :: String -> Q Char
requireOne = forall a. [a] -> Maybe a
oneMaybe forall a b. (a -> Maybe b) -> String -> a -> Q b
|| String
"Must be exactly one character."
requireAscii :: Unicode.Char -> Q Char
requireAscii :: Char -> Q Char
requireAscii = forall char. ToChar char => char -> Maybe Char
S.toCharMaybe forall a b. (a -> Maybe b) -> String -> a -> Q b
|| String
"Must be an ASCII character."
requireAsciiList :: Unicode.String -> Q [Char]
requireAsciiList :: String -> Q [Char]
requireAsciiList = forall string. ToString string => string -> Maybe [Char]
S.toCharListMaybe forall a b. (a -> Maybe b) -> String -> a -> Q b
|| String
"Must be only ASCII characters."
requireAsciiListCI :: Unicode.String -> Q [CaselessChar]
requireAsciiListCI :: String -> Q [CaselessChar]
requireAsciiListCI = forall string.
ToCaselessString string =>
string -> Maybe [CaselessChar]
S.toCaselessCharListMaybe forall a b. (a -> Maybe b) -> String -> a -> Q b
|| String
"Must be only ASCII characters."
(||) :: (a -> Maybe b) -> Unicode.String -> a -> Q b
a -> Maybe b
f || :: forall a b. (a -> Maybe b) -> String -> a -> Q b
|| String
msg = \a
a -> case a -> Maybe b
f a
a of Just b
b -> forall (m :: * -> *) a. Monad m => a -> m a
return b
b; Maybe b
Nothing -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
msg
expPatQQ :: (Unicode.String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ :: forall a.
(String -> Q a) -> (a -> Q Exp) -> (a -> Q Pat) -> QuasiQuoter
expPatQQ String -> Q a
f a -> Q Exp
a a -> Q Pat
b = QuasiQuoter
{ quoteExp :: String -> Q Exp
quoteExp = String -> Q a
f forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> a -> Q Exp
a
, quotePat :: String -> Q Pat
quotePat = String -> Q a
f forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> a -> Q Pat
b
, quoteType :: String -> Q Type
quoteType = forall (m :: * -> *) a b. MonadFail m => a -> m b
notType
, quoteDec :: String -> Q [Dec]
quoteDec = forall (m :: * -> *) a b. MonadFail m => a -> m b
notDec
}
notType :: MonadFail m => a -> m b
notType :: forall (m :: * -> *) a b. MonadFail m => a -> m b
notType a
_ = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Cannot be used in a type context."
notDec :: MonadFail m => a -> m b
notDec :: forall (m :: * -> *) a b. MonadFail m => a -> m b
notDec a
_ = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Cannot be used in a declaration context."