{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE OverloadedStrings #-}
module Network.HTTP.Client.Types
    ( BodyReader
    , Connection (..)
    , StatusHeaders (..)
    , HttpException (..)
    , HttpExceptionContent (..)
    , unHttpExceptionContentWrapper
    , throwHttp
    , toHttpException
    , Cookie (..)
    , CookieJar (..)
    , Proxy (..)
    , RequestBody (..)
    , Popper
    , NeedsPopper
    , GivesPopper
    , Request (..)
    , Response (..)
    , ResponseClose (..)
    , Manager (..)
    , HasHttpManager (..)
    , ConnsMap (..)
    , ManagerSettings (..)
    , NonEmptyList (..)
    , ConnHost (..)
    , ConnKey (..)
    , ProxyOverride (..)
    , StreamFileStatus (..)
    , ResponseTimeout (..)
    ) where

import qualified Data.Typeable as T (Typeable)
import Network.HTTP.Types
import Control.Exception (Exception, SomeException, throwIO)
import Data.Word (Word64)
import qualified Data.ByteString as S
import qualified Data.ByteString.Lazy as L
import Blaze.ByteString.Builder (Builder, fromLazyByteString, fromByteString, toLazyByteString)
import Data.Int (Int64)
import Data.Foldable (Foldable)
import Data.Monoid (Monoid(..))
import Data.Semigroup (Semigroup(..))
import Data.String (IsString, fromString)
import Data.Time (UTCTime)
import Data.Traversable (Traversable)
import qualified Data.List as DL
import Network.Socket (HostAddress)
import Data.IORef
import qualified Network.Socket as NS
import qualified Data.Map as Map
import Data.Text (Text)
import Data.Streaming.Zlib (ZlibException)
import Data.CaseInsensitive as CI
import Data.KeyedPool (KeyedPool)

-- | An @IO@ action that represents an incoming response body coming from the
-- server. Data provided by this action has already been gunzipped and
-- de-chunked, and respects any content-length headers present.
--
-- The action gets a single chunk of data from the response body, or an empty
-- bytestring if no more data is available.
--
-- Since 0.4.0
type BodyReader = IO S.ByteString

data Connection = Connection
    { Connection -> IO ByteString
connectionRead :: IO S.ByteString
      -- ^ If no more data, return empty.
    , Connection -> ByteString -> IO ()
connectionUnread :: S.ByteString -> IO ()
      -- ^ Return data to be read next time.
    , Connection -> ByteString -> IO ()
connectionWrite :: S.ByteString -> IO ()
      -- ^ Send data to server
    , Connection -> IO ()
connectionClose :: IO ()
      -- ^ Close connection. Any successive operation on the connection
      -- (except closing) should fail with `ConnectionClosed` exception.
      -- It is allowed to close connection multiple times.
    }
    deriving T.Typeable

data StatusHeaders = StatusHeaders Status HttpVersion RequestHeaders
    deriving (Int -> StatusHeaders -> ShowS
[StatusHeaders] -> ShowS
StatusHeaders -> String
(Int -> StatusHeaders -> ShowS)
-> (StatusHeaders -> String)
-> ([StatusHeaders] -> ShowS)
-> Show StatusHeaders
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StatusHeaders] -> ShowS
$cshowList :: [StatusHeaders] -> ShowS
show :: StatusHeaders -> String
$cshow :: StatusHeaders -> String
showsPrec :: Int -> StatusHeaders -> ShowS
$cshowsPrec :: Int -> StatusHeaders -> ShowS
Show, StatusHeaders -> StatusHeaders -> Bool
(StatusHeaders -> StatusHeaders -> Bool)
-> (StatusHeaders -> StatusHeaders -> Bool) -> Eq StatusHeaders
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StatusHeaders -> StatusHeaders -> Bool
$c/= :: StatusHeaders -> StatusHeaders -> Bool
== :: StatusHeaders -> StatusHeaders -> Bool
$c== :: StatusHeaders -> StatusHeaders -> Bool
Eq, Eq StatusHeaders
Eq StatusHeaders
-> (StatusHeaders -> StatusHeaders -> Ordering)
-> (StatusHeaders -> StatusHeaders -> Bool)
-> (StatusHeaders -> StatusHeaders -> Bool)
-> (StatusHeaders -> StatusHeaders -> Bool)
-> (StatusHeaders -> StatusHeaders -> Bool)
-> (StatusHeaders -> StatusHeaders -> StatusHeaders)
-> (StatusHeaders -> StatusHeaders -> StatusHeaders)
-> Ord StatusHeaders
StatusHeaders -> StatusHeaders -> Bool
StatusHeaders -> StatusHeaders -> Ordering
StatusHeaders -> StatusHeaders -> StatusHeaders
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: StatusHeaders -> StatusHeaders -> StatusHeaders
$cmin :: StatusHeaders -> StatusHeaders -> StatusHeaders
max :: StatusHeaders -> StatusHeaders -> StatusHeaders
$cmax :: StatusHeaders -> StatusHeaders -> StatusHeaders
>= :: StatusHeaders -> StatusHeaders -> Bool
$c>= :: StatusHeaders -> StatusHeaders -> Bool
> :: StatusHeaders -> StatusHeaders -> Bool
$c> :: StatusHeaders -> StatusHeaders -> Bool
<= :: StatusHeaders -> StatusHeaders -> Bool
$c<= :: StatusHeaders -> StatusHeaders -> Bool
< :: StatusHeaders -> StatusHeaders -> Bool
$c< :: StatusHeaders -> StatusHeaders -> Bool
compare :: StatusHeaders -> StatusHeaders -> Ordering
$ccompare :: StatusHeaders -> StatusHeaders -> Ordering
$cp1Ord :: Eq StatusHeaders
Ord, T.Typeable)

-- | A newtype wrapper which is not exported from this library but is an
-- instance of @Exception@. This allows @HttpExceptionContent@ to be thrown
-- (via this wrapper), but users of the library can't accidentally try to catch
-- it (when they /should/ be trying to catch 'HttpException').
--
-- @since 0.5.0
newtype HttpExceptionContentWrapper = HttpExceptionContentWrapper
    { HttpExceptionContentWrapper -> HttpExceptionContent
unHttpExceptionContentWrapper :: HttpExceptionContent
    }
    deriving (Int -> HttpExceptionContentWrapper -> ShowS
[HttpExceptionContentWrapper] -> ShowS
HttpExceptionContentWrapper -> String
(Int -> HttpExceptionContentWrapper -> ShowS)
-> (HttpExceptionContentWrapper -> String)
-> ([HttpExceptionContentWrapper] -> ShowS)
-> Show HttpExceptionContentWrapper
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HttpExceptionContentWrapper] -> ShowS
$cshowList :: [HttpExceptionContentWrapper] -> ShowS
show :: HttpExceptionContentWrapper -> String
$cshow :: HttpExceptionContentWrapper -> String
showsPrec :: Int -> HttpExceptionContentWrapper -> ShowS
$cshowsPrec :: Int -> HttpExceptionContentWrapper -> ShowS
Show, T.Typeable)
instance Exception HttpExceptionContentWrapper

throwHttp :: HttpExceptionContent -> IO a
throwHttp :: HttpExceptionContent -> IO a
throwHttp = HttpExceptionContentWrapper -> IO a
forall e a. Exception e => e -> IO a
throwIO (HttpExceptionContentWrapper -> IO a)
-> (HttpExceptionContent -> HttpExceptionContentWrapper)
-> HttpExceptionContent
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HttpExceptionContent -> HttpExceptionContentWrapper
HttpExceptionContentWrapper

toHttpException :: Request -> HttpExceptionContentWrapper -> HttpException
toHttpException :: Request -> HttpExceptionContentWrapper -> HttpException
toHttpException Request
req (HttpExceptionContentWrapper HttpExceptionContent
e) = Request -> HttpExceptionContent -> HttpException
HttpExceptionRequest Request
req HttpExceptionContent
e

