-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A Testing Framework for Haskell
--   
--   Hspec is a testing framework for Haskell. Some of Hspec's distinctive
--   features are:
--   
--   <ul>
--   <li>a friendly DSL for defining tests</li>
--   <li>integration with QuickCheck, SmallCheck, and HUnit</li>
--   <li>parallel test execution</li>
--   <li>automatic discovery of test files</li>
--   </ul>
--   
--   The Hspec Manual is at <a>https://hspec.github.io/</a>.
@package hspec
@version 2.11.12


-- | <i>Warning: This module is used by <tt>hspec-discover</tt>. It is not
--   part of the public API and may change at any time.</i>
module Test.Hspec.Discover
type Spec = SpecWith ()
hspec :: Spec -> IO ()
class IsFormatter a
toFormatter :: IsFormatter a => a -> IO Formatter
hspecWithFormatter :: IsFormatter a => a -> Spec -> IO ()
postProcessSpec :: FilePath -> Spec -> Spec
describe :: HasCallStack => String -> SpecWith a -> SpecWith a
(.) :: (b -> c) -> (a -> b) -> a -> c
class Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
negate :: Num a => a -> a
abs :: Num a => a -> a
signum :: Num a => a -> a
fromInteger :: Num a => Integer -> a
data IO a
type FilePath = String
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
type String = [Char]
(++) :: [a] -> [a] -> [a]
otherwise :: Bool
data Char
data Bool
False :: Bool
True :: Bool
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
($) :: (a -> b) -> a -> b
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
class Foldable (t :: Type -> Type)
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
null :: Foldable t => t a -> Bool
length :: Foldable t => t a -> Int
elem :: (Foldable t, Eq a) => a -> t a -> Bool
maximum :: (Foldable t, Ord a) => t a -> a
minimum :: (Foldable t, Ord a) => t a -> a
sum :: (Foldable t, Num a) => t a -> a
product :: (Foldable t, Num a) => t a -> a
ioError :: IOError -> IO a
data Double
data Float
data Int
data Word
data Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
class a ~# b => (a :: k) ~ (b :: k)
data Integer
map :: (a -> b) -> [a] -> [b]
class Functor f => Applicative (f :: Type -> Type)
pure :: Applicative f => a -> f a
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
(*>) :: Applicative f => f a -> f b -> f b
(<*) :: Applicative f => f a -> f b -> f a
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
class Semigroup a
(<>) :: Semigroup a => a -> a -> a
all :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
concat :: Foldable t => t [a] -> [a]
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
or :: Foldable t => t Bool -> Bool
lines :: String -> [String]
unlines :: [String] -> String
unwords :: [String] -> String
words :: String -> [String]
(!!) :: HasCallStack => [a] -> Int -> a
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: HasCallStack => [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
head :: HasCallStack => [a] -> a
init :: HasCallStack => [a] -> [a]
iterate :: (a -> a) -> a -> [a]
last :: HasCallStack => [a] -> a
lookup :: Eq a => a -> [(a, b)] -> Maybe b
repeat :: a -> [a]
replicate :: Int -> a -> [a]
reverse :: [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
splitAt :: Int -> [a] -> ([a], [a])
tail :: HasCallStack => [a] -> [a]
take :: Int -> [a] -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
class Read a
readsPrec :: Read a => Int -> ReadS a
readList :: Read a => ReadS [a]
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
showParen :: Bool -> ShowS -> ShowS
showString :: String -> ShowS
read :: Read a => String -> a
type ReadS a = String -> [(a, String)]
type ShowS = String -> String
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
maybe :: b -> (a -> b) -> Maybe a -> b
type IOError = IOException
fromIntegral :: (Integral a, Num b) => a -> b
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b
either :: (a -> c) -> (b -> c) -> Either a b -> c
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
(<$>) :: Functor f => (a -> b) -> f a -> f b
curry :: ((a, b) -> c) -> a -> b -> c
fst :: (a, b) -> a
snd :: (a, b) -> b
uncurry :: (a -> b -> c) -> (a, b) -> c
($!) :: (a -> b) -> a -> b
(=<<) :: Monad m => (a -> m b) -> m a -> m b
asTypeOf :: a -> a -> a
const :: a -> b -> a
flip :: (a -> b -> c) -> b -> a -> c
id :: a -> a
until :: (a -> Bool) -> (a -> a) -> a -> a
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
class Enum a
succ :: Enum a => a -> a
pred :: Enum a => a -> a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
enumFrom :: Enum a => a -> [a]
enumFromThen :: Enum a => a -> a -> [a]
enumFromTo :: Enum a => a -> a -> [a]
enumFromThenTo :: Enum a => a -> a -> a -> [a]
error :: HasCallStack => [Char] -> a
errorWithoutStackTrace :: [Char] -> a
undefined :: HasCallStack => a
class Fractional a => Floating a
pi :: Floating a => a
exp :: Floating a => a -> a
log :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
class (RealFrac a, Floating a) => RealFloat a
floatRadix :: RealFloat a => a -> Integer
floatDigits :: RealFloat a => a -> Int
floatRange :: RealFloat a => a -> (Int, Int)
decodeFloat :: RealFloat a => a -> (Integer, Int)
encodeFloat :: RealFloat a => Integer -> Int -> a
exponent :: RealFloat a => a -> Int
significand :: RealFloat a => a -> a
scaleFloat :: RealFloat a => Int -> a -> a
isNaN :: RealFloat a => a -> Bool
isInfinite :: RealFloat a => a -> Bool
isDenormalized :: RealFloat a => a -> Bool
isNegativeZero :: RealFloat a => a -> Bool
isIEEE :: RealFloat a => a -> Bool
atan2 :: RealFloat a => a -> a -> a
userError :: String -> IOError
subtract :: Num a => a -> a -> a
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
class Num a => Fractional a
(/) :: Fractional a => a -> a -> a
recip :: Fractional a => a -> a
fromRational :: Fractional a => Rational -> a
class (Real a, Enum a) => Integral a
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
divMod :: Integral a => a -> a -> (a, a)
toInteger :: Integral a => a -> Integer
type Rational = Ratio Integer
class (Num a, Ord a) => Real a
toRational :: Real a => a -> Rational
class (Real a, Fractional a) => RealFrac a
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
truncate :: (RealFrac a, Integral b) => a -> b
round :: (RealFrac a, Integral b) => a -> b
ceiling :: (RealFrac a, Integral b) => a -> b
floor :: (RealFrac a, Integral b) => a -> b
(^) :: (Num a, Integral b) => a -> b -> a
(^^) :: (Fractional a, Integral b) => a -> b -> a
even :: Integral a => a -> Bool
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
odd :: Integral a => a -> Bool
realToFrac :: (Real a, Fractional b) => a -> b
showChar :: Char -> ShowS
shows :: Show a => a -> ShowS
appendFile :: FilePath -> String -> IO ()
getChar :: IO Char
getContents :: IO String
getLine :: IO String
interact :: (String -> String) -> IO ()
print :: Show a => a -> IO ()
putChar :: Char -> IO ()
putStr :: String -> IO ()
putStrLn :: String -> IO ()
readFile :: FilePath -> IO String
readIO :: Read a => String -> IO a
readLn :: Read a => IO a
writeFile :: FilePath -> String -> IO ()
reads :: Read a => ReadS a
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
seq :: a -> b -> b
instance Test.Hspec.Discover.IsFormatter Test.Hspec.Core.Formatters.V1.Monad.Formatter
instance Test.Hspec.Discover.IsFormatter (GHC.Types.IO Test.Hspec.Core.Formatters.V1.Monad.Formatter)



-- | <i>Deprecated: Use <a>Test.Hspec.Api.Formatters.V1</a> instead.</i>
module Test.Hspec.Formatters
data Formatter
Formatter :: FormatM () -> ([String] -> String -> FormatM ()) -> FormatM () -> (Path -> FormatM ()) -> (Path -> Progress -> FormatM ()) -> (Path -> String -> FormatM ()) -> (Path -> String -> FailureReason -> FormatM ()) -> (Path -> String -> Maybe String -> FormatM ()) -> FormatM () -> FormatM () -> Formatter
[headerFormatter] :: Formatter -> FormatM ()
[exampleGroupStarted] :: Formatter -> [String] -> String -> FormatM ()
[exampleGroupDone] :: Formatter -> FormatM ()
[exampleStarted] :: Formatter -> Path -> FormatM ()
[exampleProgress] :: Formatter -> Path -> Progress -> FormatM ()
[exampleSucceeded] :: Formatter -> Path -> String -> FormatM ()
[exampleFailed] :: Formatter -> Path -> String -> FailureReason -> FormatM ()
[examplePending] :: Formatter -> Path -> String -> Maybe String -> FormatM ()
[failedFormatter] :: Formatter -> FormatM ()
[footerFormatter] :: Formatter -> FormatM ()
data FailureReason
NoReason :: FailureReason
Reason :: String -> FailureReason
ExpectedButGot :: Maybe String -> String -> String -> FailureReason
Error :: Maybe String -> SomeException -> FailureReason
formatterToFormat :: Formatter -> FormatConfig -> IO Format
checks :: Formatter
newtype Seconds
Seconds :: Double -> Seconds
failed_examples :: Formatter
progress :: Formatter
silent :: Formatter
specdoc :: Formatter
data FailureRecord
FailureRecord :: Maybe Location -> Path -> FailureReason -> FailureRecord
[failureRecordLocation] :: FailureRecord -> Maybe Location
[failureRecordPath] :: FailureRecord -> Path
[failureRecordMessage] :: FailureRecord -> FailureReason
type FormatM = Free FormatF
extraChunk :: String -> FormatM ()
getCPUTime :: FormatM (Maybe Seconds)
getFailCount :: FormatM Int
getFailMessages :: FormatM [FailureRecord]
getPendingCount :: FormatM Int
getRealTime :: FormatM Seconds
getSuccessCount :: FormatM Int
getTotalCount :: FormatM Int
missingChunk :: String -> FormatM ()
useDiff :: FormatM Bool
usedSeed :: FormatM Integer
withFailColor :: FormatM a -> FormatM a
withInfoColor :: FormatM a -> FormatM a
withPendingColor :: FormatM a -> FormatM a
withSuccessColor :: FormatM a -> FormatM a
write :: String -> FormatM ()
writeLine :: String -> FormatM ()
writeTransient :: String -> FormatM ()
formatException :: SomeException -> String

module Test.Hspec.Runner
type Spec = SpecWith ()
type SpecWith a = SpecM a ()
hspec :: Spec -> IO ()
hspecWith :: Config -> Spec -> IO ()
defaultConfig :: Config
data Config
Config :: Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Maybe Int -> Bool -> Bool -> Bool -> Maybe Integer -> Maybe Integer -> Maybe FilePath -> Bool -> Bool -> Maybe (Path -> Bool) -> Maybe (Path -> Bool) -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> ColorMode -> UnicodeMode -> Bool -> Maybe Int -> Maybe (Maybe Int -> String -> String -> IO ()) -> Bool -> (Bool -> String -> String -> (String, String)) -> (SomeException -> String) -> Bool -> Bool -> [(String, FormatConfig -> IO Format)] -> Maybe (FormatConfig -> IO Format) -> Maybe Formatter -> Bool -> Maybe Int -> Annotations -> Config
[configIgnoreConfigFile] :: Config -> Bool
[configDryRun] :: Config -> Bool
[configFocusedOnly] :: Config -> Bool
[configFailOnEmpty] :: Config -> Bool
[configFailOnFocused] :: Config -> Bool
[configFailOnPending] :: Config -> Bool
[configFailOnEmptyDescription] :: Config -> Bool
[configPrintSlowItems] :: Config -> Maybe Int
[configPrintCpuTime] :: Config -> Bool
[configFailFast] :: Config -> Bool
[configRandomize] :: Config -> Bool
[configSeed] :: Config -> Maybe Integer
[configQuickCheckSeed] :: Config -> Maybe Integer
[configFailureReport] :: Config -> Maybe FilePath
[configRerun] :: Config -> Bool
[configRerunAllOnSuccess] :: Config -> Bool
[configFilterPredicate] :: Config -> Maybe (Path -> Bool)
[configSkipPredicate] :: Config -> Maybe (Path -> Bool)
[configQuickCheckMaxSuccess] :: Config -> Maybe Int
[configQuickCheckMaxDiscardRatio] :: Config -> Maybe Int
[configQuickCheckMaxSize] :: Config -> Maybe Int
[configQuickCheckMaxShrinks] :: Config -> Maybe Int
[configSmallCheckDepth] :: Config -> Maybe Int
[configColorMode] :: Config -> ColorMode
[configUnicodeMode] :: Config -> UnicodeMode
[configDiff] :: Config -> Bool
[configDiffContext] :: Config -> Maybe Int
[configExternalDiff] :: Config -> Maybe (Maybe Int -> String -> String -> IO ())
[configPrettyPrint] :: Config -> Bool
[configPrettyPrintFunction] :: Config -> Bool -> String -> String -> (String, String)
[configFormatException] :: Config -> SomeException -> String
[configTimes] :: Config -> Bool
[configExpertMode] :: Config -> Bool
[configAvailableFormatters] :: Config -> [(String, FormatConfig -> IO Format)]
[configFormat] :: Config -> Maybe (FormatConfig -> IO Format)
[configFormatter] :: Config -> Maybe Formatter
[configHtmlOutput] :: Config -> Bool
[configConcurrentJobs] :: Config -> Maybe Int
[configAnnotations] :: Config -> Annotations
configAddFilter :: (Path -> Bool) -> Config -> Config
readConfig :: Config -> [String] -> IO Config
data ColorMode
ColorAuto :: ColorMode
ColorNever :: ColorMode
ColorAlways :: ColorMode
data UnicodeMode
UnicodeAuto :: UnicodeMode
UnicodeNever :: UnicodeMode
UnicodeAlways :: UnicodeMode
data ResultItem
data ResultItemStatus
ResultItemSuccess :: ResultItemStatus
ResultItemPending :: ResultItemStatus
ResultItemFailure :: ResultItemStatus
data SpecResult
data Summary
Summary :: !Int -> !Int -> Summary
[summaryExamples] :: Summary -> !Int
[summaryFailures] :: Summary -> !Int
isSuccess :: Summary -> Bool
resultItemIsFailure :: ResultItem -> Bool
toSummary :: SpecResult -> Summary
type Path = ([String], String)
registerDefaultFormatter :: (String, FormatConfig -> IO Format) -> Config -> Config
registerFormatter :: (String, FormatConfig -> IO Format) -> Config -> Config
evalSpec :: Config -> SpecWith a -> IO (Config, [SpecTree a])
evaluateResult :: SpecResult -> IO ()
evaluateSummary :: Summary -> IO ()
hspecResult :: Spec -> IO Summary
hspecWithResult :: Config -> Spec -> IO Summary
runSpec :: Spec -> Config -> IO Summary
runSpecForest :: [SpecTree ()] -> Config -> IO SpecResult


-- | Hspec is a testing framework for Haskell.
--   
--   This is the library reference for Hspec. The <a>User's Manual</a>
--   contains more in-depth documentation.
module Test.Hspec
type Spec = SpecWith ()
type SpecWith a = SpecM a ()
type family Arg e
class Example e
type Selector a = a -> Bool
type HasCallStack = ?callStack :: CallStack
type Expectation = Assertion
shouldBe :: (HasCallStack, Show a, Eq a) => a -> a -> Expectation
shouldContain :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldEndWith :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldMatchList :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldNotBe :: (HasCallStack, Show a, Eq a) => a -> a -> Expectation
shouldNotContain :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldNotReturn :: (HasCallStack, Show a, Eq a) => IO a -> a -> Expectation
shouldNotSatisfy :: (HasCallStack, Show a) => a -> (a -> Bool) -> Expectation
shouldReturn :: (HasCallStack, Show a, Eq a) => IO a -> a -> Expectation
shouldSatisfy :: (HasCallStack, Show a) => a -> (a -> Bool) -> Expectation
shouldStartWith :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldThrow :: (HasCallStack, Exception e) => IO a -> Selector e -> Expectation
anyArithException :: Selector ArithException
anyErrorCall :: Selector ErrorCall
anyException :: Selector SomeException
anyIOException :: Selector IOException
errorCall :: String -> Selector ErrorCall
expectationFailure :: HasCallStack => String -> Expectation
it :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
specify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
describe :: HasCallStack => String -> SpecWith a -> SpecWith a
context :: HasCallStack => String -> SpecWith a -> SpecWith a

-- | <tt>example</tt> is a type restricted version of <a>id</a>. It can be
--   used to get better error messages on type mismatches.
--   
--   Compare e.g.
--   
--   <pre>
--   it "exposes some behavior" $ example $ do
--     putStrLn
--   </pre>
--   
--   with
--   
--   <pre>
--   it "exposes some behavior" $ do
--     putStrLn
--   </pre>
example :: Expectation -> Expectation
parallel :: SpecWith a -> SpecWith a
sequential :: SpecWith a -> SpecWith a
runIO :: IO r -> SpecM a r
pending :: HasCallStack => Expectation
pendingWith :: HasCallStack => String -> Expectation
xit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
xspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
xdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
xcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
focus :: SpecWith a -> SpecWith a
fit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
fspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
fdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
fcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
type ActionWith a = a -> IO ()
before :: IO a -> SpecWith a -> Spec
before_ :: IO () -> SpecWith a -> SpecWith a
beforeWith :: (b -> IO a) -> SpecWith a -> SpecWith b
beforeAll :: HasCallStack => IO a -> SpecWith a -> Spec
beforeAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a
beforeAllWith :: HasCallStack => (b -> IO a) -> SpecWith a -> SpecWith b
after :: ActionWith a -> SpecWith a -> SpecWith a
after_ :: IO () -> SpecWith a -> SpecWith a
afterAll :: HasCallStack => ActionWith a -> SpecWith a -> SpecWith a
afterAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a
around :: (ActionWith a -> IO ()) -> SpecWith a -> Spec
around_ :: (IO () -> IO ()) -> SpecWith a -> SpecWith a
aroundWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
aroundAll :: HasCallStack => (ActionWith a -> IO ()) -> SpecWith a -> Spec
aroundAll_ :: HasCallStack => (IO () -> IO ()) -> SpecWith a -> SpecWith a
aroundAllWith :: HasCallStack => (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
mapSubject :: (b -> a) -> SpecWith a -> SpecWith b
ignoreSubject :: SpecWith () -> SpecWith a
hspec :: Spec -> IO ()

module Test.Hspec.QuickCheck
modifyArgs :: (Args -> Args) -> SpecWith a -> SpecWith a
modifyMaxSuccess :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxDiscardRatio :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxSize :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxShrinks :: (Int -> Int) -> SpecWith a -> SpecWith a

-- | <pre>
--   prop ".." $
--     ..
--   </pre>
--   
--   is a shortcut for
--   
--   <pre>
--   <a>it</a> ".." $ <a>property</a> $
--     ..
--   </pre>
prop :: (HasCallStack, Testable prop) => String -> prop -> Spec

-- | <pre>
--   xprop ".." $
--     ..
--   </pre>
--   
--   is a shortcut for
--   
--   <pre>
--   <a>xit</a> ".." $ <a>property</a> $
--     ..
--   </pre>
xprop :: (HasCallStack, Testable prop) => String -> prop -> Spec

-- | <pre>
--   fprop ".." $
--     ..
--   </pre>
--   
--   is a shortcut for
--   
--   <pre>
--   <a>fit</a> ".." $ <a>property</a> $
--     ..
--   </pre>
fprop :: (HasCallStack, Testable prop) => String -> prop -> Spec
