| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Web.Internal.HttpApiData
Description
Convert Haskell values to and from HTTP API data such as URL pieces, headers and query parameters.
Synopsis
- class ToHttpApiData a where
- toUrlPiece :: a -> Text
- toEncodedUrlPiece :: a -> Builder
- toHeader :: a -> ByteString
- toQueryParam :: a -> Text
- class FromHttpApiData a where
- parseUrlPiece :: Text -> Either Text a
- parseHeader :: ByteString -> Either Text a
- parseQueryParam :: Text -> Either Text a
- toUrlPieces :: (Functor t, ToHttpApiData a) => t a -> t Text
- parseUrlPieces :: (Traversable t, FromHttpApiData a) => t Text -> Either Text (t a)
- toQueryParams :: (Functor t, ToHttpApiData a) => t a -> t Text
- parseQueryParams :: (Traversable t, FromHttpApiData a) => t Text -> Either Text (t a)
- parseUrlPieceMaybe :: FromHttpApiData a => Text -> Maybe a
- parseHeaderMaybe :: FromHttpApiData a => ByteString -> Maybe a
- parseQueryParamMaybe :: FromHttpApiData a => Text -> Maybe a
- defaultParseError :: Text -> Either Text a
- parseMaybeTextData :: (Text -> Maybe a) -> Text -> Either Text a
- showTextData :: Show a => a -> Text
- showt :: Show a => a -> Text
- parseUrlPieceWithPrefix :: FromHttpApiData a => Text -> Text -> Either Text a
- parseHeaderWithPrefix :: FromHttpApiData a => ByteString -> ByteString -> Either Text a
- parseQueryParamWithPrefix :: FromHttpApiData a => Text -> Text -> Either Text a
- parseBoundedTextData :: (Show a, Bounded a, Enum a) => Text -> Either Text a
- lookupBoundedEnumOf :: (Bounded a, Enum a, Eq b) => (a -> b) -> b -> Maybe a
- parseBoundedEnumOf :: (Bounded a, Enum a) => (a -> Text) -> Text -> Either Text a
- parseBoundedEnumOfI :: (Bounded a, Enum a) => (a -> Text) -> Text -> Either Text a
- parseBoundedUrlPiece :: (ToHttpApiData a, Bounded a, Enum a) => Text -> Either Text a
- parseBoundedQueryParam :: (ToHttpApiData a, Bounded a, Enum a) => Text -> Either Text a
- parseBoundedHeader :: (ToHttpApiData a, Bounded a, Enum a) => ByteString -> Either Text a
- readTextData :: Read a => Text -> Either Text a
- runReader :: Reader a -> Text -> Either Text a
- parseBounded :: forall a. (Bounded a, Integral a) => Reader Integer -> Text -> Either Text a
- unsafeToEncodedUrlPiece :: ToHttpApiData a => a -> Builder
- timeToUrlPiece :: FormatTime t => String -> t -> Text
- nominalDiffTimeToSecs :: NominalDiffTime -> Pico
- secsToNominalDiffTime :: Pico -> NominalDiffTime
- newtype LenientData a = LenientData {
- getLenientData :: Either Text a
- runAtto :: Parser a -> Text -> Either Text a
Documentation
>>>data BasicAuthToken = BasicAuthToken Text deriving (Show)>>>instance FromHttpApiData BasicAuthToken where parseHeader h = BasicAuthToken <$> parseHeaderWithPrefix "Basic " h; parseQueryParam p = BasicAuthToken <$> parseQueryParam p>>>import Data.Time>>>import Data.Version
class ToHttpApiData a where Source #
Convert value to HTTP API data.
WARNING: Do not derive this using DeriveAnyClass as the generated
instance will loop indefinitely.
Minimal complete definition
Methods
toUrlPiece :: a -> Text Source #
Convert to URL path piece.
toEncodedUrlPiece :: a -> Builder Source #
Convert to a URL path piece, making sure to encode any special chars.
The default definition uses encodePathSegmentsRelative,
but this may be overriden with a more efficient version.
toHeader :: a -> ByteString Source #
Convert to HTTP header value.
toQueryParam :: a -> Text Source #
Convert to query param value.
Instances
class FromHttpApiData a where Source #
Parse value from HTTP API data.
WARNING: Do not derive this using DeriveAnyClass as the generated
instance will loop indefinitely.
Minimal complete definition
Methods
parseUrlPiece :: Text -> Either Text a Source #
Parse URL path piece.
parseHeader :: ByteString -> Either Text a Source #
Parse HTTP header value.
parseQueryParam :: Text -> Either Text a Source #
Parse query param value.
Instances
toUrlPieces :: (Functor t, ToHttpApiData a) => t a -> t Text Source #
Convert multiple values to a list of URL pieces.
>>>toUrlPieces [1, 2, 3] :: [Text]["1","2","3"]
parseUrlPieces :: (Traversable t, FromHttpApiData a) => t Text -> Either Text (t a) Source #
Parse multiple URL pieces.
>>>parseUrlPieces ["true", "false"] :: Either Text [Bool]Right [True,False]>>>parseUrlPieces ["123", "hello", "world"] :: Either Text [Int]Left "could not parse: `hello' (input does not start with a digit)"
toQueryParams :: (Functor t, ToHttpApiData a) => t a -> t Text Source #
Convert multiple values to a list of query parameter values.
>>>toQueryParams [fromGregorian 2015 10 03, fromGregorian 2015 12 01] :: [Text]["2015-10-03","2015-12-01"]
parseQueryParams :: (Traversable t, FromHttpApiData a) => t Text -> Either Text (t a) Source #
Parse multiple query parameters.
>>>parseQueryParams ["1", "2", "3"] :: Either Text [Int]Right [1,2,3]>>>parseQueryParams ["64", "128", "256"] :: Either Text [Word8]Left "out of bounds: `256' (should be between 0 and 255)"
parseUrlPieceMaybe :: FromHttpApiData a => Text -> Maybe a Source #
Parse URL path piece in a Maybe
>>>parseUrlPieceMaybe "12" :: Maybe IntJust 12
parseHeaderMaybe :: FromHttpApiData a => ByteString -> Maybe a Source #
Parse HTTP header value in a Maybe
>>>parseHeaderMaybe "hello" :: Maybe TextJust "hello"
parseQueryParamMaybe :: FromHttpApiData a => Text -> Maybe a Source #
Parse query param value in a Maybe
>>>parseQueryParamMaybe "true" :: Maybe BoolJust True
showTextData :: Show a => a -> Text Source #
Lower case.
Convert to URL piece using Show
>>>showTextData True"true"
This can be used as a default implementation for enumeration types:
>>>data MyData = Foo | Bar | Baz deriving (Show)>>>instance ToHttpApiData MyData where toUrlPiece = showTextData>>>toUrlPiece Foo"foo"
parseUrlPieceWithPrefix :: FromHttpApiData a => Text -> Text -> Either Text a Source #
Case insensitive.
Parse given text case insensitive and then parse the rest of the input
using parseUrlPiece
>>>parseUrlPieceWithPrefix "Just " "just 10" :: Either Text IntRight 10>>>parseUrlPieceWithPrefix "Left " "left" :: Either Text BoolLeft "could not parse: `left'"
This can be used to implement FromHttpApiData
>>>data Foo = Foo Int deriving (Show)>>>instance FromHttpApiData Foo where parseUrlPiece s = Foo <$> parseUrlPieceWithPrefix "Foo " s>>>parseUrlPiece "foo 1" :: Either Text FooRight (Foo 1)
parseHeaderWithPrefix :: FromHttpApiData a => ByteString -> ByteString -> Either Text a Source #
Parse given bytestring then parse the rest of the input using parseHeader
data BasicAuthToken = BasicAuthToken Text deriving (Show) instance FromHttpApiData BasicAuthToken where parseHeader h = BasicAuthToken <$> parseHeaderWithPrefix "Basic " h parseQueryParam p = BasicAuthToken <$> parseQueryParam p
>>>parseHeader "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==" :: Either Text BasicAuthTokenRight (BasicAuthToken "QWxhZGRpbjpvcGVuIHNlc2FtZQ==")
parseQueryParamWithPrefix :: FromHttpApiData a => Text -> Text -> Either Text a Source #
Case insensitive.
Parse given text case insensitive and then parse the rest of the input
using parseQueryParam
>>>parseQueryParamWithPrefix "z" "z10" :: Either Text IntRight 10
parseBoundedTextData :: (Show a, Bounded a, Enum a) => Text -> Either Text a Source #
Case insensitive.
Parse values case insensitively based on Show
>>>parseBoundedTextData "true" :: Either Text BoolRight True>>>parseBoundedTextData "FALSE" :: Either Text BoolRight False
This can be used as a default implementation for enumeration types:
>>>data MyData = Foo | Bar | Baz deriving (Show, Bounded, Enum)>>>instance FromHttpApiData MyData where parseUrlPiece = parseBoundedTextData>>>parseUrlPiece "foo" :: Either Text MyDataRight Foo
lookupBoundedEnumOf :: (Bounded a, Enum a, Eq b) => (a -> b) -> b -> Maybe a Source #
Lookup values based on a precalculated mapping of their representations.
parseBoundedEnumOf :: (Bounded a, Enum a) => (a -> Text) -> Text -> Either Text a Source #
Parse values based on a precalculated mapping of their Text
>>>parseBoundedEnumOf toUrlPiece "true" :: Either Text BoolRight True
For case sensitive parser see parseBoundedEnumOfI.
parseBoundedEnumOfI :: (Bounded a, Enum a) => (a -> Text) -> Text -> Either Text a Source #
Case insensitive.
Parse values case insensitively based on a precalculated mapping
of their Text
>>>parseBoundedEnumOfI toUrlPiece "FALSE" :: Either Text BoolRight False
For case sensitive parser see parseBoundedEnumOf.
parseBoundedUrlPiece :: (ToHttpApiData a, Bounded a, Enum a) => Text -> Either Text a Source #
Case insensitive.
Parse values case insensitively based on ToHttpApiDatatoUrlPiece
parseBoundedQueryParam :: (ToHttpApiData a, Bounded a, Enum a) => Text -> Either Text a Source #
Case insensitive.
Parse values case insensitively based on ToHttpApiDatatoQueryParam
parseBoundedHeader :: (ToHttpApiData a, Bounded a, Enum a) => ByteString -> Either Text a Source #
Parse values based on ToHttpApiDatatoHeader
readTextData :: Read a => Text -> Either Text a Source #
Parse URL piece using Read
Use for types which do not involve letters:
>>>readTextData "1991-06-02" :: Either Text DayRight 1991-06-02
This parser is case sensitive and will not match showTextData
>>>readTextData (showTextData True) :: Either Text BoolLeft "could not parse: `true'"
See parseBoundedTextData
parseBounded :: forall a. (Bounded a, Integral a) => Reader Integer -> Text -> Either Text a Source #
Run Reader
>>>parseBounded decimal "256" :: Either Text Word8Left "out of bounds: `256' (should be between 0 and 255)"
unsafeToEncodedUrlPiece :: ToHttpApiData a => a -> Builder Source #
Convert to a URL-encoded path piece using toUrlPiece.
Note: this function does not check if the result contains unescaped characters!
This function can be used to override toEncodedUrlPiece as a more efficient implementation
when the resulting URL piece never has to be escaped.
timeToUrlPiece :: FormatTime t => String -> t -> Text Source #
newtype LenientData a Source #
Lenient parameters. FromHttpApiData combinators always return Right.
Since: 0.3.5
Constructors
| LenientData | |
Fields
| |