-- | An exception which may be generated by this library
--
-- @since 0.5.0
data HttpException
    = HttpExceptionRequest Request HttpExceptionContent
    -- ^ Most exceptions are specific to a 'Request'. Inspect the
    -- 'HttpExceptionContent' value for details on what occurred.
    --
    -- @since 0.5.0
    | InvalidUrlException String String
    -- ^ A URL (first field) is invalid for a given reason
    -- (second argument).
    --
    -- @since 0.5.0
    deriving (Int -> HttpException -> ShowS
[HttpException] -> ShowS
HttpException -> String
(Int -> HttpException -> ShowS)
-> (HttpException -> String)
-> ([HttpException] -> ShowS)
-> Show HttpException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HttpException] -> ShowS
$cshowList :: [HttpException] -> ShowS
show :: HttpException -> String
$cshow :: HttpException -> String
showsPrec :: Int -> HttpException -> ShowS
$cshowsPrec :: Int -> HttpException -> ShowS
Show, T.Typeable)
instance Exception HttpException

data HttpExceptionContent
                   = StatusCodeException (Response ()) S.ByteString
                   -- ^ Generated by the @parseUrlThrow@ function when the
                   -- server returns a non-2XX response status code.
                   --
                   -- May include the beginning of the response body.
                   --
                   -- @since 0.5.0
                   | TooManyRedirects [Response L.ByteString]
                   -- ^ The server responded with too many redirects for a
                   -- request.
                   --
                   -- Contains the list of encountered responses containing
                   -- redirects in reverse chronological order; including last
                   -- redirect, which triggered the exception and was not
                   -- followed.
                   --
                   -- @since 0.5.0
                   | OverlongHeaders
                   -- ^ Either too many headers, or too many total bytes in a
                   -- single header, were returned by the server, and the
                   -- memory exhaustion protection in this library has kicked
                   -- in.
                   --
                   -- @since 0.5.0
                   | ResponseTimeout
                   -- ^ The server took too long to return a response. This can
                   -- be altered via 'responseTimeout' or
                   -- 'managerResponseTimeout'.
                   --
                   -- @since 0.5.0
                   | ConnectionTimeout
                   -- ^ Attempting to connect to the server timed out.
                   --
                   -- @since 0.5.0
                   | ConnectionFailure SomeException
                   -- ^ An exception occurred when trying to connect to the
                   -- server.
                   --
                   -- @since 0.5.0
                   | InvalidStatusLine S.ByteString
                   -- ^ The status line returned by the server could not be parsed.
                   --
                   -- @since 0.5.0
                   | InvalidHeader S.ByteString
                   -- ^ The given response header line could not be parsed
                   --
                   -- @since 0.5.0
                   | InvalidRequestHeader S.ByteString
                   -- ^ The given request header is not compliant (e.g. has newlines)
                   --
                   -- @since 0.5.14
                   | InternalException SomeException
                   -- ^ An exception was raised by an underlying library when
                   -- performing the request. Most often, this is caused by a
                   -- failing socket action or a TLS exception.
                   --
                   -- @since 0.5.0
                   | ProxyConnectException S.ByteString Int Status
                   -- ^ A non-200 status code was returned when trying to
                   -- connect to the proxy server on the given host and port.
                   --
                   -- @since 0.5.0
                   | NoResponseDataReceived
                   -- ^ No response data was received from the server at all.
                   -- This exception may deserve special handling within the
                   -- library, since it may indicate that a pipelining has been
                   -- used, and a connection thought to be open was in fact
                   -- closed.
                   --
                   -- @since 0.5.0
                   | TlsNotSupported
                   -- ^ Exception thrown when using a @Manager@ which does not
                   -- have support for secure connections. Typically, you will
                   -- want to use @tlsManagerSettings@ from @http-client-tls@
                   -- to overcome this.
                   --
                   -- @since 0.5.0
                   | WrongRequestBodyStreamSize Word64 Word64
                   -- ^ The request body provided did not match the expected size.
                   --
                   -- Provides the expected and actual size.
                   --
                   -- @since 0.4.31
                   | ResponseBodyTooShort Word64 Word64
                   -- ^ The returned response body is too short. Provides the
                   -- expected size and actual size.
                   --
                   -- @since 0.5.0
                   | InvalidChunkHeaders
                   -- ^ A chunked response body had invalid headers.
                   --
                   -- @since 0.5.0
                   | IncompleteHeaders
                   -- ^ An incomplete set of response headers were returned.
                   --
                   -- @since 0.5.0
                   | InvalidDestinationHost S.ByteString
                   -- ^ The host we tried to connect to is invalid (e.g., an
                   -- empty string).
                   | HttpZlibException ZlibException
                   -- ^ An exception was thrown when inflating a response body.
                   --
                   -- @since 0.5.0
                   | InvalidProxyEnvironmentVariable Text Text
                   -- ^ Values in the proxy environment variable were invalid.
                   -- Provides the environment variable name and its value.
                   --
                   -- @since 0.5.0
                   | ConnectionClosed
                   -- ^ Attempted to use a 'Connection' which was already closed
                   --
                   -- @since 0.5.0
                   | InvalidProxySettings Text
                   -- ^ Proxy settings are not valid (Windows specific currently)
                   -- @since 0.5.7
    deriving (Int -> HttpExceptionContent -> ShowS
[HttpExceptionContent] -> ShowS
HttpExceptionContent -> String
(Int -> HttpExceptionContent -> ShowS)
-> (HttpExceptionContent -> String)
-> ([HttpExceptionContent] -> ShowS)
-> Show HttpExceptionContent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HttpExceptionContent] -> ShowS
$cshowList :: [HttpExceptionContent] -> ShowS
show :: HttpExceptionContent -> String
$cshow :: HttpExceptionContent -> String
showsPrec :: Int -> HttpExceptionContent -> ShowS
$cshowsPrec :: Int -> HttpExceptionContent -> ShowS
Show, T.Typeable)

-- Purposely not providing this instance, since we don't want users to
-- accidentally try and catch these exceptions instead of HttpException
--
-- instance Exception HttpExceptionContent


-- This corresponds to the description of a cookie detailed in Section 5.3 \"Storage Model\"
data Cookie = Cookie
  { Cookie -> ByteString
cookie_name :: S.ByteString
  , Cookie -> ByteString
cookie_value :: S.ByteString
  , Cookie -> UTCTime
cookie_expiry_time :: UTCTime
  , Cookie -> ByteString
cookie_domain :: S.ByteString
  , Cookie -> ByteString
cookie_path :: S.ByteString
  , Cookie -> UTCTime
cookie_creation_time :: UTCTime
  , Cookie -> UTCTime
cookie_last_access_time :: UTCTime
  , Cookie -> Bool
cookie_persistent :: Bool
  , Cookie -> Bool
cookie_host_only :: Bool
  , Cookie -> Bool
cookie_secure_only :: Bool
  , Cookie -> Bool
cookie_http_only :: Bool
  }
  deriving (ReadPrec [Cookie]
ReadPrec Cookie
Int -> ReadS Cookie
ReadS [Cookie]
(Int -> ReadS Cookie)
-> ReadS [Cookie]
-> ReadPrec Cookie
-> ReadPrec [Cookie]
-> Read Cookie
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Cookie]
$creadListPrec :: ReadPrec [Cookie]
readPrec :: ReadPrec Cookie
$creadPrec :: ReadPrec Cookie
readList :: ReadS [Cookie]
$creadList :: ReadS [Cookie]
readsPrec :: Int -> ReadS Cookie
$creadsPrec :: Int -> ReadS Cookie
Read, Int -> Cookie -> ShowS
[Cookie] -> ShowS
Cookie -> String
(Int -> Cookie -> ShowS)
-> (Cookie -> String) -> ([Cookie] -> ShowS) -> Show Cookie
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cookie] -> ShowS
$cshowList :: [Cookie] -> ShowS
show :: Cookie -> String
$cshow :: Cookie -> String
showsPrec :: Int -> Cookie -> ShowS
$cshowsPrec :: Int -> Cookie -> ShowS
Show, T.Typeable)

newtype CookieJar = CJ { CookieJar -> [Cookie]
expose :: [Cookie] }
  deriving (ReadPrec [CookieJar]
ReadPrec CookieJar
Int -> ReadS CookieJar
ReadS [CookieJar]
(Int -> ReadS CookieJar)
-> ReadS [CookieJar]
-> ReadPrec CookieJar
-> ReadPrec [CookieJar]
-> Read CookieJar
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CookieJar]
$creadListPrec :: ReadPrec [CookieJar]
readPrec :: ReadPrec CookieJar
$creadPrec :: ReadPrec CookieJar
readList :: ReadS [CookieJar]
$creadList :: ReadS [CookieJar]
readsPrec :: Int -> ReadS CookieJar
$creadsPrec :: Int -> ReadS CookieJar
Read, Int -> CookieJar -> ShowS
[CookieJar] -> ShowS
CookieJar -> String
(Int -> CookieJar -> ShowS)
-> (CookieJar -> String)
-> ([CookieJar] -> ShowS)
-> Show CookieJar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CookieJar] -> ShowS
$cshowList :: [CookieJar] -> ShowS
show :: CookieJar -> String
$cshow :: CookieJar -> String
showsPrec :: Int -> CookieJar -> ShowS
$cshowsPrec :: Int -> CookieJar -> ShowS
Show, T.Typeable)

