module Network.Wai.RequestSpec.Combinators (
intQ,
boolQ,
floatQ,
textQ,
bytesQ,
textQM,
intQM,
floatQM,
bytesQM,
intF,
boolF,
floatF,
textF,
bytesF,
textFM,
intFM,
floatFM,
bytesFM,
intH,
boolH,
floatH,
textH,
bytesH,
textHM,
intHM,
floatHM,
bytesHM,
choice
) where
#if __GLASGOW_HASKELL__ < 710
import Control.Applicative
#endif
import Data.ByteString
import Data.CaseInsensitive
import Data.Foldable (asum)
import Data.Text
import Network.Wai.RequestSpec.Internal.Combinators
import Network.Wai.RequestSpec.Internal.Env
import Network.Wai.RequestSpec.Internal.Parser
intQ :: (Read a, Integral a) => Text -> Env -> P a
intQ = qParam int
boolQ :: Text -> Env -> P Bool
boolQ = qParam bool
floatQ :: (Read a, Fractional a) => Text -> Env -> P a
floatQ = qParam float
textQ :: Text -> Env -> P Text
textQ = qParam pure
bytesQ :: (Text -> ByteString) -> Text -> Env -> P ByteString
bytesQ f = qParam (pure . f)
intQM :: (Read a, Integral a) => Text -> Env -> P (Maybe a)
intQM = qParamM int
floatQM :: (Read a, Fractional a) => Text -> Env -> P (Maybe a)
floatQM = qParamM float
textQM :: Text -> Env -> P (Maybe Text)
textQM = qParamM pure
bytesQM :: (Text -> ByteString) -> Text -> Env -> P (Maybe ByteString)
bytesQM f = qParamM (pure . f)
intF :: (Read a, Integral a) => Text -> Env -> P a
intF = fParam int
boolF :: Text -> Env -> P Bool
boolF = fParam bool
floatF :: (Read a, Fractional a) => Text -> Env -> P a
floatF = fParam float
textF :: Text -> Env -> P Text
textF = fParam pure
bytesF :: (Text -> ByteString) -> Text -> Env -> P ByteString
bytesF f = fParam (pure . f)
intFM :: (Read a, Integral a) => Text -> Env -> P (Maybe a)
intFM = fParamM int
floatFM :: (Read a, Fractional a) => Text -> Env -> P (Maybe a)
floatFM = fParamM float
textFM :: Text -> Env -> P (Maybe Text)
textFM = fParamM pure
bytesFM :: (Text -> ByteString) -> Text -> Env -> P (Maybe ByteString)
bytesFM f = fParamM (pure . f)
intH :: (Integral a, Read a) => CI Text -> Env -> P a
intH = header int
boolH :: CI Text -> Env -> P Bool
boolH = header bool
floatH :: (Fractional a, Read a) => CI Text -> Env -> P a
floatH = header float
textH :: CI Text -> Env -> P Text
textH = header pure
bytesH :: (Text -> ByteString) -> CI Text -> Env -> P ByteString
bytesH f = header (pure . f)
textHM :: CI Text -> Env -> P (Maybe Text)
textHM = headerM pure
intHM :: (Integral a, Read a) => CI Text -> Env -> P (Maybe a)
intHM = headerM int
floatHM :: (Fractional a, Read a) => CI Text -> Env -> P (Maybe a)
floatHM = headerM float
bytesHM :: (Text -> ByteString) -> CI Text -> Env -> P (Maybe ByteString)
bytesHM f = headerM (pure . f)
choice :: [P a] -> P a
choice = asum