webby 0.3.0 → 0.3.1
raw patch · 6 files changed
+48/−50 lines, 6 filesdep +base-nopreludedep +reludedep −basedep −protoludePVP ok
version bump matches the API change (PVP)
Dependencies added: base-noprelude, relude
Dependencies removed: base, protolude
API changes (from Hackage documentation)
+ Prelude: ($!!) :: NFData a => (a -> b) -> a -> b
+ Prelude: ($!) :: () => (a -> b) -> a -> b
+ Prelude: ($) :: () => (a -> b) -> a -> b
+ Prelude: ($>) :: Functor f => f a -> b -> f b
+ Prelude: (%) :: () => Format r a -> Format r' r -> Format r' a
+ Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Prelude: (&&) :: Bool -> Bool -> Bool
+ Prelude: (&) :: () => a -> (a -> b) -> b
+ Prelude: (*) :: Num a => a -> a -> a
+ Prelude: (**) :: Floating a => a -> a -> a
+ Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Prelude: (+) :: Num a => a -> a -> a
+ Prelude: (++) :: () => [a] -> [a] -> [a]
+ Prelude: (-) :: Num a => a -> a -> a
+ Prelude: (.) :: () => (b -> c) -> (a -> b) -> a -> c
+ Prelude: (/) :: Fractional a => a -> a -> a
+ Prelude: (/=) :: Eq a => a -> a -> Bool
+ Prelude: (:|) :: a -> [a] -> NonEmpty a
+ Prelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
+ Prelude: (<$) :: Functor f => a -> f b -> f a
+ Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ Prelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ Prelude: (<) :: Ord a => a -> a -> Bool
+ Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Prelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
+ Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Prelude: (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
+ Prelude: (<=) :: Ord a => a -> a -> Bool
+ Prelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
+ Prelude: (<>) :: Semigroup a => a -> a -> a
+ Prelude: (<|>) :: Alternative f => f a -> f a -> f a
+ Prelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
+ Prelude: (==) :: Eq a => a -> a -> Bool
+ Prelude: (>) :: Ord a => a -> a -> Bool
+ Prelude: (>=) :: Ord a => a -> a -> Bool
+ Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
+ Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
+ Prelude: (?:) :: () => Maybe a -> a -> a
+ Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Prelude: (||) :: Bool -> Bool -> Bool
+ Prelude: -- | Type of single element of the structure.
+ Prelude: All :: Bool -> All
+ Prelude: Alt :: f a -> Alt
+ Prelude: Any :: Bool -> Any
+ Prelude: AppendMode :: IOMode
+ Prelude: Bug :: SomeException -> CallStack -> Bug
+ Prelude: ByteRangeFrom :: !Integer -> ByteRange
+ Prelude: ByteRangeFromTo :: !Integer -> !Integer -> ByteRange
+ Prelude: ByteRangeSuffix :: !Integer -> ByteRange
+ Prelude: CONNECT :: StdMethod
+ Prelude: ChunkedBody :: RequestBodyLength
+ Prelude: Compose :: f (g a) -> Compose
+ Prelude: Const :: a -> Const a
+ Prelude: D# :: Double# -> Double
+ Prelude: DELETE :: StdMethod
+ Prelude: Down :: a -> Down a
+ Prelude: Dual :: a -> Dual a
+ Prelude: EQ :: Ordering
+ Prelude: Endo :: (a -> a) -> Endo a
+ Prelude: ExceptT :: m (Either e a) -> ExceptT e a
+ Prelude: F# :: Float# -> Float
+ Prelude: False :: Bool
+ Prelude: FilePart :: Integer -> Integer -> Integer -> FilePart
+ Prelude: First :: Maybe a -> First a
+ Prelude: GET :: StdMethod
+ Prelude: GT :: Ordering
+ Prelude: HEAD :: StdMethod
+ Prelude: HttpVersion :: !Int -> !Int -> HttpVersion
+ Prelude: Identity :: a -> Identity a
+ Prelude: Just :: a -> Maybe a
+ Prelude: KnownLength :: Word64 -> RequestBodyLength
+ Prelude: LT :: Ordering
+ Prelude: Last :: Maybe a -> Last a
+ Prelude: Left :: a -> Either a b
+ Prelude: MaybeT :: m (Maybe a) -> MaybeT a
+ Prelude: Nothing :: Maybe a
+ Prelude: OPTIONS :: StdMethod
+ Prelude: Option :: Maybe a -> Option a
+ Prelude: PATCH :: StdMethod
+ Prelude: POST :: StdMethod
+ Prelude: PUT :: StdMethod
+ Prelude: Product :: a -> Product a
+ Prelude: Proxy :: Proxy
+ Prelude: QE :: ByteString -> EscapeItem
+ Prelude: QN :: ByteString -> EscapeItem
+ Prelude: ReadMode :: IOMode
+ Prelude: ReadWriteMode :: IOMode
+ Prelude: ReaderT :: (r -> m a) -> ReaderT r
+ Prelude: Right :: b -> Either a b
+ Prelude: StateT :: (s -> m (a, s)) -> StateT s a
+ Prelude: Status :: Int -> ByteString -> Status
+ Prelude: Sum :: a -> Sum a
+ Prelude: TRACE :: StdMethod
+ Prelude: True :: Bool
+ Prelude: Undefined :: Undefined
+ Prelude: WriteMode :: IOMode
+ Prelude: ZipList :: [a] -> ZipList a
+ Prelude: [SomeException] :: forall e. Exception e => e -> SomeException
+ Prelude: [SomeNat] :: forall (n :: Nat). KnownNat n => Proxy n -> SomeNat
+ Prelude: [appEndo] :: Endo a -> a -> a
+ Prelude: [filePartByteCount] :: FilePart -> Integer
+ Prelude: [filePartFileSize] :: FilePart -> Integer
+ Prelude: [filePartOffset] :: FilePart -> Integer
+ Prelude: [getAll] :: All -> Bool
+ Prelude: [getAlt] :: Alt -> f a
+ Prelude: [getAny] :: Any -> Bool
+ Prelude: [getCompose] :: Compose -> f (g a)
+ Prelude: [getConst] :: Const a -> a
+ Prelude: [getDual] :: Dual a -> a
+ Prelude: [getFirst] :: First a -> Maybe a
+ Prelude: [getLast] :: Last a -> Maybe a
+ Prelude: [getOption] :: Option a -> Maybe a
+ Prelude: [getProduct] :: Product a -> a
+ Prelude: [getSum] :: Sum a -> a
+ Prelude: [getZipList] :: ZipList a -> [a]
+ Prelude: [httpMajor] :: HttpVersion -> !Int
+ Prelude: [httpMinor] :: HttpVersion -> !Int
+ Prelude: [runIdentity] :: Identity a -> a
+ Prelude: [runMaybeT] :: MaybeT a -> m (Maybe a)
+ Prelude: [runReaderT] :: ReaderT r -> r -> m a
+ Prelude: [runStateT] :: StateT s a -> s -> m (a, s)
+ Prelude: [statusCode] :: Status -> Int
+ Prelude: [statusMessage] :: Status -> ByteString
+ Prelude: abs :: Num a => a -> a
+ Prelude: absurd :: () => Void -> a
+ Prelude: accepted202 :: Status
+ Prelude: acos :: Floating a => a -> a
+ Prelude: acosh :: Floating a => a -> a
+ Prelude: all :: Foldable t => (a -> Bool) -> t a -> Bool
+ Prelude: allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
+ Prelude: and :: Foldable t => t Bool -> Bool
+ Prelude: andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
+ Prelude: any :: Foldable t => (a -> Bool) -> t a -> Bool
+ Prelude: anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
+ Prelude: appendFile :: MonadIO m => FilePath -> Text -> m ()
+ Prelude: asTypeOf :: () => a -> a -> a
+ Prelude: asin :: Floating a => a -> a
+ Prelude: asinh :: Floating a => a -> a
+ Prelude: ask :: MonadReader r m => m r
+ Prelude: asks :: MonadReader r m => (r -> a) -> m a
+ Prelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
+ Prelude: atan :: Floating a => a -> a
+ Prelude: atanh :: Floating a => a -> a
+ Prelude: atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
+ Prelude: atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
+ Prelude: atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
+ Prelude: atomically :: MonadIO m => STM a -> m a
+ Prelude: badGateway502 :: Status
+ Prelude: badRequest400 :: Status
+ Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Prelude: bool :: () => a -> a -> Bool -> a
+ Prelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
+ Prelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
+ Prelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ Prelude: bug :: (HasCallStack, Exception e) => e -> a
+ Prelude: byteSwap16 :: Word16 -> Word16
+ Prelude: byteSwap32 :: Word32 -> Word32
+ Prelude: byteSwap64 :: Word64 -> Word64
+ Prelude: callStack :: HasCallStack -> CallStack
+ Prelude: catMaybes :: () => [Maybe a] -> [a]
+ Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Prelude: chr :: Int -> Char
+ Prelude: class Applicative f => Alternative (f :: Type -> Type)
+ Prelude: class Functor f => Applicative (f :: Type -> Type)
+ Prelude: class Bifunctor (p :: Type -> Type -> Type)
+ Prelude: class Bounded a
+ Prelude: class a ~R# b => Coercible (a :: k0) (b :: k0)
+ Prelude: class ConvertUtf8 a b
+ Prelude: class Enum a
+ Prelude: class Eq a
+ Prelude: class (Typeable e, Show e) => Exception e
+ Prelude: class Fractional a => Floating a
+ Prelude: class Foldable (t :: Type -> Type)
+ Prelude: class Num a => Fractional a
+ Prelude: class Functor (f :: Type -> Type)
+ Prelude: class Generic a
+ Prelude: class Hashable a
+ Prelude: class (Real a, Enum a) => Integral a
+ Prelude: class IsLabel (x :: Symbol) a
+ Prelude: class IsList l
+ Prelude: class IsString a
+ Prelude: class KnownNat (n :: Nat)
+ Prelude: class LazyStrict l s | l -> s, s -> l
+ Prelude: class Applicative m => Monad (m :: Type -> Type)
+ Prelude: class Monad m => MonadFail (m :: Type -> Type)
+ Prelude: class Monad m => MonadIO (m :: Type -> Type)
+ Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
+ Prelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
+ Prelude: class Monad m => MonadState s (m :: Type -> Type) | m -> s
+ Prelude: class MonadTrans (t :: Type -> Type -> Type -> Type)
+ Prelude: class Semigroup a => Monoid a
+ Prelude: class NFData a
+ Prelude: class Num a
+ Prelude: class One x where {
+ Prelude: class Eq a => Ord a
+ Prelude: class Print a
+ Prelude: class QueryLike a
+ Prelude: class Read a
+ Prelude: class (Num a, Ord a) => Real a
+ Prelude: class (Real a, Fractional a) => RealFrac a
+ Prelude: class Semigroup a
+ Prelude: class Show a
+ Prelude: class ToLText a
+ Prelude: class ToString a
+ Prelude: class ToText a
+ Prelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ Prelude: class Typeable (a :: k)
+ Prelude: coerce :: Coercible a b => a -> b
+ Prelude: compare :: Ord a => a -> a -> Ordering
+ Prelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
+ Prelude: concat :: Foldable t => t [a] -> [a]
+ Prelude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
+ Prelude: conflict409 :: Status
+ Prelude: const :: () => a -> b -> a
+ Prelude: continue100 :: Status
+ Prelude: cos :: Floating a => a -> a
+ Prelude: cosh :: Floating a => a -> a
+ Prelude: created201 :: Status
+ Prelude: currentCallStack :: IO [String]
+ Prelude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ Prelude: cycle :: () => [a] -> [a]
+ Prelude: cycle1 :: Semigroup m => m -> m
+ Prelude: d :: Integral a => Format r (a -> r)
+ Prelude: data Bool
+ Prelude: data Bug
+ Prelude: data ByteRange
+ Prelude: data ByteString
+ Prelude: data CallStack
+ Prelude: data Char
+ Prelude: data Constraint
+ Prelude: data Double
+ Prelude: data Either a b
+ Prelude: data EscapeItem
+ Prelude: data FilePart
+ Prelude: data Float
+ Prelude: data Handle
+ Prelude: data HashMap k v
+ Prelude: data HashSet a
+ Prelude: data HttpVersion
+ Prelude: data IO a
+ Prelude: data IOMode
+ Prelude: data IORef a
+ Prelude: data Int
+ Prelude: data Int16
+ Prelude: data Int32
+ Prelude: data Int64
+ Prelude: data Int8
+ Prelude: data IntMap a
+ Prelude: data IntSet
+ Prelude: data Integer
+ Prelude: data MVar a
+ Prelude: data Map k a
+ Prelude: data Maybe a
+ Prelude: data Nat
+ Prelude: data Natural
+ Prelude: data NonEmpty a
+ Prelude: data Ordering
+ Prelude: data Ratio a
+ Prelude: data Request
+ Prelude: data RequestBodyLength
+ Prelude: data ResourceT (m :: Type -> Type) a
+ Prelude: data Response
+ Prelude: data ResponseReceived
+ Prelude: data STM a
+ Prelude: data Seq a
+ Prelude: data Set a
+ Prelude: data SomeException
+ Prelude: data SomeNat
+ Prelude: data Status
+ Prelude: data StdMethod
+ Prelude: data TVar a
+ Prelude: data Text
+ Prelude: data Undefined
+ Prelude: data UnicodeException
+ Prelude: data Void
+ Prelude: data Word
+ Prelude: data Word16
+ Prelude: data Word32
+ Prelude: data Word64
+ Prelude: data Word8
+ Prelude: data WrappedMonoid m
+ Prelude: data IdentityT (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
+ Prelude: decodePath :: ByteString -> ([Text], Query)
+ Prelude: decodePathSegments :: ByteString -> [Text]
+ Prelude: decodeUtf8 :: ConvertUtf8 a b => b -> a
+ Prelude: decodeUtf8' :: ByteString -> Either UnicodeException Text
+ Prelude: decodeUtf8Strict :: ConvertUtf8 a b => b -> Either UnicodeException a
+ Prelude: decodeUtf8With :: OnDecodeError -> ByteString -> Text
+ Prelude: deepseq :: NFData a => a -> b -> b
+ Prelude: defaultRequest :: Request
+ Prelude: denominator :: () => Ratio a -> a
+ Prelude: die :: MonadIO m => String -> m ()
+ Prelude: displayException :: Exception e => e -> String
+ Prelude: div :: Integral a => a -> a -> a
+ Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Prelude: drop :: () => Int -> [a] -> [a]
+ Prelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ Prelude: elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
+ Prelude: empty :: Alternative f => f a
+ Prelude: encodePath :: [Text] -> Query -> Builder
+ Prelude: encodePathSegments :: [Text] -> Builder
+ Prelude: encodePathSegmentsRelative :: [Text] -> Builder
+ Prelude: encodeUtf8 :: ConvertUtf8 a b => a -> b
+ Prelude: enumFrom :: Enum a => a -> [a]
+ Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Prelude: error :: HasCallStack => Text -> a
+ Prelude: evalState :: () => State s a -> s -> a
+ Prelude: evalStateT :: Monad m => StateT s m a -> s -> m a
+ Prelude: evaluateNF :: (NFData a, MonadIO m) => a -> m a
+ Prelude: evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
+ Prelude: evaluateWHNF :: MonadIO m => a -> m a
+ Prelude: evaluateWHNF_ :: MonadIO m => a -> m ()
+ Prelude: evaluatingState :: () => s -> State s a -> a
+ Prelude: evaluatingStateT :: Functor f => s -> StateT s f a -> f a
+ Prelude: even :: Integral a => a -> Bool
+ Prelude: exceptToMaybeT :: Functor m => ExceptT e m a -> MaybeT m a
+ Prelude: execState :: () => State s a -> s -> s
+ Prelude: execStateT :: Monad m => StateT s m a -> s -> m s
+ Prelude: executingState :: () => s -> State s a -> s
+ Prelude: executingStateT :: Functor f => s -> StateT s f a -> f s
+ Prelude: exitFailure :: MonadIO m => m a
+ Prelude: exitSuccess :: MonadIO m => m a
+ Prelude: exitWith :: MonadIO m => ExitCode -> m a
+ Prelude: exp :: Floating a => a -> a
+ Prelude: expectationFailed417 :: Status
+ Prelude: extractPath :: ByteString -> ByteString
+ Prelude: fail :: MonadFail m => String -> m a
+ Prelude: filter :: () => (a -> Bool) -> [a] -> [a]
+ Prelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
+ Prelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
+ Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
+ Prelude: fix :: () => (a -> a) -> a
+ Prelude: flip :: () => (a -> b -> c) -> b -> a -> c
+ Prelude: flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
+ Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Prelude: fmap :: Functor f => (a -> b) -> f a -> f b
+ Prelude: fold :: (Foldable t, Monoid m) => t m -> m
+ Prelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
+ Prelude: foldMapA :: (Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
+ Prelude: foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
+ Prelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
+ Prelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
+ Prelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
+ Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+ Prelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
+ Prelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+ Prelude: forbidden403 :: Status
+ Prelude: force :: NFData a => a -> a
+ Prelude: forever :: Applicative f => f a -> f b
+ Prelude: format :: () => Format Text a -> a
+ Prelude: found302 :: Status
+ Prelude: fromEnum :: Enum a => a -> Int
+ Prelude: fromException :: Exception e => SomeException -> Maybe e
+ Prelude: fromInteger :: Num a => Integer -> a
+ Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Prelude: fromLabel :: IsLabel x a => a
+ Prelude: fromLazy :: LazyStrict l s => l -> s
+ Prelude: fromLeft :: () => a -> Either a b -> a
+ Prelude: fromList :: IsList l => [Item l] -> l
+ Prelude: fromListN :: IsList l => Int -> [Item l] -> l
+ Prelude: fromMaybe :: () => a -> Maybe a -> a
+ Prelude: fromRational :: Fractional a => Rational -> a
+ Prelude: fromRight :: () => b -> Either a b -> b
+ Prelude: fromStrict :: LazyStrict l s => s -> l
+ Prelude: fromString :: IsString a => String -> a
+ Prelude: fst :: () => (a, b) -> a
+ Prelude: gatewayTimeout504 :: Status
+ Prelude: gcd :: Integral a => a -> a -> a
+ Prelude: genericDrop :: Integral i => i -> [a] -> [a]
+ Prelude: genericLength :: Num i => [a] -> i
+ Prelude: genericReplicate :: Integral i => i -> a -> [a]
+ Prelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ Prelude: genericTake :: Integral i => i -> [a] -> [a]
+ Prelude: getCallStack :: CallStack -> [([Char], SrcLoc)]
+ Prelude: getLine :: MonadIO m => m Text
+ Prelude: getRequestBodyChunk :: Request -> IO ByteString
+ Prelude: getStackTrace :: IO (Maybe [Location])
+ Prelude: gets :: MonadState s m => (s -> a) -> m a
+ Prelude: gone410 :: Status
+ Prelude: group :: Eq a => [a] -> [[a]]
+ Prelude: guard :: Alternative f => Bool -> f ()
+ Prelude: guardM :: MonadPlus m => m Bool -> m ()
+ Prelude: hAccept :: HeaderName
+ Prelude: hAcceptLanguage :: HeaderName
+ Prelude: hAuthorization :: HeaderName
+ Prelude: hCacheControl :: HeaderName
+ Prelude: hConnection :: HeaderName
+ Prelude: hContentEncoding :: HeaderName
+ Prelude: hContentLength :: HeaderName
+ Prelude: hContentMD5 :: HeaderName
+ Prelude: hContentType :: HeaderName
+ Prelude: hCookie :: HeaderName
+ Prelude: hDate :: HeaderName
+ Prelude: hIfModifiedSince :: HeaderName
+ Prelude: hIfRange :: HeaderName
+ Prelude: hLastModified :: HeaderName
+ Prelude: hLocation :: HeaderName
+ Prelude: hRange :: HeaderName
+ Prelude: hReferer :: HeaderName
+ Prelude: hServer :: HeaderName
+ Prelude: hUserAgent :: HeaderName
+ Prelude: hashNub :: (Eq a, Hashable a) => [a] -> [a]
+ Prelude: hashWithSalt :: Hashable a => Int -> a -> Int
+ Prelude: head :: () => NonEmpty a -> a
+ Prelude: headMay :: [a] -> Maybe a
+ Prelude: http09 :: HttpVersion
+ Prelude: http10 :: HttpVersion
+ Prelude: http11 :: HttpVersion
+ Prelude: http20 :: HttpVersion
+ Prelude: httpVersionNotSupported505 :: Status
+ Prelude: id :: () => a -> a
+ Prelude: identity :: () => a -> a
+ Prelude: ifM :: Monad m => m Bool -> m a -> m a -> m a
+ Prelude: ifRequest :: (Request -> Bool) -> Middleware -> Middleware
+ Prelude: imATeapot418 :: Status
+ Prelude: infix 4 <=
+ Prelude: infixl 0 `on`
+ Prelude: infixl 1 <&>
+ Prelude: infixl 3 <|>
+ Prelude: infixl 4 <<$>>
+ Prelude: infixl 6 `xor`
+ Prelude: infixl 7 *
+ Prelude: infixr 0 ?:
+ Prelude: infixr 1 =<<
+ Prelude: infixr 2 ||
+ Prelude: infixr 3 &&
+ Prelude: infixr 5 :|
+ Prelude: infixr 6 <>
+ Prelude: infixr 8 ^
+ Prelude: infixr 9 %
+ Prelude: init :: () => NonEmpty a -> [a]
+ Prelude: inits :: () => [a] -> [[a]]
+ Prelude: intercalate :: () => [a] -> [[a]] -> [a]
+ Prelude: internalServerError500 :: Status
+ Prelude: intersperse :: () => a -> [a] -> [a]
+ Prelude: isJust :: () => Maybe a -> Bool
+ Prelude: isLeft :: () => Either a b -> Bool
+ Prelude: isNothing :: () => Maybe a -> Bool
+ Prelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Prelude: isRight :: () => Either a b -> Bool
+ Prelude: iterate :: () => (a -> a) -> a -> [a]
+ Prelude: join :: Monad m => m (m a) -> m a
+ Prelude: last :: () => NonEmpty a -> a
+ Prelude: lazyRequestBody :: Request -> IO ByteString
+ Prelude: lcm :: Integral a => a -> a -> a
+ Prelude: leftToMaybe :: () => Either l r -> Maybe l
+ Prelude: lefts :: () => [Either a b] -> [a]
+ Prelude: length :: Foldable t => t a -> Int
+ Prelude: lengthRequired411 :: Status
+ Prelude: lenientDecode :: OnDecodeError
+ Prelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ Prelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ Prelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ Prelude: liftIO :: MonadIO m => IO a -> m a
+ Prelude: liftResourceT :: MonadResource m => ResourceT IO a -> m a
+ Prelude: lines :: Text -> [Text]
+ Prelude: listToMaybe :: () => [a] -> Maybe a
+ Prelude: local :: MonadReader r m => (r -> r) -> m a -> m a
+ Prelude: logBase :: Floating a => a -> a -> a
+ Prelude: many :: Alternative f => f a -> f [a]
+ Prelude: map :: () => (a -> b) -> [a] -> [b]
+ Prelude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Prelude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+ Prelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
+ Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
+ Prelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
+ Prelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]
+ Prelude: mapResponseHeaders :: (ResponseHeaders -> ResponseHeaders) -> Response -> Response
+ Prelude: mapResponseStatus :: (Status -> Status) -> Response -> Response
+ Prelude: mappend :: Monoid a => a -> a -> a
+ Prelude: max :: Ord a => a -> a -> a
+ Prelude: maxBound :: Bounded a => a
+ Prelude: maxInt :: Int
+ Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ Prelude: maybeToExceptT :: Functor m => e -> MaybeT m a -> ExceptT e m a
+ Prelude: maybeToLeft :: () => r -> Maybe l -> Either l r
+ Prelude: maybeToList :: () => Maybe a -> [a]
+ Prelude: maybeToMonoid :: Monoid m => Maybe m -> m
+ Prelude: maybeToRight :: () => l -> Maybe r -> Either l r
+ Prelude: mconcat :: Monoid a => [a] -> a
+ Prelude: mempty :: Monoid a => a
+ Prelude: methodConnect :: Method
+ Prelude: methodDelete :: Method
+ Prelude: methodGet :: Method
+ Prelude: methodHead :: Method
+ Prelude: methodNotAllowed405 :: Status
+ Prelude: methodOptions :: Method
+ Prelude: methodPatch :: Method
+ Prelude: methodPost :: Method
+ Prelude: methodPut :: Method
+ Prelude: methodTrace :: Method
+ Prelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
+ Prelude: min :: Ord a => a -> a -> a
+ Prelude: minBound :: Bounded a => a
+ Prelude: minInt :: Int
+ Prelude: mkStatus :: Int -> ByteString -> Status
+ Prelude: mod :: Integral a => a -> a -> a
+ Prelude: modify :: MonadState s m => (s -> s) -> m ()
+ Prelude: modify' :: MonadState s m => (s -> s) -> m ()
+ Prelude: modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
+ Prelude: modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
+ Prelude: modifyResponse :: (Response -> Response) -> Middleware
+ Prelude: modifyTVar' :: () => TVar a -> (a -> a) -> STM ()
+ Prelude: movedPermanently301 :: Status
+ Prelude: mplus :: MonadPlus m => m a -> m a -> m a
+ Prelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
+ Prelude: multipleChoices300 :: Status
+ Prelude: mzero :: MonadPlus m => m a
+ Prelude: natVal :: KnownNat n => proxy n -> Natural
+ Prelude: negate :: Num a => a -> a
+ Prelude: networkAuthenticationRequired511 :: Status
+ Prelude: newEmptyMVar :: MonadIO m => m (MVar a)
+ Prelude: newIORef :: MonadIO m => a -> m (IORef a)
+ Prelude: newMVar :: MonadIO m => a -> m (MVar a)
+ Prelude: newTVar :: () => a -> STM (TVar a)
+ Prelude: newTVarIO :: MonadIO m => a -> m (TVar a)
+ Prelude: newtype All
+ Prelude: newtype Any
+ Prelude: newtype Down a
+ Prelude: newtype Dual a
+ Prelude: newtype Endo a
+ Prelude: newtype ExceptT e (m :: Type -> Type) a
+ Prelude: newtype First a
+ Prelude: newtype Identity a
+ Prelude: newtype Last a
+ Prelude: newtype MaybeT (m :: Type -> Type) a
+ Prelude: newtype Option a
+ Prelude: newtype Product a
+ Prelude: newtype StateT s (m :: Type -> Type) a
+ Prelude: newtype Sum a
+ Prelude: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type
+ Prelude: newtype ZipList a
+ Prelude: newtype Alt (f :: k -> Type) (a :: k) :: forall k. () => k -> Type -> k -> Type
+ Prelude: noContent204 :: Status
+ Prelude: nonAuthoritative203 :: Status
+ Prelude: nonEmpty :: () => [a] -> Maybe (NonEmpty a)
+ Prelude: not :: Bool -> Bool
+ Prelude: notAcceptable406 :: Status
+ Prelude: notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
+ Prelude: notFound404 :: Status
+ Prelude: notImplemented501 :: Status
+ Prelude: notModified304 :: Status
+ Prelude: null :: Foldable t => t a -> Bool
+ Prelude: numerator :: () => Ratio a -> a
+ Prelude: odd :: Integral a => a -> Bool
+ Prelude: ok200 :: Status
+ Prelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ Prelude: one :: One x => OneItem x -> x
+ Prelude: openFile :: MonadIO m => FilePath -> IOMode -> m Handle
+ Prelude: optional :: Alternative f => f a -> f (Maybe a)
+ Prelude: or :: Foldable t => t Bool -> Bool
+ Prelude: orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
+ Prelude: ord :: Char -> Int
+ Prelude: ordNub :: Ord a => [a] -> [a]
+ Prelude: otherwise :: Bool
+ Prelude: parseByteRanges :: ByteString -> Maybe ByteRanges
+ Prelude: parseInt :: Integral a => Text -> Maybe a
+ Prelude: parseMethod :: Method -> Either ByteString StdMethod
+ Prelude: parseQuery :: ByteString -> Query
+ Prelude: parseQueryText :: ByteString -> QueryText
+ Prelude: parseSimpleQuery :: ByteString -> SimpleQuery
+ Prelude: partialContent206 :: Status
+ Prelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ Prelude: pass :: Applicative f => f ()
+ Prelude: pattern Exc :: forall e. Exception e => () => e -> SomeException
+ Prelude: paymentRequired402 :: Status
+ Prelude: permanentRedirect308 :: Status
+ Prelude: permutations :: () => [a] -> [[a]]
+ Prelude: pi :: Floating a => a
+ Prelude: preconditionFailed412 :: Status
+ Prelude: preconditionRequired428 :: Status
+ Prelude: pred :: Enum a => a -> a
+ Prelude: prettyCallStack :: CallStack -> String
+ Prelude: prettySrcLoc :: SrcLoc -> String
+ Prelude: print :: (MonadIO m, Show a) => a -> m ()
+ Prelude: product :: (Foldable f, Num a) => f a -> a
+ Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Prelude: proxyAuthenticationRequired407 :: Status
+ Prelude: pure :: Applicative f => a -> f a
+ Prelude: putLText :: MonadIO m => Text -> m ()
+ Prelude: putLTextLn :: MonadIO m => Text -> m ()
+ Prelude: putMVar :: MonadIO m => MVar a -> a -> m ()
+ Prelude: putStr :: (Print a, MonadIO m) => a -> m ()
+ Prelude: putStrLn :: (Print a, MonadIO m) => a -> m ()
+ Prelude: putText :: MonadIO m => Text -> m ()
+ Prelude: putTextLn :: MonadIO m => Text -> m ()
+ Prelude: queryTextToQuery :: QueryText -> Query
+ Prelude: queryToQueryText :: Query -> QueryText
+ Prelude: quot :: Integral a => a -> a -> a
+ Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Prelude: readEither :: (ToString a, Read b) => a -> Either Text b
+ Prelude: readFile :: MonadIO m => FilePath -> m Text
+ Prelude: readIORef :: MonadIO m => IORef a -> m a
+ Prelude: readMVar :: MonadIO m => MVar a -> m a
+ Prelude: readMaybe :: Read a => String -> Maybe a
+ Prelude: readTVar :: () => TVar a -> STM a
+ Prelude: readTVarIO :: MonadIO m => TVar a -> m a
+ Prelude: reader :: MonadReader r m => (r -> a) -> m a
+ Prelude: reads :: Read a => ReadS a
+ Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Prelude: recip :: Fractional a => a -> a
+ Prelude: rem :: Integral a => a -> a -> a
+ Prelude: renderByteRange :: ByteRange -> ByteString
+ Prelude: renderByteRangeBuilder :: ByteRange -> Builder
+ Prelude: renderByteRanges :: ByteRanges -> ByteString
+ Prelude: renderByteRangesBuilder :: ByteRanges -> Builder
+ Prelude: renderMethod :: Either ByteString StdMethod -> Method
+ Prelude: renderQuery :: Bool -> Query -> ByteString
+ Prelude: renderQueryBuilder :: Bool -> Query -> Builder
+ Prelude: renderQueryBuilderPartialEscape :: Bool -> PartialEscapeQuery -> Builder
+ Prelude: renderQueryPartialEscape :: Bool -> PartialEscapeQuery -> ByteString
+ Prelude: renderQueryText :: Bool -> QueryText -> Builder
+ Prelude: renderSimpleQuery :: Bool -> SimpleQuery -> ByteString
+ Prelude: renderStdMethod :: StdMethod -> Method
+ Prelude: repeat :: () => a -> [a]
+ Prelude: replicate :: () => Int -> a -> [a]
+ Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
+ Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Prelude: requestEntityTooLarge413 :: Status
+ Prelude: requestHeaderFieldsTooLarge431 :: Status
+ Prelude: requestTimeout408 :: Status
+ Prelude: requestURITooLong414 :: Status
+ Prelude: requestedRangeNotSatisfiable416 :: Status
+ Prelude: resetContent205 :: Status
+ Prelude: responseBuilder :: Status -> ResponseHeaders -> Builder -> Response
+ Prelude: responseFile :: Status -> ResponseHeaders -> FilePath -> Maybe FilePart -> Response
+ Prelude: responseHeaders :: Response -> ResponseHeaders
+ Prelude: responseLBS :: Status -> ResponseHeaders -> ByteString -> Response
+ Prelude: responseRaw :: (IO ByteString -> (ByteString -> IO ()) -> IO ()) -> Response -> Response
+ Prelude: responseStatus :: Response -> Status
+ Prelude: responseStream :: Status -> ResponseHeaders -> StreamingBody -> Response
+ Prelude: responseToStream :: () => Response -> (Status, ResponseHeaders, (StreamingBody -> IO a) -> IO a)
+ Prelude: return :: Monad m => a -> m a
+ Prelude: reverse :: () => [a] -> [a]
+ Prelude: rightToMaybe :: () => Either l r -> Maybe r
+ Prelude: rights :: () => [Either a b] -> [b]
+ Prelude: rnf :: NFData a => a -> ()
+ Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Prelude: runExceptT :: () => ExceptT e m a -> m (Either e a)
+ Prelude: runReader :: () => Reader r a -> r -> a
+ Prelude: runResourceT :: MonadUnliftIO m => ResourceT m a -> m a
+ Prelude: runState :: () => State s a -> s -> (a, s)
+ Prelude: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
+ Prelude: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
+ Prelude: sconcat :: Semigroup a => NonEmpty a -> a
+ Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
+ Prelude: seeOther303 :: Status
+ Prelude: seq :: () => a -> b -> b
+ Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
+ Prelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
+ Prelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
+ Prelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
+ Prelude: serviceUnavailable503 :: Status
+ Prelude: sformat :: () => Format Text a -> a
+ Prelude: sh :: Show a => Format r (a -> r)
+ Prelude: show :: (Show a, IsString b) => a -> b
+ Prelude: showStackTrace :: IO (Maybe String)
+ Prelude: signum :: Num a => a -> a
+ Prelude: simpleQueryToQuery :: SimpleQuery -> Query
+ Prelude: sin :: Floating a => a -> a
+ Prelude: sinh :: Floating a => a -> a
+ Prelude: snd :: () => (a, b) -> b
+ Prelude: some :: Alternative f => f a -> f [a]
+ Prelude: someNatVal :: Natural -> SomeNat
+ Prelude: sort :: Ord a => [a] -> [a]
+ Prelude: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]
+ Prelude: sortNub :: Ord a => [a] -> [a]
+ Prelude: sortOn :: Ord b => (a -> b) -> [a] -> [a]
+ Prelude: sortWith :: Ord b => (a -> b) -> [a] -> [a]
+ Prelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ Prelude: sqrt :: Floating a => a -> a
+ Prelude: st :: () => Format r (Text -> r)
+ Prelude: state :: MonadState s m => (s -> (a, s)) -> m a
+ Prelude: status100 :: Status
+ Prelude: status101 :: Status
+ Prelude: status200 :: Status
+ Prelude: status201 :: Status
+ Prelude: status202 :: Status
+ Prelude: status203 :: Status
+ Prelude: status204 :: Status
+ Prelude: status205 :: Status
+ Prelude: status206 :: Status
+ Prelude: status300 :: Status
+ Prelude: status301 :: Status
+ Prelude: status302 :: Status
+ Prelude: status303 :: Status
+ Prelude: status304 :: Status
+ Prelude: status305 :: Status
+ Prelude: status307 :: Status
+ Prelude: status308 :: Status
+ Prelude: status400 :: Status
+ Prelude: status401 :: Status
+ Prelude: status402 :: Status
+ Prelude: status403 :: Status
+ Prelude: status404 :: Status
+ Prelude: status405 :: Status
+ Prelude: status406 :: Status
+ Prelude: status407 :: Status
+ Prelude: status408 :: Status
+ Prelude: status409 :: Status
+ Prelude: status410 :: Status
+ Prelude: status411 :: Status
+ Prelude: status412 :: Status
+ Prelude: status413 :: Status
+ Prelude: status414 :: Status
+ Prelude: status415 :: Status
+ Prelude: status416 :: Status
+ Prelude: status417 :: Status
+ Prelude: status418 :: Status
+ Prelude: status422 :: Status
+ Prelude: status428 :: Status
+ Prelude: status429 :: Status
+ Prelude: status431 :: Status
+ Prelude: status500 :: Status
+ Prelude: status501 :: Status
+ Prelude: status502 :: Status
+ Prelude: status503 :: Status
+ Prelude: status504 :: Status
+ Prelude: status505 :: Status
+ Prelude: status511 :: Status
+ Prelude: statusIsClientError :: Status -> Bool
+ Prelude: statusIsInformational :: Status -> Bool
+ Prelude: statusIsRedirection :: Status -> Bool
+ Prelude: statusIsServerError :: Status -> Bool
+ Prelude: statusIsSuccessful :: Status -> Bool
+ Prelude: stderr :: Handle
+ Prelude: stdin :: Handle
+ Prelude: stdout :: Handle
+ Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Prelude: stimesIdempotent :: Integral b => b -> a -> a
+ Prelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Prelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Prelude: strictDecode :: OnDecodeError
+ Prelude: strictRequestBody :: Request -> IO ByteString
+ Prelude: subsequences :: () => [a] -> [[a]]
+ Prelude: subtract :: Num a => a -> a -> a
+ Prelude: succ :: Enum a => a -> a
+ Prelude: sum :: (Foldable f, Num a) => f a -> a
+ Prelude: swap :: () => (a, b) -> (b, a)
+ Prelude: swapMVar :: MonadIO m => MVar a -> a -> m a
+ Prelude: switchingProtocols101 :: Status
+ Prelude: t :: () => Format r (Text -> r)
+ Prelude: tail :: () => NonEmpty a -> [a]
+ Prelude: tails :: () => [a] -> [[a]]
+ Prelude: take :: () => Int -> [a] -> [a]
+ Prelude: takeMVar :: MonadIO m => MVar a -> m a
+ Prelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ Prelude: tan :: Floating a => a -> a
+ Prelude: tanh :: Floating a => a -> a
+ Prelude: temporaryRedirect307 :: Status
+ Prelude: throwIO :: (MonadIO m, Exception e) => e -> m a
+ Prelude: toEnum :: Enum a => Int -> a
+ Prelude: toException :: Exception e => e -> SomeException
+ Prelude: toInteger :: Integral a => a -> Integer
+ Prelude: toLText :: ToLText a => a -> Text
+ Prelude: toLazy :: LazyStrict l s => s -> l
+ Prelude: toList :: Foldable t => t a -> [a]
+ Prelude: toQuery :: QueryLike a => a -> Query
+ Prelude: toRational :: Real a => a -> Rational
+ Prelude: toStrict :: LazyStrict l s => l -> s
+ Prelude: toString :: ToString a => a -> String
+ Prelude: toText :: ToText a => a -> Text
+ Prelude: tooManyRequests429 :: Status
+ Prelude: trace :: Print b => b -> a -> a
+ Prelude: traceId :: Text -> Text
+ Prelude: traceM :: Monad m => Text -> m ()
+ Prelude: traceShow :: Show a => a -> b -> b
+ Prelude: traceShowId :: Show a => a -> a
+ Prelude: traceShowM :: (Show a, Monad m) => a -> m ()
+ Prelude: transpose :: () => [[a]] -> [[a]]
+ Prelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Prelude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
+ Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Prelude: tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
+ Prelude: tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
+ Prelude: tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
+ Prelude: type Application = Request -> Response -> IO ResponseReceived -> IO ResponseReceived
+ Prelude: type ByteRanges = [ByteRange]
+ Prelude: type FilePath = String
+ Prelude: type HasCallStack = ?callStack :: CallStack
+ Prelude: type Header = (HeaderName, ByteString)
+ Prelude: type HeaderName = CI ByteString
+ Prelude: type LByteString = ByteString
+ Prelude: type LText = Text
+ Prelude: type Method = ByteString
+ Prelude: type Middleware = Application -> Application
+ Prelude: type OnDecodeError = OnError Word8 Char
+ Prelude: type OnError a b = String -> Maybe a -> Maybe b
+ Prelude: type PartialEscapeQuery = [PartialEscapeQueryItem]
+ Prelude: type PartialEscapeQueryItem = (ByteString, [EscapeItem])
+ Prelude: type Query = [QueryItem]
+ Prelude: type QueryItem = (ByteString, Maybe ByteString)
+ Prelude: type QueryText = [(Text, Maybe Text)]
+ Prelude: type Rational = Ratio Integer
+ Prelude: type Reader r = ReaderT r Identity
+ Prelude: type RequestHeaders = [Header]
+ Prelude: type ResponseHeaders = [Header]
+ Prelude: type SimpleQuery = [SimpleQueryItem]
+ Prelude: type SimpleQueryItem = (ByteString, ByteString)
+ Prelude: type State s = StateT s Identity
+ Prelude: type StreamingBody = Builder -> IO () -> IO () -> IO ()
+ Prelude: type String = [Char]
+ Prelude: type Type = Type
+ Prelude: type family OneItem x :: Type;
+ Prelude: unauthorized401 :: Status
+ Prelude: uncons :: () => [a] -> Maybe (a, [a])
+ Prelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ Prelude: undefined :: HasCallStack => a
+ Prelude: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]
+ Prelude: unless :: Applicative f => Bool -> f () -> f ()
+ Prelude: unlessM :: Monad m => m Bool -> m () -> m ()
+ Prelude: unlines :: [Text] -> Text
+ Prelude: unprocessableEntity422 :: Status
+ Prelude: unstableNub :: (Eq a, Hashable a) => [a] -> [a]
+ Prelude: unsupportedMediaType415 :: Status
+ Prelude: unwords :: [Text] -> Text
+ Prelude: unzip :: () => [(a, b)] -> ([a], [b])
+ Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Prelude: urlDecode :: Bool -> ByteString -> ByteString
+ Prelude: urlEncode :: Bool -> ByteString -> ByteString
+ Prelude: urlEncodeBuilder :: Bool -> ByteString -> Builder
+ Prelude: useProxy305 :: Status
+ Prelude: usingReader :: () => r -> Reader r a -> a
+ Prelude: usingReaderT :: () => r -> ReaderT r m a -> m a
+ Prelude: usingState :: () => s -> State s a -> (a, s)
+ Prelude: usingStateT :: () => s -> StateT s m a -> m (a, s)
+ Prelude: vacuous :: Functor f => f Void -> f a
+ Prelude: viaNonEmpty :: () => (NonEmpty a -> b) -> [a] -> Maybe b
+ Prelude: void :: Functor f => f a -> f ()
+ Prelude: when :: Applicative f => Bool -> f () -> f ()
+ Prelude: whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
+ Prelude: whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
+ Prelude: whenLeft :: Applicative f => a -> Either l r -> (l -> f a) -> f a
+ Prelude: whenLeftM :: Monad m => a -> m (Either l r) -> (l -> m a) -> m a
+ Prelude: whenLeftM_ :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
+ Prelude: whenLeft_ :: Applicative f => Either l r -> (l -> f ()) -> f ()
+ Prelude: whenM :: Monad m => m Bool -> m () -> m ()
+ Prelude: whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
+ Prelude: whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
+ Prelude: whenNothing :: Applicative f => Maybe a -> f a -> f a
+ Prelude: whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
+ Prelude: whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
+ Prelude: whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
+ Prelude: whenRight :: Applicative f => a -> Either l r -> (r -> f a) -> f a
+ Prelude: whenRightM :: Monad m => a -> m (Either l r) -> (r -> m a) -> m a
+ Prelude: whenRightM_ :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
+ Prelude: whenRight_ :: Applicative f => Either l r -> (r -> f ()) -> f ()
+ Prelude: withFile :: () => FilePath -> IOMode -> (Handle -> IO r) -> IO r
+ Prelude: withFrozenCallStack :: HasCallStack => (HasCallStack -> a) -> a
+ Prelude: withReader :: () => (r' -> r) -> Reader r a -> Reader r' a
+ Prelude: withReaderT :: () => (r' -> r) -> ReaderT r m a -> ReaderT r' m a
+ Prelude: withState :: () => (s -> s) -> State s a -> State s a
+ Prelude: words :: Text -> [Text]
+ Prelude: writeFile :: MonadIO m => FilePath -> Text -> m ()
+ Prelude: writeIORef :: MonadIO m => IORef a -> a -> m ()
+ Prelude: writeTVar :: () => TVar a -> a -> STM ()
+ Prelude: xor :: Bits a => a -> a -> a
+ Prelude: zip :: () => [a] -> [b] -> [(a, b)]
+ Prelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ Prelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ Prelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
+ Prelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
+ Prelude: }
Files
- src/Prelude.hs +31/−0
- src/Webby/Server.hs +5/−5
- src/Webby/Types.hs +1/−1
- src/WebbyPrelude.hs +0/−33
- test/Spec.hs +1/−1
- webby.cabal +10/−10
+ src/Prelude.hs view
@@ -0,0 +1,31 @@+module Prelude+ ( module Exports++ -- | Custom prelude functions+ , parseInt+ , headMay+ ) where++import Control.Monad.Trans.Resource as Exports (ResourceT,+ liftResourceT,+ runResourceT)+import Network.HTTP.Types as Exports+import Network.Wai as Exports+import Relude as Exports hiding (get, put)++-- import Data.Text.Encoding (decodeUtf8With)+-- import Data.Text.Encoding.Error (lenientDecode)+import qualified Data.Text.Read as TR++import UnliftIO.Exception as Exports (throwIO)++-- Text formatting+import Formatting as Exports (format, sformat, (%))+import Formatting.ShortFormatters as Exports (d, sh, st, t)++parseInt :: Integral a => Text -> Maybe a+parseInt t' = either (const Nothing) Just $ fmap fst $ TR.decimal t'++headMay :: [a] -> Maybe a+headMay [] = Nothing+headMay (a:_) = Just a
src/Webby/Server.hs view
@@ -16,7 +16,7 @@ import qualified UnliftIO.Exception as E import Web.HttpApiData -import WebbyPrelude+import Prelude import Webby.Types @@ -95,7 +95,7 @@ header :: HeaderName -> WebbyM appEnv (Maybe Text) header n = do hs <- requestHeaders <$> request- return $ headMay $ map (decodeUtf8Lenient . snd) $ filter ((n == ) . fst) hs+ return $ headMay $ map (decodeUtf8 . snd) $ filter ((n == ) . fst) hs request :: WebbyM appEnv Request request = asks weRequest@@ -112,7 +112,7 @@ requestBodyLength :: WebbyM appEnv (Maybe Int64) requestBodyLength = do hMay <- header hContentLength- return $ do val <- toS <$> hMay+ return $ do val <- hMay parseInt val finish :: WebbyM appEnv a@@ -209,10 +209,10 @@ E.Handler (\(ex :: WebbyError) -> case ex of wmc@(WebbyMissingCapture _) -> respond $ responseLBS status404 [] $- toS $ displayException wmc+ encodeUtf8 $ displayException wmc _ -> respond $ responseLBS status400 [] $- toS $ displayException ex+ encodeUtf8 $ displayException ex ) -- Handles Webby's finish statement
src/Webby/Types.hs view
@@ -10,7 +10,7 @@ import qualified UnliftIO as U import qualified UnliftIO.Concurrent as Conc -import WebbyPrelude+import Prelude -- | A data type to represent parts of the response constructed in the -- handler when servicing a request.
− src/WebbyPrelude.hs
@@ -1,33 +0,0 @@-module WebbyPrelude- ( module Exports-- -- | Custom prelude functions- , decodeUtf8Lenient- , parseInt- ) where--import Control.Monad.Trans.Resource as Exports (ResourceT,- liftResourceT,- runResourceT)-import Network.HTTP.Types as Exports-import Network.Wai as Exports-import Protolude as Exports hiding (get, put, (%))--import Data.Text.Encoding as Exports (encodeUtf8)---- Imports for custom functionality coded in this module.-import Data.Text.Encoding (decodeUtf8With)-import Data.Text.Encoding.Error (lenientDecode)-import qualified Data.Text.Read as TR---- Text formatting-import Formatting as Exports (format, sformat, (%))-import Formatting.ShortFormatters as Exports (d, sh, st, t)---- Decode UTF8 leniently (by replacing an invalid input byte with the--- Unicode replacement character U+FFFD).-decodeUtf8Lenient :: ByteString -> Text-decodeUtf8Lenient = decodeUtf8With lenientDecode--parseInt :: Integral a => Text -> Maybe a-parseInt t' = hush $ fmap fst $ TR.decimal t'
test/Spec.hs view
@@ -7,7 +7,7 @@ import Webby.Server import Webby.Types-import WebbyPrelude+import Prelude main :: IO () main = defaultMain tests
webby.cabal view
@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 453573afb20aa05fec6830a6c56f09a3e0ce3770df20ecc25fecb5f278073e09+-- hash: 65bbfd9f416a142a8a1486ee20e9bf0dc2bb5715c5086ae8f3587951a83de9b8 name: webby-version: 0.3.0+version: 0.3.1 synopsis: A super-simple web server framework description: A super-simple, easy to use web server framework inspired by Scotty. The goals of the project are: (1) Be easy to use (2) Allow@@ -38,7 +38,7 @@ ghc-options: -Wall build-depends: aeson >=1.2 && <1.5- , base >=4.7 && <5+ , base-noprelude >=4.7 && <5 , binary >=0.8 && <0.9 , bytestring >=0.10 && <0.11 , fast-logger >=2.4 && <2.5@@ -46,20 +46,20 @@ , http-api-data >=0.3 && <0.5 , http-types >=0.12 && <0.13 , monad-logger >=0.3 && <0.4- , protolude >=0.2 && <0.3+ , relude , resourcet >=1.2 && <1.3 , text >=1.2 && <1.3 , unliftio >=0.2.7 && <0.3 , unordered-containers >=0.2.9 && <0.3 , wai >=3.2 && <3.3 if flag(dev)- ghc-options: -Werror+ ghc-options: -Wall -Werror exposed-modules: Webby+ Prelude other-modules: Webby.Server Webby.Types- WebbyPrelude Paths_webby default-language: Haskell2010 @@ -67,10 +67,10 @@ type: exitcode-stdio-1.0 main-is: Spec.hs other-modules:+ Prelude Webby Webby.Server Webby.Types- WebbyPrelude Paths_webby hs-source-dirs: src@@ -79,7 +79,7 @@ ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N build-depends: aeson >=1.2 && <1.5- , base >=4.7 && <5+ , base-noprelude >=4.7 && <5 , binary >=0.8 && <0.9 , bytestring >=0.10 && <0.11 , fast-logger >=2.4 && <2.5@@ -87,7 +87,7 @@ , http-api-data >=0.3 && <0.5 , http-types >=0.12 && <0.13 , monad-logger >=0.3 && <0.4- , protolude >=0.2 && <0.3+ , relude , resourcet >=1.2 && <1.3 , tasty , tasty-hunit@@ -98,5 +98,5 @@ , wai >=3.2 && <3.3 , webby if flag(dev)- ghc-options: -Werror+ ghc-options: -Wall -Werror default-language: Haskell2010