-- This corresponds to step 11 of the algorithm described in Section 5.3 \"Storage Model\"
instance Eq Cookie where
  == :: Cookie -> Cookie -> Bool
(==) Cookie
a Cookie
b = Bool
name_matches Bool -> Bool -> Bool
&& Bool
domain_matches Bool -> Bool -> Bool
&& Bool
path_matches
    where name_matches :: Bool
name_matches = Cookie -> ByteString
cookie_name Cookie
a ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== Cookie -> ByteString
cookie_name Cookie
b
          domain_matches :: Bool
domain_matches = ByteString -> ByteString
forall s. FoldCase s => s -> s
CI.foldCase (Cookie -> ByteString
cookie_domain Cookie
a) ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString -> ByteString
forall s. FoldCase s => s -> s
CI.foldCase (Cookie -> ByteString
cookie_domain Cookie
b)
          path_matches :: Bool
path_matches = Cookie -> ByteString
cookie_path Cookie
a ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== Cookie -> ByteString
cookie_path Cookie
b

instance Ord Cookie where
  compare :: Cookie -> Cookie -> Ordering
compare Cookie
c1 Cookie
c2
    | ByteString -> Int
S.length (Cookie -> ByteString
cookie_path Cookie
c1) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> ByteString -> Int
S.length (Cookie -> ByteString
cookie_path Cookie
c2) = Ordering
LT
    | ByteString -> Int
S.length (Cookie -> ByteString
cookie_path Cookie
c1) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
S.length (Cookie -> ByteString
cookie_path Cookie
c2) = Ordering
GT
    | Cookie -> UTCTime
cookie_creation_time Cookie
c1 UTCTime -> UTCTime -> Bool
forall a. Ord a => a -> a -> Bool
> Cookie -> UTCTime
cookie_creation_time Cookie
c2 = Ordering
GT
    | Bool
otherwise = Ordering
LT

instance Eq CookieJar where
  == :: CookieJar -> CookieJar -> Bool
(==) CookieJar
cj1 CookieJar
cj2 = ([Cookie] -> [Cookie]
forall a. Ord a => [a] -> [a]
DL.sort ([Cookie] -> [Cookie]) -> [Cookie] -> [Cookie]
forall a b. (a -> b) -> a -> b
$ CookieJar -> [Cookie]
expose CookieJar
cj1) [Cookie] -> [Cookie] -> Bool
forall a. Eq a => a -> a -> Bool
== ([Cookie] -> [Cookie]
forall a. Ord a => [a] -> [a]
DL.sort ([Cookie] -> [Cookie]) -> [Cookie] -> [Cookie]
forall a b. (a -> b) -> a -> b
$ CookieJar -> [Cookie]
expose CookieJar
cj2)

instance Semigroup CookieJar where
  (CJ [Cookie]
a) <> :: CookieJar -> CookieJar -> CookieJar
<> (CJ [Cookie]
b) = [Cookie] -> CookieJar
CJ ([Cookie] -> [Cookie]
forall a. Eq a => [a] -> [a]
DL.nub ([Cookie] -> [Cookie]) -> [Cookie] -> [Cookie]
forall a b. (a -> b) -> a -> b
$ (Cookie -> Cookie -> Ordering) -> [Cookie] -> [Cookie]
forall a. (a -> a -> Ordering) -> [a] -> [a]
DL.sortBy Cookie -> Cookie -> Ordering
compare' ([Cookie] -> [Cookie]) -> [Cookie] -> [Cookie]
forall a b. (a -> b) -> a -> b
$ [Cookie]
a [Cookie] -> [Cookie] -> [Cookie]
forall a. Semigroup a => a -> a -> a
<> [Cookie]
b)
    where compare' :: Cookie -> Cookie -> Ordering
compare' Cookie
c1 Cookie
c2 =
            -- inverse so that recent cookies are kept by nub over older
            if Cookie -> UTCTime
cookie_creation_time Cookie
c1 UTCTime -> UTCTime -> Bool
forall a. Ord a => a -> a -> Bool
> Cookie -> UTCTime
cookie_creation_time Cookie
c2
                then Ordering
LT
                else Ordering
GT

-- | Since 1.9
instance Data.Monoid.Monoid CookieJar where
  mempty :: CookieJar
mempty = [Cookie] -> CookieJar
CJ []
#if !(MIN_VERSION_base(4,11,0))
  mappend = (<>)
#endif

-- | Define a HTTP proxy, consisting of a hostname and port number.

data Proxy = Proxy
    { Proxy -> ByteString
proxyHost :: S.ByteString -- ^ The host name of the HTTP proxy.
    , Proxy -> Int
proxyPort :: Int -- ^ The port number of the HTTP proxy.
    }
    deriving (Int -> Proxy -> ShowS
[Proxy] -> ShowS
Proxy -> String
(Int -> Proxy -> ShowS)
-> (Proxy -> String) -> ([Proxy] -> ShowS) -> Show Proxy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Proxy] -> ShowS
$cshowList :: [Proxy] -> ShowS
show :: Proxy -> String
$cshow :: Proxy -> String
showsPrec :: Int -> Proxy -> ShowS
$cshowsPrec :: Int -> Proxy -> ShowS
Show, ReadPrec [Proxy]
ReadPrec Proxy
Int -> ReadS Proxy
ReadS [Proxy]
(Int -> ReadS Proxy)
-> ReadS [Proxy]
-> ReadPrec Proxy
-> ReadPrec [Proxy]
-> Read Proxy
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Proxy]
$creadListPrec :: ReadPrec [Proxy]
readPrec :: ReadPrec Proxy
$creadPrec :: ReadPrec Proxy
readList :: ReadS [Proxy]
$creadList :: ReadS [Proxy]
readsPrec :: Int -> ReadS Proxy
$creadsPrec :: Int -> ReadS Proxy
Read, Proxy -> Proxy -> Bool
(Proxy -> Proxy -> Bool) -> (Proxy -> Proxy -> Bool) -> Eq Proxy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Proxy -> Proxy -> Bool
$c/= :: Proxy -> Proxy -> Bool
== :: Proxy -> Proxy -> Bool
$c== :: Proxy -> Proxy -> Bool
Eq, Eq Proxy
Eq Proxy
-> (Proxy -> Proxy -> Ordering)
-> (Proxy -> Proxy -> Bool)
-> (Proxy -> Proxy -> Bool)
-> (Proxy -> Proxy -> Bool)
-> (Proxy -> Proxy -> Bool)
-> (Proxy -> Proxy -> Proxy)
-> (Proxy -> Proxy -> Proxy)
-> Ord Proxy
Proxy -> Proxy -> Bool
Proxy -> Proxy -> Ordering
Proxy -> Proxy -> Proxy
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Proxy -> Proxy -> Proxy
$cmin :: Proxy -> Proxy -> Proxy
max :: Proxy -> Proxy -> Proxy
$cmax :: Proxy -> Proxy -> Proxy
>= :: Proxy -> Proxy -> Bool
$c>= :: Proxy -> Proxy -> Bool
> :: Proxy -> Proxy -> Bool
$c> :: Proxy -> Proxy -> Bool
<= :: Proxy -> Proxy -> Bool
$c<= :: Proxy -> Proxy -> Bool
< :: Proxy -> Proxy -> Bool
$c< :: Proxy -> Proxy -> Bool
compare :: Proxy -> Proxy -> Ordering
$ccompare :: Proxy -> Proxy -> Ordering
$cp1Ord :: Eq Proxy
Ord, T.Typeable)

