    {-# LANGUAGE DeriveDataTypeable    #-}
    {-# LANGUAGE DeriveGeneric         #-}
    {-# LANGUAGE DeriveTraversable     #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE RankNTypes            #-}
    {-# LANGUAGE ScopedTypeVariables   #-}
    {-# LANGUAGE TypeFamilies          #-}
    {-# LANGUAGE NamedFieldPuns #-}

    module Servant.Client.Core.Response (
        Response,
        StreamingResponse,
        ResponseF (..),
        responseToInternalResponse,
        ) where

    import           Prelude ()
    import           Prelude.Compat

    import           Control.DeepSeq
                     (NFData (..))
    import qualified Data.ByteString      as BS
    import qualified Data.ByteString.Lazy as LBS
    import qualified Data.Sequence        as Seq
    import           Data.Typeable
                     (Typeable)
    import           GHC.Generics
                     (Generic)
    import           Network.HTTP.Types
                     (Header, HttpVersion (..), Status (..))

    import           Servant.API.Stream
                     (SourceIO)
    import           Servant.Types.Internal.Response

    data ResponseF a = Response
      { forall a. ResponseF a -> Status
    responseStatusCode  :: Status
      , forall a. ResponseF a -> Seq Header
    responseHeaders     :: Seq.Seq Header
      , forall a. ResponseF a -> HttpVersion
    responseHttpVersion :: HttpVersion
      , forall a. ResponseF a -> a
    responseBody        :: a
      } deriving (ResponseF a -> ResponseF a -> Bool
    (ResponseF a -> ResponseF a -> Bool)
    -> (ResponseF a -> ResponseF a -> Bool) -> Eq (ResponseF a)
    forall a. Eq a => ResponseF a -> ResponseF a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => ResponseF a -> ResponseF a -> Bool
    == :: ResponseF a -> ResponseF a -> Bool
    $c/= :: forall a. Eq a => ResponseF a -> ResponseF a -> Bool
    /= :: ResponseF a -> ResponseF a -> Bool
    Eq, Int -> ResponseF a -> ShowS
    [ResponseF a] -> ShowS
    ResponseF a -> String
    (Int -> ResponseF a -> ShowS)
    -> (ResponseF a -> String)
    -> ([ResponseF a] -> ShowS)
    -> Show (ResponseF a)
    forall a. Show a => Int -> ResponseF a -> ShowS
    forall a. Show a => [ResponseF a] -> ShowS
    forall a. Show a => ResponseF a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> ResponseF a -> ShowS
    showsPrec :: Int -> ResponseF a -> ShowS
    $cshow :: forall a. Show a => ResponseF a -> String
    show :: ResponseF a -> String
    $cshowList :: forall a. Show a => [ResponseF a] -> ShowS
    showList :: [ResponseF a] -> ShowS
    Show, (forall x. ResponseF a -> Rep (ResponseF a) x)
    -> (forall x. Rep (ResponseF a) x -> ResponseF a)
    -> Generic (ResponseF a)
    forall x. Rep (ResponseF a) x -> ResponseF a
    forall x. ResponseF a -> Rep (ResponseF a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (ResponseF a) x -> ResponseF a
    forall a x. ResponseF a -> Rep (ResponseF a) x
    $cfrom :: forall a x. ResponseF a -> Rep (ResponseF a) x
    from :: forall x. ResponseF a -> Rep (ResponseF a) x
    $cto :: forall a x. Rep (ResponseF a) x -> ResponseF a
    to :: forall x. Rep (ResponseF a) x -> ResponseF a
    Generic, Typeable, (forall a b. (a -> b) -> ResponseF a -> ResponseF b)
    -> (forall a b. a -> ResponseF b -> ResponseF a)
    -> Functor ResponseF
    forall a b. a -> ResponseF b -> ResponseF a
    forall a b. (a -> b) -> ResponseF a -> ResponseF b
    forall (f :: Type -> Type).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> ResponseF a -> ResponseF b
    fmap :: forall a b. (a -> b) -> ResponseF a -> ResponseF b
    $c<$ :: forall a b. a -> ResponseF b -> ResponseF a
    <$ :: forall a b. a -> ResponseF b -> ResponseF a
    Functor, (forall m. Monoid m => ResponseF m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ResponseF a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ResponseF a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ResponseF a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ResponseF a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ResponseF a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ResponseF a -> b)
    -> (forall a. (a -> a -> a) -> ResponseF a -> a)
    -> (forall a. (a -> a -> a) -> ResponseF a -> a)
    -> (forall a. ResponseF a -> [a])
    -> (forall a. ResponseF a -> Bool)
    -> (forall a. ResponseF a -> Int)
    -> (forall a. Eq a => a -> ResponseF a -> Bool)
    -> (forall a. Ord a => ResponseF a -> a)
    -> (forall a. Ord a => ResponseF a -> a)
    -> (forall a. Num a => ResponseF a -> a)
    -> (forall a. Num a => ResponseF a -> a)
    -> Foldable ResponseF
    forall a. Eq a => a -> ResponseF a -> Bool
    forall a. Num a => ResponseF a -> a
    forall a. Ord a => ResponseF a -> a
    forall m. Monoid m => ResponseF m -> m
    forall a. ResponseF a -> Bool
    forall a. ResponseF a -> Int
    forall a. ResponseF a -> [a]
    forall a. (a -> a -> a) -> ResponseF a -> a
    forall m a. Monoid m => (a -> m) -> ResponseF a -> m
    forall b a. (b -> a -> b) -> b -> ResponseF a -> b
    forall a b. (a -> b -> b) -> b -> ResponseF a -> b
    forall (t :: Type -> Type).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ResponseF m -> m
    fold :: forall m. Monoid m => ResponseF m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ResponseF a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ResponseF a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ResponseF a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ResponseF a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ResponseF a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ResponseF a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ResponseF a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ResponseF a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ResponseF a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ResponseF a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ResponseF a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ResponseF a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ResponseF a -> a
    foldr1 :: forall a. (a -> a -> a) -> ResponseF a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ResponseF a -> a
    foldl1 :: forall a. (a -> a -> a) -> ResponseF a -> a
    $ctoList :: forall a. ResponseF a -> [a]
    toList :: forall a. ResponseF a -> [a]
    $cnull :: forall a. ResponseF a -> Bool
    null :: forall a. ResponseF a -> Bool
    $clength :: forall a. ResponseF a -> Int
    length :: forall a. ResponseF a -> Int
    $celem :: forall a. Eq a => a -> ResponseF a -> Bool
    elem :: forall a. Eq a => a -> ResponseF a -> Bool
    $cmaximum :: forall a. Ord a => ResponseF a -> a
    maximum :: forall a. Ord a => ResponseF a -> a
    $cminimum :: forall a. Ord a => ResponseF a -> a
    minimum :: forall a. Ord a => ResponseF a -> a
    $csum :: forall a. Num a => ResponseF a -> a
    sum :: forall a. Num a => ResponseF a -> a
    $cproduct :: forall a. Num a => ResponseF a -> a
    product :: forall a. Num a => ResponseF a -> a
    Foldable, Functor ResponseF
    Foldable ResponseF
    (Functor ResponseF, Foldable ResponseF) =>
    (forall (f :: Type -> Type) a b.
     Applicative f =>
     (a -> f b) -> ResponseF a -> f (ResponseF b))
    -> (forall (f :: Type -> Type) a.
        Applicative f =>
        ResponseF (f a) -> f (ResponseF a))
    -> (forall (m :: Type -> Type) a b.
        Monad m =>
        (a -> m b) -> ResponseF a -> m (ResponseF b))
    -> (forall (m :: Type -> Type) a.
        Monad m =>
        ResponseF (m a) -> m (ResponseF a))
    -> Traversable ResponseF
    forall (t :: Type -> Type).
    (Functor t, Foldable t) =>
    (forall (f :: Type -> Type) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: Type -> Type) a.
        Applicative f =>
        t (f a) -> f (t a))
    -> (forall (m :: Type -> Type) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: Type -> Type) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: Type -> Type) a.
    Monad m =>
    ResponseF (m a) -> m (ResponseF a)
    forall (f :: Type -> Type) a.
    Applicative f =>
    ResponseF (f a) -> f (ResponseF a)
    forall (m :: Type -> Type) a b.
    Monad m =>
    (a -> m b) -> ResponseF a -> m (ResponseF b)
    forall (f :: Type -> Type) a b.
    Applicative f =>
    (a -> f b) -> ResponseF a -> f (ResponseF b)
    $ctraverse :: forall (f :: Type -> Type) a b.
    Applicative f =>
    (a -> f b) -> ResponseF a -> f (ResponseF b)
    traverse :: forall (f :: Type -> Type) a b.
    Applicative f =>
    (a -> f b) -> ResponseF a -> f (ResponseF b)
    $csequenceA :: forall (f :: Type -> Type) a.
    Applicative f =>
    ResponseF (f a) -> f (ResponseF a)
    sequenceA :: forall (f :: Type -> Type) a.
    Applicative f =>
    ResponseF (f a) -> f (ResponseF a)
    $cmapM :: forall (m :: Type -> Type) a b.
    Monad m =>
    (a -> m b) -> ResponseF a -> m (ResponseF b)
    mapM :: forall (m :: Type -> Type) a b.
    Monad m =>
    (a -> m b) -> ResponseF a -> m (ResponseF b)
    $csequence :: forall (m :: Type -> Type) a.
    Monad m =>
    ResponseF (m a) -> m (ResponseF a)
    sequence :: forall (m :: Type -> Type) a.
    Monad m =>
    ResponseF (m a) -> m (ResponseF a)
    Traversable)

    instance NFData a => NFData (ResponseF a) where
        rnf :: ResponseF a -> ()
    rnf (Response Status
    sc Seq Header
    hs HttpVersion
    hv a
    body) =
            Status -> ()
    rnfStatus Status
    sc () -> () -> ()
    forall a b. a -> b -> b
    `seq`
            Seq Header -> ()
    forall a. NFData a => a -> ()
    rnf Seq Header
    hs () -> () -> ()
    forall a b. a -> b -> b
    `seq`
            HttpVersion -> ()
    rnfHttpVersion HttpVersion
    hv () -> () -> ()
    forall a b. a -> b -> b
    `seq`
            a -> ()
    forall a. NFData a => a -> ()
    rnf a
    body
          where
            rnfStatus :: Status -> ()
    rnfStatus (Status Int
    code ByteString
    msg) = Int -> ()
    forall a. NFData a => a -> ()
    rnf Int
    code () -> () -> ()
    forall a b. a -> b -> b
    `seq` ByteString -> ()
    forall a. NFData a => a -> ()
    rnf ByteString
    msg
            rnfHttpVersion :: HttpVersion -> ()
    rnfHttpVersion (HttpVersion Int
    _ Int
    _) = () -- HttpVersion fields are strict

    type Response = ResponseF LBS.ByteString
    type StreamingResponse = ResponseF (SourceIO BS.ByteString)

    responseToInternalResponse :: ResponseF a -> InternalResponse a
    responseToInternalResponse :: forall a. ResponseF a -> InternalResponse a
    responseToInternalResponse Response{Status
    responseStatusCode :: forall a. ResponseF a -> Status
    responseStatusCode :: Status
    responseStatusCode, Seq Header
    responseHeaders :: forall a. ResponseF a -> Seq Header
    responseHeaders :: Seq Header
    responseHeaders,a
    responseBody :: forall a. ResponseF a -> a
    responseBody :: a
    responseBody} =
        Status -> Seq Header -> a -> InternalResponse a
    forall a. Status -> Seq Header -> a -> InternalResponse a
    InternalResponse Status
    responseStatusCode Seq Header
    responseHeaders a
    responseBody