-- | When using one of the 'RequestBodyStream' \/ 'RequestBodyStreamChunked'
-- constructors, you must ensure that the 'GivesPopper' can be called multiple
-- times.  Usually this is not a problem.
--
-- The 'RequestBodyStreamChunked' will send a chunked request body. Note that
-- not all servers support this. Only use 'RequestBodyStreamChunked' if you
-- know the server you're sending to supports chunked request bodies.
--
-- Since 0.1.0
data RequestBody
    = RequestBodyLBS L.ByteString
    | RequestBodyBS S.ByteString
    | RequestBodyBuilder Int64 Builder
    | RequestBodyStream Int64 (GivesPopper ())
    | RequestBodyStreamChunked (GivesPopper ())
    | RequestBodyIO (IO RequestBody)
    -- ^ Allows creation of a @RequestBody@ inside the @IO@ monad, which is
    -- useful for making easier APIs (like @setRequestBodyFile@).
    --
    -- @since 0.4.28
    deriving T.Typeable
-- |
--
-- Since 0.4.12
instance IsString RequestBody where
    fromString :: String -> RequestBody
fromString String
str = ByteString -> RequestBody
RequestBodyBS (String -> ByteString
forall a. IsString a => String -> a
fromString String
str)
instance Monoid RequestBody where
    mempty :: RequestBody
mempty = ByteString -> RequestBody
RequestBodyBS ByteString
S.empty
#if !(MIN_VERSION_base(4,11,0))
    mappend = (<>)
#endif

instance Semigroup RequestBody where
    RequestBody
x0 <> :: RequestBody -> RequestBody -> RequestBody
<> RequestBody
y0 =
        case (RequestBody
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
simplify RequestBody
x0, RequestBody
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
simplify RequestBody
y0) of
            (Left (Int64
i, Builder
x), Left (Int64
j, Builder
y)) -> Int64 -> Builder -> RequestBody
RequestBodyBuilder (Int64
i Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
j) (Builder
x Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
y)
            (Left (Int64, Builder)
x, Right (Maybe Int64, GivesPopper ())
y) -> (Maybe Int64, GivesPopper ())
-> (Maybe Int64, GivesPopper ()) -> RequestBody
combine ((Int64, Builder) -> (Maybe Int64, GivesPopper ())
builderToStream (Int64, Builder)
x) (Maybe Int64, GivesPopper ())
y
            (Right (Maybe Int64, GivesPopper ())
x, Left (Int64, Builder)
y) -> (Maybe Int64, GivesPopper ())
-> (Maybe Int64, GivesPopper ()) -> RequestBody
combine (Maybe Int64, GivesPopper ())
x ((Int64, Builder) -> (Maybe Int64, GivesPopper ())
builderToStream (Int64, Builder)
y)
            (Right (Maybe Int64, GivesPopper ())
x, Right (Maybe Int64, GivesPopper ())
y) -> (Maybe Int64, GivesPopper ())
-> (Maybe Int64, GivesPopper ()) -> RequestBody
combine (Maybe Int64, GivesPopper ())
x (Maybe Int64, GivesPopper ())
y
      where
        combine :: (Maybe Int64, GivesPopper ())
-> (Maybe Int64, GivesPopper ()) -> RequestBody
combine (Just Int64
i, GivesPopper ()
x) (Just Int64
j, GivesPopper ()
y) = Int64 -> GivesPopper () -> RequestBody
RequestBodyStream (Int64
i Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
j) (GivesPopper () -> GivesPopper () -> GivesPopper ()
combine' GivesPopper ()
x GivesPopper ()
y)
        combine (Maybe Int64
_, GivesPopper ()
x) (Maybe Int64
_, GivesPopper ()
y) = GivesPopper () -> RequestBody
RequestBodyStreamChunked (GivesPopper () -> GivesPopper () -> GivesPopper ()
combine' GivesPopper ()
x GivesPopper ()
y)

        combine' :: GivesPopper () -> GivesPopper () -> GivesPopper ()
        combine' :: GivesPopper () -> GivesPopper () -> GivesPopper ()
combine' GivesPopper ()
x GivesPopper ()
y NeedsPopper ()
f = GivesPopper ()
x GivesPopper () -> GivesPopper ()
forall a b. (a -> b) -> a -> b
$ \IO ByteString
x' -> GivesPopper ()
y GivesPopper () -> GivesPopper ()
forall a b. (a -> b) -> a -> b
$ \IO ByteString
y' -> IO ByteString -> IO ByteString -> GivesPopper ()
combine'' IO ByteString
x' IO ByteString
y' NeedsPopper ()
f

        combine'' :: Popper -> Popper -> NeedsPopper () -> IO ()
        combine'' :: IO ByteString -> IO ByteString -> GivesPopper ()
combine'' IO ByteString
x IO ByteString
y NeedsPopper ()
f = do
            IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
istate <- Either (IO ByteString, IO ByteString) (IO ByteString)
-> IO
     (IORef (Either (IO ByteString, IO ByteString) (IO ByteString)))
forall a. a -> IO (IORef a)
newIORef (Either (IO ByteString, IO ByteString) (IO ByteString)
 -> IO
      (IORef (Either (IO ByteString, IO ByteString) (IO ByteString))))
-> Either (IO ByteString, IO ByteString) (IO ByteString)
-> IO
     (IORef (Either (IO ByteString, IO ByteString) (IO ByteString)))
forall a b. (a -> b) -> a -> b
$ (IO ByteString, IO ByteString)
-> Either (IO ByteString, IO ByteString) (IO ByteString)
forall a b. a -> Either a b
Left (IO ByteString
x, IO ByteString
y)
            NeedsPopper ()
f NeedsPopper () -> NeedsPopper ()
forall a b. (a -> b) -> a -> b
$ IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
-> IO ByteString
go IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
istate

        go :: IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
-> IO ByteString
go IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
istate = do
            Either (IO ByteString, IO ByteString) (IO ByteString)
state <- IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
-> IO (Either (IO ByteString, IO ByteString) (IO ByteString))
forall a. IORef a -> IO a
readIORef IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
istate
            case Either (IO ByteString, IO ByteString) (IO ByteString)
state of
                Left (IO ByteString
x, IO ByteString
y) -> do
                    ByteString
bs <- IO ByteString
x
                    if ByteString -> Bool
S.null ByteString
bs
                        then do
                            IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
-> Either (IO ByteString, IO ByteString) (IO ByteString) -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Either (IO ByteString, IO ByteString) (IO ByteString))
istate (Either (IO ByteString, IO ByteString) (IO ByteString) -> IO ())
-> Either (IO ByteString, IO ByteString) (IO ByteString) -> IO ()
forall a b. (a -> b) -> a -> b
$ IO ByteString
-> Either (IO ByteString, IO ByteString) (IO ByteString)
forall a b. b -> Either a b
Right IO ByteString
y
                            IO ByteString
y
                        else ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bs
                Right IO ByteString
y -> IO ByteString
y

simplify :: RequestBody -> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
simplify :: RequestBody
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
simplify (RequestBodyLBS ByteString
lbs) = (Int64, Builder)
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a b. a -> Either a b
Left (ByteString -> Int64
L.length ByteString
lbs, ByteString -> Builder
fromLazyByteString ByteString
lbs)
simplify (RequestBodyBS ByteString
bs) = (Int64, Builder)
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a b. a -> Either a b
Left (Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int64) -> Int -> Int64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
S.length ByteString
bs, ByteString -> Builder
fromByteString ByteString
bs)
simplify (RequestBodyBuilder Int64
len Builder
b) = (Int64, Builder)
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a b. a -> Either a b
Left (Int64
len, Builder
b)
simplify (RequestBodyStream Int64
i GivesPopper ()
gp) = (Maybe Int64, GivesPopper ())
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a b. b -> Either a b
Right (Int64 -> Maybe Int64
forall a. a -> Maybe a
Just Int64
i, GivesPopper ()
gp)
simplify (RequestBodyStreamChunked GivesPopper ()
gp) = (Maybe Int64, GivesPopper ())
-> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a b. b -> Either a b
Right (Maybe Int64
forall a. Maybe a
Nothing, GivesPopper ()
gp)
simplify (RequestBodyIO IO RequestBody
_mbody) = String -> Either (Int64, Builder) (Maybe Int64, GivesPopper ())
forall a. HasCallStack => String -> a
error String
"FIXME No support for Monoid on RequestBodyIO"

builderToStream :: (Int64, Builder) -> (Maybe Int64, GivesPopper ())
builderToStream :: (Int64, Builder) -> (Maybe Int64, GivesPopper ())
builderToStream (Int64
len, Builder
builder) =
    (Int64 -> Maybe Int64
forall a. a -> Maybe a
Just Int64
len, GivesPopper ()
forall b. (IO ByteString -> IO b) -> IO b
gp)
  where
    gp :: (IO ByteString -> IO b) -> IO b
gp IO ByteString -> IO b
np = do
        IORef [ByteString]
ibss <- [ByteString] -> IO (IORef [ByteString])
forall a. a -> IO (IORef a)
newIORef ([ByteString] -> IO (IORef [ByteString]))
-> [ByteString] -> IO (IORef [ByteString])
forall a b. (a -> b) -> a -> b
$ ByteString -> [ByteString]
L.toChunks (ByteString -> [ByteString]) -> ByteString -> [ByteString]
forall a b. (a -> b) -> a -> b
$ Builder -> ByteString
toLazyByteString Builder
builder
        IO ByteString -> IO b
np (IO ByteString -> IO b) -> IO ByteString -> IO b
forall a b. (a -> b) -> a -> b
$ do
            [ByteString]
bss <- IORef [ByteString] -> IO [ByteString]
forall a. IORef a -> IO a
readIORef IORef [ByteString]
ibss
            case [ByteString]
bss of
                [] -> ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
S.empty
                ByteString
bs:[ByteString]
bss' -> do
                    IORef [ByteString] -> [ByteString] -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef [ByteString]
ibss [ByteString]
bss'
                    ByteString -> IO ByteString
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
bs

-- | A function which generates successive chunks of a request body, provider a
-- single empty bytestring when no more data is available.
--
-- Since 0.1.0
type Popper = IO S.ByteString

-- | A function which must be provided with a 'Popper'.
--
-- Since 0.1.0
type NeedsPopper a = Popper -> IO a

-- | A function which will provide a 'Popper' to a 'NeedsPopper'. This
-- seemingly convoluted structure allows for creation of request bodies which
-- allocate scarce resources in an exception safe manner.
--
-- Since 0.1.0
type GivesPopper a = NeedsPopper a -> IO a

-- | All information on how to connect to a host and what should be sent in the
-- HTTP request.
--
-- If you simply wish to download from a URL, see 'parseRequest'.
--
-- The constructor for this data type is not exposed. Instead, you should use
-- either the 'defaultRequest' value, or 'parseRequest' to
-- construct from a URL, and then use the records below to make modifications.
-- This approach allows http-client to add configuration options without
-- breaking backwards compatibility.
--
-- For example, to construct a POST request, you could do something like:
--
-- > initReq <- parseRequest "http://www.example.com/path"
-- > let req = initReq
-- >             { method = "POST"
-- >             }
--
-- For more information, please see
-- <http://www.yesodweb.com/book/settings-types>.
--
-- Since 0.1.0
data Request = Request
    { Request -> ByteString
method :: Method
    -- ^ HTTP request method, eg GET, POST.
    --
    -- Since 0.1.0
    , Request -> Bool
secure :: Bool
    -- ^ Whether to use HTTPS (ie, SSL).
    --
    -- Since 0.1.0
    , Request -> ByteString
host :: S.ByteString
    -- ^ Requested host name, used for both the IP address to connect to and
    -- the @host@ request header.
    --
    -- Since 0.1.0
    , Request -> Int
port :: Int
    -- ^ The port to connect to. Also used for generating the @host@ request header.
    --
    -- Since 0.1.0
    , Request -> ByteString
path :: S.ByteString
    -- ^ Everything from the host to the query string.
    --
    -- Since 0.1.0
    , Request -> ByteString
queryString :: S.ByteString
    -- ^ Query string appended to the path.
    --
    -- Since 0.1.0
    , Request -> RequestHeaders
requestHeaders :: RequestHeaders
    -- ^ Custom HTTP request headers
    --
    -- The Content-Length and Transfer-Encoding headers are set automatically
    -- by this module, and shall not be added to @requestHeaders@.
    --
    -- If not provided by the user, @Host@ will automatically be set based on
    -- the @host@ and @port@ fields.
    --
    -- Moreover, the Accept-Encoding header is set implicitly to gzip for
    -- convenience by default. This behaviour can be overridden if needed, by
    -- setting the header explicitly to a different value. In order to omit the
    -- Accept-Header altogether, set it to the empty string \"\". If you need an
    -- empty Accept-Header (i.e. requesting the identity encoding), set it to a
    -- non-empty white-space string, e.g. \" \". See RFC 2616 section 14.3 for
    -- details about the semantics of the Accept-Header field. If you request a
    -- content-encoding not supported by this module, you will have to decode
    -- it yourself (see also the 'decompress' field).
    --
    -- Note: Multiple header fields with the same field-name will result in
    -- multiple header fields being sent and therefore it\'s the responsibility
    -- of the client code to ensure that the rules from RFC 2616 section 4.2
    -- are honoured.
    --
    -- Since 0.1.0
    , Request -> RequestBody
requestBody :: RequestBody
    -- ^ Request body to be sent to the server.
    --
    -- Since 0.1.0
    , Request -> Maybe Proxy
proxy :: Maybe Proxy
    -- ^ Optional HTTP proxy.
    --
    -- Since 0.1.0
    , Request -> Maybe HostAddress
hostAddress :: Maybe HostAddress
    -- ^ Optional resolved host address. May not be used by all backends.
    --
    -- Since 0.1.0
    , Request -> Bool
rawBody :: Bool
    -- ^ If @True@, a chunked and\/or gzipped body will not be
    -- decoded. Use with caution.
    --
    -- Since 0.1.0
    , Request -> ByteString -> Bool
decompress :: S.ByteString -> Bool
    -- ^ Predicate to specify whether gzipped data should be
    -- decompressed on the fly (see 'alwaysDecompress' and
    -- 'browserDecompress'). Argument is the mime type.
    -- Default: browserDecompress.
    --
    -- Since 0.1.0
    , Request -> Int
redirectCount :: Int
    -- ^ How many redirects to follow when getting a resource. 0 means follow
    -- no redirects. Default value: 10.
    --
    -- Since 0.1.0
    , Request -> Request -> Response (IO ByteString) -> IO ()
checkResponse :: Request -> Response BodyReader -> IO ()
    -- ^ Check the response immediately after receiving the status and headers.
    -- This can be useful for throwing exceptions on non-success status codes.
    --
    -- In previous versions of http-client, this went under the name
    -- @checkStatus@, but was renamed to avoid confusion about the new default
    -- behavior (doing nothing).
    --
    -- @since 0.5.0
    , Request -> ResponseTimeout
responseTimeout :: ResponseTimeout
    -- ^ Number of microseconds to wait for a response (see 'ResponseTimeout'
    -- for more information). Default: use 'managerResponseTimeout' (which by
    -- default is 30 seconds).
    --
    -- Since 0.1.0
    , Request -> Maybe CookieJar
cookieJar :: Maybe CookieJar
    -- ^ A user-defined cookie jar.
    -- If 'Nothing', no cookie handling will take place, \"Cookie\" headers
    -- in 'requestHeaders' will be sent raw, and 'responseCookieJar' will be
    -- empty.
    --
    -- Since 0.1.0

    , Request -> HttpVersion
requestVersion :: HttpVersion
    -- ^ HTTP version to send to server.
    --
    -- Default: HTTP 1.1
    --
    -- Since 0.4.3

    , Request -> SomeException -> IO ()
onRequestBodyException :: SomeException -> IO ()
    -- ^ How to deal with exceptions thrown while sending the request.
    --
    -- Default: ignore @IOException@s, rethrow all other exceptions.
    --
    -- Since: 0.4.6

    , Request -> Maybe Manager
requestManagerOverride :: Maybe Manager
    -- ^ A 'Manager' value that should override whatever @Manager@ value was
    -- passed in to the HTTP request function manually. This is useful when
    -- dealing with implicit global managers, such as in @Network.HTTP.Simple@
    --
    -- @since 0.4.28

    , Request -> HeaderName -> Bool
shouldStripHeaderOnRedirect :: HeaderName -> Bool
    -- ^ Decide whether a header must be stripped from the request
    -- when following a redirect. Default: keep all headers intact.
    --
    -- @since 0.6.2
    }
    deriving T.Typeable

-- | How to deal with timing out on retrieval of response headers.
--
-- @since 0.5.0
data ResponseTimeout
    = ResponseTimeoutMicro !Int
    -- ^ Wait the given number of microseconds for response headers to
    -- load, then throw an exception
    | ResponseTimeoutNone
    -- ^ Wait indefinitely
    | ResponseTimeoutDefault
    -- ^ Fall back to the manager setting ('managerResponseTimeout') or, in its
    -- absence, Wait 30 seconds and then throw an exception.
    deriving (ResponseTimeout -> ResponseTimeout -> Bool
(ResponseTimeout -> ResponseTimeout -> Bool)
-> (ResponseTimeout -> ResponseTimeout -> Bool)
-> Eq ResponseTimeout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResponseTimeout -> ResponseTimeout -> Bool
$c/= :: ResponseTimeout -> ResponseTimeout -> Bool
== :: ResponseTimeout -> ResponseTimeout -> Bool
$c== :: ResponseTimeout -> ResponseTimeout -> Bool
Eq, Int -> ResponseTimeout -> ShowS
[ResponseTimeout] -> ShowS
ResponseTimeout -> String
(Int -> ResponseTimeout -> ShowS)
-> (ResponseTimeout -> String)
-> ([ResponseTimeout] -> ShowS)
-> Show ResponseTimeout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResponseTimeout] -> ShowS
$cshowList :: [ResponseTimeout] -> ShowS
show :: ResponseTimeout -> String
$cshow :: ResponseTimeout -> String
showsPrec :: Int -> ResponseTimeout -> ShowS
$cshowsPrec :: Int -> ResponseTimeout -> ShowS
Show)

instance Show Request where
    show :: Request -> String
show Request
x = [String] -> String
unlines
        [ String
"Request {"
        , String
"  host                 = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
forall a. Show a => a -> String
show (Request -> ByteString
host Request
x)
        , String
"  port                 = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Request -> Int
port Request
x)
        , String
"  secure               = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Bool -> String
forall a. Show a => a -> String
show (Request -> Bool
secure Request
x)
        , String
"  requestHeaders       = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ RequestHeaders -> String
forall a. Show a => a -> String
show ((Header -> Header) -> RequestHeaders -> RequestHeaders
forall a b. (a -> b) -> [a] -> [b]
DL.map Header -> Header
redactSensitiveHeader (Request -> RequestHeaders
requestHeaders Request
x))
        , String
"  path                 = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
forall a. Show a => a -> String
show (Request -> ByteString
path Request
x)
        , String
"  queryString          = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
forall a. Show a => a -> String
show (Request -> ByteString
queryString Request
x)
        --, "  requestBody          = " ++ show (requestBody x)
        , String
"  method               = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> String
forall a. Show a => a -> String
show (Request -> ByteString
method Request
x)
        , String
"  proxy                = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Maybe Proxy -> String
forall a. Show a => a -> String
show (Request -> Maybe Proxy
proxy Request
x)
        , String
"  rawBody              = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Bool -> String
forall a. Show a => a -> String
show (Request -> Bool
rawBody Request
x)
        , String
"  redirectCount        = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show (Request -> Int
redirectCount Request
x)
        , String
"  responseTimeout      = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ResponseTimeout -> String
forall a. Show a => a -> String
show (Request -> ResponseTimeout
responseTimeout Request
x)
        , String
"  requestVersion       = " String -> ShowS
forall a. [a] -> [a] -> [a]
++ HttpVersion -> String
forall a. Show a => a -> String
show (Request -> HttpVersion
requestVersion Request
x)
        , String
"}"
        ]

redactSensitiveHeader :: Header -> Header
redactSensitiveHeader :: Header -> Header
redactSensitiveHeader (HeaderName
"Authorization", ByteString
_) = (HeaderName
"Authorization", ByteString
"<REDACTED>")
redactSensitiveHeader Header
h = Header
h

-- | A simple representation of the HTTP response.
--
-- Since 0.1.0
data Response body = Response
    { Response body -> Status
responseStatus :: Status
    -- ^ Status code of the response.
    --
    -- Since 0.1.0
    , Response body -> HttpVersion
responseVersion :: HttpVersion
    -- ^ HTTP version used by the server.
    --
    -- Since 0.1.0
    , Response body -> RequestHeaders
responseHeaders :: ResponseHeaders
    -- ^ Response headers sent by the server.
    --
    -- Since 0.1.0
    , Response body -> body
responseBody :: body
    -- ^ Response body sent by the server.
    --
    -- Since 0.1.0
    , Response body -> CookieJar
responseCookieJar :: CookieJar
    -- ^ Cookies set on the client after interacting with the server. If
    -- cookies have been disabled by setting 'cookieJar' to @Nothing@, then
    -- this will always be empty.
    --
    -- Since 0.1.0
    , Response body -> ResponseClose
responseClose' :: ResponseClose
    -- ^ Releases any resource held by this response. If the response body
    -- has not been fully read yet, doing so after this call will likely
    -- be impossible.
    --
    -- Since 0.1.0
    }
    deriving (Int -> Response body -> ShowS
[Response body] -> ShowS
Response body -> String
(Int -> Response body -> ShowS)
-> (Response body -> String)
-> ([Response body] -> ShowS)
-> Show (Response body)
forall body. Show body => Int -> Response body -> ShowS
forall body. Show body => [Response body] -> ShowS
forall body. Show body => Response body -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Response body] -> ShowS
$cshowList :: forall body. Show body => [Response body] -> ShowS
show :: Response body -> String
$cshow :: forall body. Show body => Response body -> String
showsPrec :: Int -> Response body -> ShowS
$cshowsPrec :: forall body. Show body => Int -> Response body -> ShowS
Show, Response body -> Response body -> Bool
(Response body -> Response body -> Bool)
-> (Response body -> Response body -> Bool) -> Eq (Response body)
forall body. Eq body => Response body -> Response body -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Response body -> Response body -> Bool
$c/= :: forall body. Eq body => Response body -> Response body -> Bool
== :: Response body -> Response body -> Bool
$c== :: forall body. Eq body => Response body -> Response body -> Bool
Eq, T.Typeable, a -> Response b -> Response a
(a -> b) -> Response a -> Response b
(forall a b. (a -> b) -> Response a -> Response b)
-> (forall a b. a -> Response b -> Response a) -> Functor Response
forall a b. a -> Response b -> Response a
forall a b. (a -> b) -> Response a -> Response b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Response b -> Response a
$c<$ :: forall a b. a -> Response b -> Response a
fmap :: (a -> b) -> Response a -> Response b
$cfmap :: forall a b. (a -> b) -> Response a -> Response b
Functor, Response a -> Bool
(a -> m) -> Response a -> m
(a -> b -> b) -> b -> Response a -> b
(forall m. Monoid m => Response m -> m)
-> (forall m a. Monoid m => (a -> m) -> Response a -> m)
-> (forall m a. Monoid m => (a -> m) -> Response a -> m)
-> (forall a b. (a -> b -> b) -> b -> Response a -> b)
-> (forall a b. (a -> b -> b) -> b -> Response a -> b)
-> (forall b a. (b -> a -> b) -> b -> Response a -> b)
-> (forall b a. (b -> a -> b) -> b -> Response a -> b)
-> (forall a. (a -> a -> a) -> Response a -> a)
-> (forall a. (a -> a -> a) -> Response a -> a)
-> (forall a. Response a -> [a])
-> (forall a. Response a -> Bool)
-> (forall a. Response a -> Int)
-> (forall a. Eq a => a -> Response a -> Bool)
-> (forall a. Ord a => Response a -> a)
-> (forall a. Ord a => Response a -> a)
-> (forall a. Num a => Response a -> a)
-> (forall a. Num a => Response a -> a)
-> Foldable Response
forall a. Eq a => a -> Response a -> Bool
forall a. Num a => Response a -> a
forall a. Ord a => Response a -> a
forall m. Monoid m => Response m -> m
forall a. Response a -> Bool
forall a. Response a -> Int
forall a. Response a -> [a]
forall a. (a -> a -> a) -> Response a -> a
forall m a. Monoid m => (a -> m) -> Response a -> m
forall b a. (b -> a -> b) -> b -> Response a -> b
forall a b. (a -> b -> b) -> b -> Response a -> b
forall (t :: * -> *).
(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
product :: Response a -> a
$cproduct :: forall a. Num a => Response a -> a
sum :: Response a -> a
$csum :: forall a. Num a => Response a -> a
minimum :: Response a -> a
$cminimum :: forall a. Ord a => Response a -> a
maximum :: Response a -> a
$cmaximum :: forall a. Ord a => Response a -> a
elem :: a -> Response a -> Bool
$celem :: forall a. Eq a => a -> Response a -> Bool
length :: Response a -> Int
$clength :: forall a. Response a -> Int
null :: Response a -> Bool
$cnull :: forall a. Response a -> Bool
toList :: Response a -> [a]
$ctoList :: forall a. Response a -> [a]
foldl1 :: (a -> a -> a) -> Response a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Response a -> a
foldr1 :: (a -> a -> a) -> Response a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Response a -> a
foldl' :: (b -> a -> b) -> b -> Response a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Response a -> b
foldl :: (b -> a -> b) -> b -> Response a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Response a -> b
foldr' :: (a -> b -> b) -> b -> Response a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Response a -> b
foldr :: (a -> b -> b) -> b -> Response a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Response a -> b
foldMap' :: (a -> m) -> Response a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Response a -> m
foldMap :: (a -> m) -> Response a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Response a -> m
fold :: Response m -> m
$cfold :: forall m. Monoid m => Response m -> m
Data.Foldable.Foldable, Functor Response
Foldable Response
Functor Response
-> Foldable Response
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Response a -> f (Response b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Response (f a) -> f (Response a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Response a -> m (Response b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Response (m a) -> m (Response a))
-> Traversable Response
(a -> f b) -> Response a -> f (Response b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Response (m a) -> m (Response a)
forall (f :: * -> *) a.
Applicative f =>
Response (f a) -> f (Response a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Response a -> m (Response b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Response a -> f (Response b)
sequence :: Response (m a) -> m (Response a)
$csequence :: forall (m :: * -> *) a. Monad m => Response (m a) -> m (Response a)
mapM :: (a -> m b) -> Response a -> m (Response b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Response a -> m (Response b)
sequenceA :: Response (f a) -> f (Response a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Response (f a) -> f (Response a)
traverse :: (a -> f b) -> Response a -> f (Response b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Response a -> f (Response b)
$cp2Traversable :: Foldable Response
$cp1Traversable :: Functor Response
Data.Traversable.Traversable)

newtype ResponseClose = ResponseClose { ResponseClose -> IO ()
runResponseClose :: IO () }
    deriving T.Typeable
instance Show ResponseClose where
    show :: ResponseClose -> String
show ResponseClose
_ = String
"ResponseClose"
instance Eq ResponseClose where
    ResponseClose
_ == :: ResponseClose -> ResponseClose -> Bool
== ResponseClose
_ = Bool
True

-- | Settings for a @Manager@. Please use the 'defaultManagerSettings' function and then modify
-- individual settings. For more information, see <http://www.yesodweb.com/book/settings-types>.
--
-- Since 0.1.0
data ManagerSettings = ManagerSettings
    { ManagerSettings -> Int
managerConnCount :: Int
      -- ^ Number of connections to a single host to keep alive. Default: 10.
      --
      -- Since 0.1.0
    , ManagerSettings
-> IO (Maybe HostAddress -> String -> Int -> IO Connection)
managerRawConnection :: IO (Maybe NS.HostAddress -> String -> Int -> IO Connection)
      -- ^ Create an insecure connection.
      --
      -- Since 0.1.0
    , ManagerSettings
-> IO (Maybe HostAddress -> String -> Int -> IO Connection)
managerTlsConnection :: IO (Maybe NS.HostAddress -> String -> Int -> IO Connection)
      -- ^ Create a TLS connection. Default behavior: throw an exception that TLS is not supported.
      --
      -- Since 0.1.0
    , ManagerSettings
-> IO
     (ByteString
      -> (Connection -> IO ())
      -> String
      -> Maybe HostAddress
      -> String
      -> Int
      -> IO Connection)
managerTlsProxyConnection :: IO (S.ByteString -> (Connection -> IO ()) -> String -> Maybe NS.HostAddress -> String -> Int -> IO Connection)
      -- ^ Create a TLS proxy connection. Default behavior: throw an exception that TLS is not supported.
      --
      -- Since 0.2.2
    , ManagerSettings -> ResponseTimeout
managerResponseTimeout :: ResponseTimeout
      -- ^ Default timeout to be applied to requests which do not provide a
      -- timeout value.
      --
      -- Default is 30 seconds
      --
      -- @since 0.5.0
    , ManagerSettings -> SomeException -> Bool
managerRetryableException :: SomeException -> Bool
    -- ^ Exceptions for which we should retry our request if we were reusing an
    -- already open connection. In the case of IOExceptions, for example, we
    -- assume that the connection was closed on the server and therefore open a
    -- new one.
    --
    -- Since 0.1.0
    , ManagerSettings -> forall a. Request -> IO a -> IO a
managerWrapException :: forall a. Request -> IO a -> IO a
    -- ^ Action wrapped around all attempted @Request@s, usually used to wrap
    -- up exceptions in library-specific types.
    --
    -- Default: wrap all @IOException@s in the @InternalException@ constructor.
    --
    -- @since 0.5.0
    , ManagerSettings -> Int
managerIdleConnectionCount :: Int
    -- ^ Total number of idle connection to keep open at a given time.
    --
    -- This limit helps deal with the case where you are making a large number
    -- of connections to different hosts. Without this limit, you could run out
    -- of file descriptors. Additionally, it can be set to zero to prevent
    -- reuse of any connections. Doing this is useful when the server your application
    -- is talking to sits behind a load balancer.
    --
    -- Default: 512
    --
    -- Since 0.3.7
    , ManagerSettings -> Request -> IO Request
managerModifyRequest :: Request -> IO Request
    -- ^ Perform the given modification to a @Request@ before performing it.
    --
    -- This function may be called more than once during request processing.
    -- see https://github.com/snoyberg/http-client/issues/350
    --
    -- Default: no modification
    --
    -- Since 0.4.4
    , ManagerSettings
-> Response (IO ByteString) -> IO (Response (IO ByteString))
managerModifyResponse :: Response BodyReader -> IO (Response BodyReader)
    -- ^ Perform the given modification to a @Response@ after receiving it.
    --
    -- Default: no modification
    --
    -- @since 0.5.5
    , ManagerSettings -> ProxyOverride
managerProxyInsecure :: ProxyOverride
    -- ^ How HTTP proxy server settings should be discovered.
    --
    -- Default: respect the @proxy@ value on the @Request@ itself.
    --
    -- Since 0.4.7
    , ManagerSettings -> ProxyOverride
managerProxySecure :: ProxyOverride
    -- ^ How HTTPS proxy server settings should be discovered.
    --
    -- Default: respect the @proxy@ value on the @Request@ itself.
    --
    -- Since 0.4.7
    }
    deriving T.Typeable

-- | How the HTTP proxy server settings should be discovered.
--
-- Since 0.4.7
newtype ProxyOverride = ProxyOverride
    { ProxyOverride -> Bool -> IO (Request -> Request)
runProxyOverride :: Bool -> IO (Request -> Request)
    }
    deriving T.Typeable

-- | Keeps track of open connections for keep-alive.
--
-- If possible, you should share a single 'Manager' between multiple threads and requests.
--
-- Since 0.1.0
data Manager = Manager
    { Manager -> KeyedPool ConnKey Connection
mConns :: KeyedPool ConnKey Connection
    , Manager -> ResponseTimeout
mResponseTimeout :: ResponseTimeout
    -- ^ Copied from 'managerResponseTimeout'
    , Manager -> SomeException -> Bool
mRetryableException :: SomeException -> Bool
    , Manager -> forall a. Request -> IO a -> IO a
mWrapException :: forall a. Request -> IO a -> IO a
    , Manager -> Request -> IO Request
mModifyRequest :: Request -> IO Request
    , Manager -> Request -> Request
mSetProxy :: Request -> Request
    , Manager
-> Response (IO ByteString) -> IO (Response (IO ByteString))
mModifyResponse      :: Response BodyReader -> IO (Response BodyReader)
    -- ^ See 'managerProxy'
    }
    deriving T.Typeable

class HasHttpManager a where
    getHttpManager :: a -> Manager
instance HasHttpManager Manager where
    getHttpManager :: Manager -> Manager
getHttpManager = Manager -> Manager
forall a. a -> a
id

data ConnsMap
    = ManagerClosed
    | ManagerOpen {-# UNPACK #-} !Int !(Map.Map ConnKey (NonEmptyList Connection))

data NonEmptyList a =
    One a UTCTime |
    Cons a Int UTCTime (NonEmptyList a)
    deriving T.Typeable

-- | Hostname or resolved host address.
data ConnHost =
    HostName Text |
    HostAddress NS.HostAddress
    deriving (ConnHost -> ConnHost -> Bool
(ConnHost -> ConnHost -> Bool)
-> (ConnHost -> ConnHost -> Bool) -> Eq ConnHost
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnHost -> ConnHost -> Bool
$c/= :: ConnHost -> ConnHost -> Bool
== :: ConnHost -> ConnHost -> Bool
$c== :: ConnHost -> ConnHost -> Bool
Eq, Int -> ConnHost -> ShowS
[ConnHost] -> ShowS
ConnHost -> String
(Int -> ConnHost -> ShowS)
-> (ConnHost -> String) -> ([ConnHost] -> ShowS) -> Show ConnHost
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnHost] -> ShowS
$cshowList :: [ConnHost] -> ShowS
show :: ConnHost -> String
$cshow :: ConnHost -> String
showsPrec :: Int -> ConnHost -> ShowS
$cshowsPrec :: Int -> ConnHost -> ShowS
Show, Eq ConnHost
Eq ConnHost
-> (ConnHost -> ConnHost -> Ordering)
-> (ConnHost -> ConnHost -> Bool)
-> (ConnHost -> ConnHost -> Bool)
-> (ConnHost -> ConnHost -> Bool)
-> (ConnHost -> ConnHost -> Bool)
-> (ConnHost -> ConnHost -> ConnHost)
-> (ConnHost -> ConnHost -> ConnHost)
-> Ord ConnHost
ConnHost -> ConnHost -> Bool
ConnHost -> ConnHost -> Ordering
ConnHost -> ConnHost -> ConnHost
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ConnHost -> ConnHost -> ConnHost
$cmin :: ConnHost -> ConnHost -> ConnHost
max :: ConnHost -> ConnHost -> ConnHost
$cmax :: ConnHost -> ConnHost -> ConnHost
>= :: ConnHost -> ConnHost -> Bool
$c>= :: ConnHost -> ConnHost -> Bool
> :: ConnHost -> ConnHost -> Bool
$c> :: ConnHost -> ConnHost -> Bool
<= :: ConnHost -> ConnHost -> Bool
$c<= :: ConnHost -> ConnHost -> Bool
< :: ConnHost -> ConnHost -> Bool
$c< :: ConnHost -> ConnHost -> Bool
compare :: ConnHost -> ConnHost -> Ordering
$ccompare :: ConnHost -> ConnHost -> Ordering
$cp1Ord :: Eq ConnHost
Ord, T.Typeable)

-- | @ConnKey@ consists of a hostname, a port and a @Bool@
-- specifying whether to use SSL.
data ConnKey
    = CKRaw (Maybe HostAddress) {-# UNPACK #-} !S.ByteString !Int
    | CKSecure (Maybe HostAddress) {-# UNPACK #-} !S.ByteString !Int
    | CKProxy
        {-# UNPACK #-} !S.ByteString
        !Int

        -- Proxy-Authorization request header
        (Maybe S.ByteString)

        -- ultimate host
        {-# UNPACK #-} !S.ByteString

        -- ultimate port
        !Int
    deriving (ConnKey -> ConnKey -> Bool
(ConnKey -> ConnKey -> Bool)
-> (ConnKey -> ConnKey -> Bool) -> Eq ConnKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnKey -> ConnKey -> Bool
$c/= :: ConnKey -> ConnKey -> Bool
== :: ConnKey -> ConnKey -> Bool
$c== :: ConnKey -> ConnKey -> Bool
Eq, Int -> ConnKey -> ShowS
[ConnKey] -> ShowS
ConnKey -> String
(Int -> ConnKey -> ShowS)
-> (ConnKey -> String) -> ([ConnKey] -> ShowS) -> Show ConnKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnKey] -> ShowS
$cshowList :: [ConnKey] -> ShowS
show :: ConnKey -> String
$cshow :: ConnKey -> String
showsPrec :: Int -> ConnKey -> ShowS
$cshowsPrec :: Int -> ConnKey -> ShowS
Show, Eq ConnKey
Eq ConnKey
-> (ConnKey -> ConnKey -> Ordering)
-> (ConnKey -> ConnKey -> Bool)
-> (ConnKey -> ConnKey -> Bool)
-> (ConnKey -> ConnKey -> Bool)
-> (ConnKey -> ConnKey -> Bool)
-> (ConnKey -> ConnKey -> ConnKey)
-> (ConnKey -> ConnKey -> ConnKey)
-> Ord ConnKey
ConnKey -> ConnKey -> Bool
ConnKey -> ConnKey -> Ordering
ConnKey -> ConnKey -> ConnKey
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ConnKey -> ConnKey -> ConnKey
$cmin :: ConnKey -> ConnKey -> ConnKey
max :: ConnKey -> ConnKey -> ConnKey
$cmax :: ConnKey -> ConnKey -> ConnKey
>= :: ConnKey -> ConnKey -> Bool
$c>= :: ConnKey -> ConnKey -> Bool
> :: ConnKey -> ConnKey -> Bool
$c> :: ConnKey -> ConnKey -> Bool
<= :: ConnKey -> ConnKey -> Bool
$c<= :: ConnKey -> ConnKey -> Bool
< :: ConnKey -> ConnKey -> Bool
$c< :: ConnKey -> ConnKey -> Bool
compare :: ConnKey -> ConnKey -> Ordering
$ccompare :: ConnKey -> ConnKey -> Ordering
$cp1Ord :: Eq ConnKey
Ord, T.Typeable)

-- | Status of streaming a request body from a file.
--
-- Since 0.4.9
data StreamFileStatus = StreamFileStatus
    { StreamFileStatus -> Int64
fileSize :: Int64
    , StreamFileStatus -> Int64
readSoFar :: Int64
    , StreamFileStatus -> Int
thisChunkSize :: Int
    }
    deriving (StreamFileStatus -> StreamFileStatus -> Bool
(StreamFileStatus -> StreamFileStatus -> Bool)
-> (StreamFileStatus -> StreamFileStatus -> Bool)
-> Eq StreamFileStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamFileStatus -> StreamFileStatus -> Bool
$c/= :: StreamFileStatus -> StreamFileStatus -> Bool
== :: StreamFileStatus -> StreamFileStatus -> Bool
$c== :: StreamFileStatus -> StreamFileStatus -> Bool
Eq, Int -> StreamFileStatus -> ShowS
[StreamFileStatus] -> ShowS
StreamFileStatus -> String
(Int -> StreamFileStatus -> ShowS)
-> (StreamFileStatus -> String)
-> ([StreamFileStatus] -> ShowS)
-> Show StreamFileStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StreamFileStatus] -> ShowS
$cshowList :: [StreamFileStatus] -> ShowS
show :: StreamFileStatus -> String
$cshow :: StreamFileStatus -> String
showsPrec :: Int -> StreamFileStatus -> ShowS
$cshowsPrec :: Int -> StreamFileStatus -> ShowS
Show, Eq StreamFileStatus
Eq StreamFileStatus
-> (StreamFileStatus -> StreamFileStatus -> Ordering)
-> (StreamFileStatus -> StreamFileStatus -> Bool)
-> (StreamFileStatus -> StreamFileStatus -> Bool)
-> (StreamFileStatus -> StreamFileStatus -> Bool)
-> (StreamFileStatus -> StreamFileStatus -> Bool)
-> (StreamFileStatus -> StreamFileStatus -> StreamFileStatus)
-> (StreamFileStatus -> StreamFileStatus -> StreamFileStatus)
-> Ord StreamFileStatus
StreamFileStatus -> StreamFileStatus -> Bool
StreamFileStatus -> StreamFileStatus -> Ordering
StreamFileStatus -> StreamFileStatus -> StreamFileStatus
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus
$cmin :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus
max :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus
$cmax :: StreamFileStatus -> StreamFileStatus -> StreamFileStatus
>= :: StreamFileStatus -> StreamFileStatus -> Bool
$c>= :: StreamFileStatus -> StreamFileStatus -> Bool
> :: StreamFileStatus -> StreamFileStatus -> Bool
$c> :: StreamFileStatus -> StreamFileStatus -> Bool
<= :: StreamFileStatus -> StreamFileStatus -> Bool
$c<= :: StreamFileStatus -> StreamFileStatus -> Bool
< :: StreamFileStatus -> StreamFileStatus -> Bool
$c< :: StreamFileStatus -> StreamFileStatus -> Bool
compare :: StreamFileStatus -> StreamFileStatus -> Ordering
$ccompare :: StreamFileStatus -> StreamFileStatus -> Ordering
$cp1Ord :: Eq StreamFileStatus
Ord, T.Typeable)