Safe Haskell | Safe-Inferred |
---|---|
Language | GHC2021 |
Synopsis
- class Show1 (f :: TYPE LiftedRep -> TYPE LiftedRep)
- class Eq1 f => Ord1 (f :: Type -> Type)
- class Eq1 (f :: Type -> Type)
- showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
- eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
- compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
- (/==) :: (MonadTest m, Eq a, Show a, HasCallStack) => a -> a -> m ()
- (===) :: (MonadTest m, Eq a, Show a, HasCallStack) => a -> a -> m ()
- annotate :: (MonadTest m, HasCallStack) => String -> m ()
- annotateShow :: (MonadTest m, Show a, HasCallStack) => a -> m ()
- assert :: (MonadTest m, HasCallStack) => Bool -> m ()
- classify :: (MonadTest m, HasCallStack) => LabelName -> Bool -> m ()
- collect :: (MonadTest m, Show a, HasCallStack) => a -> m ()
- cover :: (MonadTest m, HasCallStack) => CoverPercentage -> LabelName -> Bool -> m ()
- diff :: (MonadTest m, Show a, Show b, HasCallStack) => a -> (a -> b -> Bool) -> b -> m ()
- discard :: forall (m :: Type -> Type) a. Monad m => PropertyT m a
- eval :: (MonadTest m, HasCallStack) => a -> m a
- evalEither :: (MonadTest m, Show x, HasCallStack) => Either x a -> m a
- evalEitherM :: (MonadTest m, Show x, MonadCatch m, HasCallStack) => m (Either x a) -> m a
- evalExceptT :: (MonadTest m, Show x, HasCallStack) => ExceptT x m a -> m a
- evalIO :: (MonadTest m, MonadIO m, HasCallStack) => IO a -> m a
- evalM :: (MonadTest m, MonadCatch m, HasCallStack) => m a -> m a
- evalMaybe :: (MonadTest m, Show a, HasCallStack) => Maybe a -> m a
- evalMaybeM :: (MonadTest m, Show a, MonadCatch m, HasCallStack) => m (Maybe a) -> m a
- evalNF :: (MonadTest m, NFData a, HasCallStack) => a -> m a
- failure :: (MonadTest m, HasCallStack) => m a
- footnote :: MonadTest m => String -> m ()
- footnoteShow :: (MonadTest m, Show a) => a -> m ()
- forAll :: forall (m :: Type -> Type) a. (Monad m, Show a, HasCallStack) => Gen a -> PropertyT m a
- forAllWith :: forall (m :: Type -> Type) a. (Monad m, HasCallStack) => (a -> String) -> Gen a -> PropertyT m a
- label :: (MonadTest m, HasCallStack) => LabelName -> m ()
- property :: HasCallStack => PropertyT IO () -> Property
- success :: MonadTest m => m ()
- verifiedTermination :: Property -> Property
- withConfidence :: Confidence -> Property -> Property
- withDiscards :: DiscardLimit -> Property -> Property
- withRetries :: ShrinkRetries -> Property -> Property
- withShrinks :: ShrinkLimit -> Property -> Property
- withTests :: TestLimit -> Property -> Property
- check :: MonadIO m => Property -> m Bool
- checkParallel :: MonadIO m => Group -> m Bool
- checkSequential :: MonadIO m => Group -> m Bool
- recheck :: MonadIO m => Size -> Seed -> Property -> m ()
- concrete :: Var a Concrete -> a
- executeParallel :: (MonadTest m, MonadCatch m, MonadBaseControl IO m, HasCallStack) => (forall (v :: Type -> Type). state v) -> Parallel m state -> m ()
- executeSequential :: (MonadTest m, MonadCatch m, HasCallStack) => (forall (v :: Type -> Type). state v) -> Sequential m state -> m ()
- opaque :: Var (Opaque a) Concrete -> a
- discover :: TExpQ Group
- discoverPrefix :: String -> TExpQ Group
- tripping :: (MonadTest m, Applicative f, Show b, Show (f a), Eq (f a), HasCallStack) => a -> (a -> b) -> (b -> f a) -> m ()
- class FunctorB (b :: (k -> Type) -> Type) where
- bmap :: (forall (a :: k). f a -> g a) -> b f -> b g
- class FunctorB b => TraversableB (b :: (k -> Type) -> Type) where
- btraverse :: Applicative e => (forall (a :: k). f a -> e (g a)) -> b f -> e (b g)
- newtype Rec p a (x :: k) = Rec {}
- distributeT :: forall f (m :: Type -> Type) a. (MonadTransDistributive g, Transformer f g m) => g (f m) a -> f (g m) a
- type Gen = GenT Identity
- data GenT (m :: Type -> Type) a
- class (Monad m, Monad (GenBase m)) => MonadGen (m :: Type -> Type) where
- type family GenBase (m :: Type -> Type) :: Type -> Type
- class HTraversable (t :: (Type -> TYPE LiftedRep) -> TYPE LiftedRep) where
- htraverse :: Applicative f => (forall a. g a -> f (h a)) -> t g -> f (t h)
- newtype Opaque a = Opaque {
- unOpaque :: a
- data Confidence
- data DiscardLimit
- data Group = Group {
- groupName :: !GroupName
- groupProperties :: ![(PropertyName, Property)]
- data GroupName
- data LabelName
- class Monad m => MonadTest (m :: Type -> Type) where
- data Property
- data PropertyName
- data PropertyT (m :: Type -> Type) a
- data ShrinkLimit
- data ShrinkRetries
- type Test = TestT Identity
- data TestLimit
- data TestT (m :: Type -> Type) a
- data Range a
- newtype Size = Size {}
- data Seed = Seed {}
- data Action (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type)
- data Callback (input :: (Type -> Type) -> Type) output (state :: (Type -> Type) -> Type)
- data Command (gen :: Type -> Type) (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) = (TraversableB input, Show (input Symbolic), Show output, Typeable output) => Command {
- commandGen :: state Symbolic -> Maybe (gen (input Symbolic))
- commandExecute :: input Concrete -> m output
- commandCallbacks :: [Callback input output state]
- newtype Concrete a where
- data Parallel (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) = Parallel {
- parallelPrefix :: [Action m state]
- parallelBranch1 :: [Action m state]
- parallelBranch2 :: [Action m state]
- newtype Sequential (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) = Sequential {
- sequentialActions :: [Action m state]
- data Symbolic a
- newtype Var a (v :: Type -> Type) = Var (v a)
- alpha :: MonadGen m => m Char
- alphaNum :: MonadGen m => m Char
- ascii :: MonadGen m => m Char
- binit :: MonadGen m => m Char
- bool :: MonadGen m => m Bool
- bool_ :: MonadGen m => m Bool
- bytes :: MonadGen m => Range Int -> m ByteString
- choice :: MonadGen m => [m a] -> m a
- constant :: MonadGen m => a -> m a
- digit :: MonadGen m => m Char
- double :: MonadGen m => Range Double -> m Double
- either :: MonadGen m => m a -> m b -> m (Either a b)
- either_ :: MonadGen m => m a -> m b -> m (Either a b)
- element :: MonadGen m => [a] -> m a
- enum :: (MonadGen m, Enum a) => a -> a -> m a
- enumBounded :: (MonadGen m, Enum a, Bounded a) => m a
- filter :: (MonadGen m, GenBase m ~ Identity) => (a -> Bool) -> m a -> m a
- filterT :: MonadGen m => (a -> Bool) -> m a -> m a
- float :: MonadGen m => Range Float -> m Float
- freeze :: MonadGen m => m a -> m (a, m a)
- frequency :: MonadGen m => [(Int, m a)] -> m a
- hexit :: MonadGen m => m Char
- int :: MonadGen m => Range Int -> m Int
- int16 :: MonadGen m => Range Int16 -> m Int16
- int32 :: MonadGen m => Range Int32 -> m Int32
- int64 :: MonadGen m => Range Int64 -> m Int64
- int8 :: MonadGen m => Range Int8 -> m Int8
- integral :: (MonadGen m, Integral a) => Range a -> m a
- integral_ :: (MonadGen m, Integral a) => Range a -> m a
- just :: (MonadGen m, GenBase m ~ Identity) => m (Maybe a) -> m a
- justT :: MonadGen m => m (Maybe a) -> m a
- latin1 :: MonadGen m => m Char
- list :: MonadGen m => Range Int -> m a -> m [a]
- lower :: MonadGen m => m Char
- map :: (MonadGen m, Ord k) => Range Int -> m (k, v) -> m (Map k v)
- mapMaybe :: (MonadGen m, GenBase m ~ Identity) => (a -> Maybe b) -> m a -> m b
- mapMaybeT :: MonadGen m => (a -> Maybe b) -> m a -> m b
- maybe :: MonadGen m => m a -> m (Maybe a)
- nonEmpty :: MonadGen m => Range Int -> m a -> m (NonEmpty a)
- octit :: MonadGen m => m Char
- printTree :: (MonadIO m, Show a) => Gen a -> m ()
- printTreeWith :: (MonadIO m, Show a) => Size -> Seed -> Gen a -> m ()
- printWith :: (MonadIO m, Show a) => Size -> Seed -> Gen a -> m ()
- prune :: MonadGen m => m a -> m a
- realFloat :: (MonadGen m, RealFloat a) => Range a -> m a
- realFrac_ :: (MonadGen m, RealFrac a) => Range a -> m a
- recursive :: MonadGen m => ([m a] -> m a) -> [m a] -> [m a] -> m a
- resize :: MonadGen m => Size -> m a -> m a
- sample :: MonadIO m => Gen a -> m a
- scale :: MonadGen m => (Size -> Size) -> m a -> m a
- seq :: MonadGen m => Range Int -> m a -> m (Seq a)
- set :: (MonadGen m, Ord a) => Range Int -> m a -> m (Set a)
- shrink :: MonadGen m => (a -> [a]) -> m a -> m a
- shuffle :: MonadGen m => [a] -> m [a]
- sized :: MonadGen m => (Size -> m a) -> m a
- small :: MonadGen m => m a -> m a
- string :: MonadGen m => Range Int -> m Char -> m String
- subsequence :: MonadGen m => [a] -> m [a]
- subterm :: MonadGen m => m a -> (a -> a) -> m a
- subterm2 :: MonadGen m => m a -> m a -> (a -> a -> a) -> m a
- subterm3 :: MonadGen m => m a -> m a -> m a -> (a -> a -> a -> a) -> m a
- subtermM :: MonadGen m => m a -> (a -> m a) -> m a
- subtermM2 :: MonadGen m => m a -> m a -> (a -> a -> m a) -> m a
- subtermM3 :: MonadGen m => m a -> m a -> m a -> (a -> a -> a -> m a) -> m a
- text :: MonadGen m => Range Int -> m Char -> m Text
- unicode :: MonadGen m => m Char
- unicodeAll :: MonadGen m => m Char
- upper :: MonadGen m => m Char
- utf8 :: MonadGen m => Range Int -> m Char -> m ByteString
- word :: MonadGen m => Range Word -> m Word
- word16 :: MonadGen m => Range Word16 -> m Word16
- word32 :: MonadGen m => Range Word32 -> m Word32
- word64 :: MonadGen m => Range Word64 -> m Word64
- word8 :: MonadGen m => Range Word8 -> m Word8
- parallel :: forall gen (m :: Type -> Type) state. (MonadGen gen, MonadTest m) => Range Int -> Range Int -> (forall (v :: Type -> Type). state v) -> [Command gen m state] -> gen (Parallel m state)
- sequential :: forall gen (m :: Type -> Type) state. (MonadGen gen, MonadTest m) => Range Int -> (forall (v :: Type -> Type). state v) -> [Command gen m state] -> gen (Sequential m state)
- adjustOption :: IsOption v => (v -> v) -> TestTree -> TestTree
- askOption :: IsOption v => (v -> TestTree) -> TestTree
- defaultIngredients :: [Ingredient]
- defaultMain :: TestTree -> IO ()
- localOption :: IsOption v => v -> TestTree -> TestTree
- withResource :: IO a -> (a -> IO ()) -> (IO a -> TestTree) -> TestTree
- defaultMainWithIngredients :: [Ingredient] -> TestTree -> IO ()
- after :: DependencyType -> String -> TestTree -> TestTree
- after_ :: DependencyType -> Expr -> TestTree -> TestTree
- testGroup :: TestName -> [TestTree] -> TestTree
- includingOptions :: [OptionDescription] -> Ingredient
- mkTimeout :: Integer -> Timeout
- data DependencyType
- type TestName = String
- data TestTree
- = IsTest t => SingleTest TestName t
- | TestGroup TestName [TestTree]
- | PlusTestOptions (OptionSet -> OptionSet) TestTree
- | WithResource (ResourceSpec a) (IO a -> TestTree)
- | AskOptions (OptionSet -> TestTree)
- | After DependencyType Expr TestTree
- data Timeout
- class Typeable v => IsOption v where
- defaultValue :: v
- parseValue :: String -> Maybe v
- optionName :: Tagged v String
- optionHelp :: Tagged v String
- showDefaultValue :: v -> Maybe String
- optionCLParser :: Parser v
- data OptionSet
- lookupOption :: IsOption v => OptionSet -> v
- changeOption :: IsOption v => (v -> v) -> OptionSet -> OptionSet
- flagCLParser :: IsOption v => Maybe Char -> v -> Parser v
- mkFlagCLParser :: IsOption v => Mod FlagFields v -> v -> Parser v
- mkOptionCLParser :: IsOption v => Mod OptionFields v -> Parser v
- safeRead :: Read a => String -> Maybe a
- safeReadBool :: String -> Maybe Bool
- setOption :: IsOption v => v -> OptionSet -> OptionSet
- singleOption :: IsOption v => v -> OptionSet
- uniqueOptionDescriptions :: [OptionDescription] -> [OptionDescription]
- data OptionDescription where
- Option :: forall v. IsOption v => Proxy v -> OptionDescription
- singleTest :: IsTest t => TestName -> t -> TestTree
- foldTestTree :: Monoid b => TreeFold b -> OptionSet -> TestTree -> b
- trivialFold :: Monoid b => TreeFold b
- foldSingle :: TreeFold b -> forall t. IsTest t => OptionSet -> TestName -> t -> b
- module Test.Tasty.HedgehogTest
- prop :: HasCallStack => TestName -> PropertyT IO () -> TestTree
- test :: HasCallStack => TestName -> PropertyT IO () -> TestTree
- minTestsOk :: Int -> TestTree -> TestTree
- noShrink :: TestTree -> TestTree
- withSeed :: String -> TestTree -> TestTree
- run :: Runnable t => t -> IO ()
- runOnly :: Runnable t => Text -> t -> IO ()
- gotException :: forall a. (HasCallStack, Show a) => a -> PropertyT IO ()
- printDifference :: (MonadIO m, Show a, Show b, HasCallStack) => a -> b -> m ()
- display :: (Show a, Monad m, HasCallStack) => a -> PropertyT m a
Documentation
class Show1 (f :: TYPE LiftedRep -> TYPE LiftedRep) #
Lifting of the Show
class to unary type constructors.
Since: base-4.9.0.0
Instances
Show1 Complex |
Since: base-4.16.0.0 |
Show1 Identity | Since: base-4.9.0.0 |
Show1 Down | Since: base-4.12.0.0 |
Show1 SCC | Since: containers-0.5.9 |
Show1 IntMap | Since: containers-0.5.9 |
Show1 Seq | Since: containers-0.5.9 |
Show1 Set | Since: containers-0.5.9 |
Show1 Concrete | |
Show1 Symbolic | |
Show1 Hashed | |
Defined in Data.Hashable.Class | |
Show1 HashSet | |
Defined in Data.HashSet.Internal | |
Show1 NonEmpty | Since: base-4.10.0.0 |
Show1 Maybe | Since: base-4.9.0.0 |
Show1 Solo | Since: base-4.15 |
Show1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Show a => Show1 (Either a) | Since: base-4.9.0.0 |
Show1 (Proxy :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0 |
Show k => Show1 (Map k) | Since: containers-0.5.9 |
Show1 m => Show1 (NodeT m) | |
Defined in Hedgehog.Internal.Tree | |
Show1 m => Show1 (TreeT m) | |
Defined in Hedgehog.Internal.Tree | |
Show k => Show1 (HashMap k) | |
Defined in Data.HashMap.Internal | |
Show1 m => Show1 (MaybeT m) | |
Show a => Show1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Show a => Show1 (Const a :: TYPE LiftedRep -> Type) | Since: base-4.9.0.0 |
Show1 (Tagged s) | |
Defined in Data.Tagged | |
(Show e, Show1 m) => Show1 (ErrorT e m) | |
(Show e, Show1 m) => Show1 (ExceptT e m) | |
Show1 f => Show1 (IdentityT f) | |
(Show w, Show1 m) => Show1 (WriterT w m) | |
(Show w, Show1 m) => Show1 (WriterT w m) | |
(Show a, Show b) => Show1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
(Show a, Show b, Show c) => Show1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes |
class Eq1 f => Ord1 (f :: Type -> Type) #
Lifting of the Ord
class to unary type constructors.
Since: base-4.9.0.0
Instances
Ord1 Identity | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Ord1 Down | Since: base-4.12.0.0 |
Defined in Data.Functor.Classes | |
Ord1 IntMap | Since: containers-0.5.9 |
Defined in Data.IntMap.Internal | |
Ord1 Seq | Since: containers-0.5.9 |
Defined in Data.Sequence.Internal | |
Ord1 Set | Since: containers-0.5.9 |
Defined in Data.Set.Internal | |
Ord1 Concrete | |
Defined in Hedgehog.Internal.State | |
Ord1 Symbolic | |
Defined in Hedgehog.Internal.State | |
Ord1 Hashed | |
Defined in Data.Hashable.Class liftCompare :: (a -> b -> Ordering) -> Hashed a -> Hashed b -> Ordering # | |
Ord1 HashSet | |
Defined in Data.HashSet.Internal liftCompare :: (a -> b -> Ordering) -> HashSet a -> HashSet b -> Ordering # | |
Ord1 NonEmpty | Since: base-4.10.0.0 |
Defined in Data.Functor.Classes | |
Ord1 Maybe | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Ord1 Solo | Since: base-4.15 |
Defined in Data.Functor.Classes | |
Ord1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes liftCompare :: (a -> b -> Ordering) -> [a] -> [b] -> Ordering # | |
Ord a => Ord1 (Either a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Ord1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Ord k => Ord1 (Map k) | Since: containers-0.5.9 |
Defined in Data.Map.Internal | |
Ord k => Ord1 (HashMap k) | |
Defined in Data.HashMap.Internal liftCompare :: (a -> b -> Ordering) -> HashMap k a -> HashMap k b -> Ordering # | |
Ord1 m => Ord1 (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
Ord a => Ord1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes liftCompare :: (a0 -> b -> Ordering) -> (a, a0) -> (a, b) -> Ordering # | |
Ord a => Ord1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Ord1 (Tagged s) | |
Defined in Data.Tagged liftCompare :: (a -> b -> Ordering) -> Tagged s a -> Tagged s b -> Ordering # | |
(Ord e, Ord1 m) => Ord1 (ErrorT e m) | |
Defined in Control.Monad.Trans.Error | |
(Ord e, Ord1 m) => Ord1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Ord1 f => Ord1 (IdentityT f) | |
Defined in Control.Monad.Trans.Identity | |
(Ord w, Ord1 m) => Ord1 (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
(Ord w, Ord1 m) => Ord1 (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
(Ord a, Ord b) => Ord1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, a0) -> (a, b, b0) -> Ordering # | |
(Ord a, Ord b, Ord c) => Ord1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes liftCompare :: (a0 -> b0 -> Ordering) -> (a, b, c, a0) -> (a, b, c, b0) -> Ordering # |
class Eq1 (f :: Type -> Type) #
Lifting of the Eq
class to unary type constructors.
Since: base-4.9.0.0
Instances
Eq1 Complex |
Since: base-4.16.0.0 |
Eq1 Identity | Since: base-4.9.0.0 |
Eq1 Down | Since: base-4.12.0.0 |
Eq1 SCC | Since: containers-0.5.9 |
Eq1 IntMap | Since: containers-0.5.9 |
Eq1 Seq | Since: containers-0.5.9 |
Eq1 Set | Since: containers-0.5.9 |
Eq1 Concrete | |
Eq1 Symbolic | |
Eq1 Hashed | |
Defined in Data.Hashable.Class | |
Eq1 HashSet | |
Defined in Data.HashSet.Internal | |
Eq1 NonEmpty | Since: base-4.10.0.0 |
Eq1 Maybe | Since: base-4.9.0.0 |
Eq1 Solo | Since: base-4.15 |
Eq1 [] | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Eq a => Eq1 (Either a) | Since: base-4.9.0.0 |
Eq1 (Proxy :: Type -> Type) | Since: base-4.9.0.0 |
Eq k => Eq1 (Map k) | Since: containers-0.5.9 |
Eq k => Eq1 (HashMap k) | |
Defined in Data.HashMap.Internal | |
Eq1 m => Eq1 (MaybeT m) | |
Eq a => Eq1 ((,) a) | Since: base-4.9.0.0 |
Defined in Data.Functor.Classes | |
Eq a => Eq1 (Const a :: Type -> Type) | Since: base-4.9.0.0 |
Eq1 (Tagged s) | |
Defined in Data.Tagged | |
(Eq e, Eq1 m) => Eq1 (ErrorT e m) | |
(Eq e, Eq1 m) => Eq1 (ExceptT e m) | |
Eq1 f => Eq1 (IdentityT f) | |
(Eq w, Eq1 m) => Eq1 (WriterT w m) | |
(Eq w, Eq1 m) => Eq1 (WriterT w m) | |
(Eq a, Eq b) => Eq1 ((,,) a b) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes | |
(Eq a, Eq b, Eq c) => Eq1 ((,,,) a b c) | Since: base-4.16.0.0 |
Defined in Data.Functor.Classes |
eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool #
Lift the standard (
function through the type constructor.==
)
Since: base-4.9.0.0
compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering #
Lift the standard compare
function through the type constructor.
Since: base-4.9.0.0
annotate :: (MonadTest m, HasCallStack) => String -> m () #
annotateShow :: (MonadTest m, Show a, HasCallStack) => a -> m () #
assert :: (MonadTest m, HasCallStack) => Bool -> m () #
collect :: (MonadTest m, Show a, HasCallStack) => a -> m () #
eval :: (MonadTest m, HasCallStack) => a -> m a #
evalEither :: (MonadTest m, Show x, HasCallStack) => Either x a -> m a #
evalEitherM :: (MonadTest m, Show x, MonadCatch m, HasCallStack) => m (Either x a) -> m a #
evalExceptT :: (MonadTest m, Show x, HasCallStack) => ExceptT x m a -> m a #
evalM :: (MonadTest m, MonadCatch m, HasCallStack) => m a -> m a #
evalMaybeM :: (MonadTest m, Show a, MonadCatch m, HasCallStack) => m (Maybe a) -> m a #
evalNF :: (MonadTest m, NFData a, HasCallStack) => a -> m a #
failure :: (MonadTest m, HasCallStack) => m a #
footnoteShow :: (MonadTest m, Show a) => a -> m () #
forAllWith :: forall (m :: Type -> Type) a. (Monad m, HasCallStack) => (a -> String) -> Gen a -> PropertyT m a #
label :: (MonadTest m, HasCallStack) => LabelName -> m () #
verifiedTermination :: Property -> Property #
withConfidence :: Confidence -> Property -> Property #
withDiscards :: DiscardLimit -> Property -> Property #
withRetries :: ShrinkRetries -> Property -> Property #
withShrinks :: ShrinkLimit -> Property -> Property #
checkParallel :: MonadIO m => Group -> m Bool #
checkSequential :: MonadIO m => Group -> m Bool #
executeParallel :: (MonadTest m, MonadCatch m, MonadBaseControl IO m, HasCallStack) => (forall (v :: Type -> Type). state v) -> Parallel m state -> m () #
executeSequential :: (MonadTest m, MonadCatch m, HasCallStack) => (forall (v :: Type -> Type). state v) -> Sequential m state -> m () #
discoverPrefix :: String -> TExpQ Group #
tripping :: (MonadTest m, Applicative f, Show b, Show (f a), Eq (f a), HasCallStack) => a -> (a -> b) -> (b -> f a) -> m () #
class FunctorB (b :: (k -> Type) -> Type) where #
Nothing
Instances
FunctorB (Var a :: (Type -> Type) -> Type) | |
Defined in Hedgehog.Internal.State | |
FunctorB (Proxy :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB | |
FunctorB (Const x :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB | |
FunctorB (Constant x :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB | |
(FunctorB a, FunctorB b) => FunctorB (Product a b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB | |
(FunctorB a, FunctorB b) => FunctorB (Sum a b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB | |
(Functor f, FunctorB b) => FunctorB (Compose f b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.FunctorB |
class FunctorB b => TraversableB (b :: (k -> Type) -> Type) where #
Nothing
btraverse :: Applicative e => (forall (a :: k). f a -> e (g a)) -> b f -> e (b g) #
Instances
TraversableB (Var a :: (Type -> Type) -> Type) | |
Defined in Hedgehog.Internal.State btraverse :: Applicative e => (forall (a0 :: k). f a0 -> e (g a0)) -> Var a f -> e (Var a g) # | |
TraversableB (Proxy :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a :: k0). f a -> e (g a)) -> Proxy f -> e (Proxy g) # | |
TraversableB (Const a :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a0 :: k0). f a0 -> e (g a0)) -> Const a f -> e (Const a g) # | |
TraversableB (Constant a :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a0 :: k0). f a0 -> e (g a0)) -> Constant a f -> e (Constant a g) # | |
(TraversableB a, TraversableB b) => TraversableB (Product a b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a0 :: k0). f a0 -> e (g a0)) -> Product a b f -> e (Product a b g) # | |
(TraversableB a, TraversableB b) => TraversableB (Sum a b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a0 :: k0). f a0 -> e (g a0)) -> Sum a b f -> e (Sum a b g) # | |
(Traversable f, TraversableB b) => TraversableB (Compose f b :: (k -> Type) -> Type) | |
Defined in Barbies.Internal.TraversableB btraverse :: Applicative e => (forall (a :: k0). f0 a -> e (g a)) -> Compose f b f0 -> e (Compose f b g) # |
Instances
GConstraints n (c :: k1 -> Constraint) (f :: k2) (Rec a' a :: Type -> TYPE LiftedRep) (Rec b' b :: k3 -> TYPE LiftedRep) (Rec b' b :: k3 -> TYPE LiftedRep) | |
Defined in Barbies.Generics.Constraints | |
GConstraints n (c :: k1 -> Constraint) (f :: k1 -> Type) (Rec (P n (X :: k1 -> Type) a') (X a) :: Type -> TYPE LiftedRep) (Rec (P n f a') (f a) :: k2 -> TYPE LiftedRep) (Rec (P n (Product (Dict c) f) a') (Product (Dict c) f a) :: k2 -> TYPE LiftedRep) | |
type GAll n (c :: k -> Constraint) (Rec l r :: Type -> TYPE LiftedRep) | |
Defined in Barbies.Generics.Constraints |
distributeT :: forall f (m :: Type -> Type) a. (MonadTransDistributive g, Transformer f g m) => g (f m) a -> f (g m) a #
data GenT (m :: Type -> Type) a #
Instances
MonadTransDistributive GenT | |
Defined in Hedgehog.Internal.Gen type Transformer f GenT m | |
MMonad GenT | |
MonadTrans GenT | |
Defined in Hedgehog.Internal.Gen | |
MFunctor GenT | |
Defined in Hedgehog.Internal.Gen | |
MonadBaseControl b m => MonadBaseControl b (GenT m) | |
Defined in Hedgehog.Internal.Gen type StM (GenT m) a | |
MonadError e m => MonadError e (GenT m) | |
Defined in Hedgehog.Internal.Gen throwError :: e -> GenT m a # catchError :: GenT m a -> (e -> GenT m a) -> GenT m a # | |
MonadReader r m => MonadReader r (GenT m) | |
MonadState s m => MonadState s (GenT m) | |
MonadWriter w m => MonadWriter w (GenT m) | |
MonadBase b m => MonadBase b (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
Monad m => MonadFail (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
MonadIO m => MonadIO (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
Monad m => Alternative (GenT m) | |
Monad m => Applicative (GenT m) | |
Functor m => Functor (GenT m) | |
Monad m => Monad (GenT m) | |
Monad m => MonadPlus (GenT m) | |
MonadCatch m => MonadCatch (GenT m) | |
MonadThrow m => MonadThrow (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
Monad m => MonadGen (GenT m) | |
PrimMonad m => PrimMonad (GenT m) | |
MonadResource m => MonadResource (GenT m) | |
Defined in Hedgehog.Internal.Gen liftResourceT :: ResourceT IO a -> GenT m a | |
(Monad m, Monoid a) => Monoid (GenT m a) | |
(Monad m, Semigroup a) => Semigroup (GenT m a) | |
type Transformer t GenT m | |
type GenBase (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
type PrimState (GenT m) | |
Defined in Hedgehog.Internal.Gen type PrimState (GenT m) = PrimState m | |
type StM (GenT m) a | |
class (Monad m, Monad (GenBase m)) => MonadGen (m :: Type -> Type) where #
Instances
Monad m => MonadGen (GenT m) | |
MonadGen m => MonadGen (MaybeT m) | |
MonadGen m => MonadGen (ExceptT x m) | |
MonadGen m => MonadGen (IdentityT m) | |
MonadGen m => MonadGen (ReaderT r m) | |
MonadGen m => MonadGen (StateT r m) | |
MonadGen m => MonadGen (StateT r m) | |
(MonadGen m, Monoid w) => MonadGen (WriterT w m) | |
(MonadGen m, Monoid w) => MonadGen (WriterT w m) | |
type family GenBase (m :: Type -> Type) :: Type -> Type #
Instances
type GenBase (GenT m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (MaybeT m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (ExceptT x m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (IdentityT m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (ReaderT r m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (StateT r m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (StateT r m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (WriterT w m) | |
Defined in Hedgehog.Internal.Gen | |
type GenBase (WriterT w m) | |
Defined in Hedgehog.Internal.Gen |
class HTraversable (t :: (Type -> TYPE LiftedRep) -> TYPE LiftedRep) where #
htraverse :: Applicative f => (forall a. g a -> f (h a)) -> t g -> f (t h) #
data Confidence #
Instances
data DiscardLimit #
Instances
Group | |
|
class Monad m => MonadTest (m :: Type -> Type) where #
Instances
data PropertyName #
Instances
data PropertyT (m :: Type -> Type) a #
Instances
data ShrinkLimit #
Instances
data ShrinkRetries #
Instances
Instances
Enum TestLimit | |
Defined in Hedgehog.Internal.Property succ :: TestLimit -> TestLimit # pred :: TestLimit -> TestLimit # fromEnum :: TestLimit -> Int # enumFrom :: TestLimit -> [TestLimit] # enumFromThen :: TestLimit -> TestLimit -> [TestLimit] # enumFromTo :: TestLimit -> TestLimit -> [TestLimit] # enumFromThenTo :: TestLimit -> TestLimit -> TestLimit -> [TestLimit] # | |
Num TestLimit | |
Defined in Hedgehog.Internal.Property | |
Integral TestLimit | |
Defined in Hedgehog.Internal.Property | |
Real TestLimit | |
Defined in Hedgehog.Internal.Property toRational :: TestLimit -> Rational # | |
Show TestLimit | |
Eq TestLimit | |
Ord TestLimit | |
Defined in Hedgehog.Internal.Property | |
Lift TestLimit | |
data TestT (m :: Type -> Type) a #
Instances
Instances
Read Seed | |
Show Seed | |
Eq Seed | |
Ord Seed | |
RandomGen Seed | |
Defined in Hedgehog.Internal.Seed genWord8 :: Seed -> (Word8, Seed) genWord16 :: Seed -> (Word16, Seed) genWord32 :: Seed -> (Word32, Seed) genWord64 :: Seed -> (Word64, Seed) genWord32R :: Word32 -> Seed -> (Word32, Seed) genWord64R :: Word64 -> Seed -> (Word64, Seed) genShortByteString :: Int -> Seed -> (ShortByteString, Seed) | |
Lift Seed | |
data Command (gen :: Type -> Type) (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) #
(TraversableB input, Show (input Symbolic), Show output, Typeable output) => Command | |
|
Instances
Foldable Concrete | |
Defined in Hedgehog.Internal.State fold :: Monoid m => Concrete m -> m # foldMap :: Monoid m => (a -> m) -> Concrete a -> m # foldMap' :: Monoid m => (a -> m) -> Concrete a -> m # foldr :: (a -> b -> b) -> b -> Concrete a -> b # foldr' :: (a -> b -> b) -> b -> Concrete a -> b # foldl :: (b -> a -> b) -> b -> Concrete a -> b # foldl' :: (b -> a -> b) -> b -> Concrete a -> b # foldr1 :: (a -> a -> a) -> Concrete a -> a # foldl1 :: (a -> a -> a) -> Concrete a -> a # elem :: Eq a => a -> Concrete a -> Bool # maximum :: Ord a => Concrete a -> a # minimum :: Ord a => Concrete a -> a # | |
Eq1 Concrete | |
Ord1 Concrete | |
Defined in Hedgehog.Internal.State | |
Show1 Concrete | |
Traversable Concrete | |
Functor Concrete | |
Show a => Show (Concrete a) | |
Eq a => Eq (Concrete a) | |
Ord a => Ord (Concrete a) | |
data Parallel (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) #
Parallel | |
|
newtype Sequential (m :: TYPE LiftedRep -> Type) (state :: (Type -> Type) -> Type) #
Sequential | |
|
Instances
Show (Sequential m state) | |
Defined in Hedgehog.Internal.State showsPrec :: Int -> Sequential m state -> ShowS # show :: Sequential m state -> String # showList :: [Sequential m state] -> ShowS # |
Instances
Eq1 Symbolic | |
Ord1 Symbolic | |
Defined in Hedgehog.Internal.State | |
Show1 Symbolic | |
Show (Symbolic a) | |
Eq (Symbolic a) | |
Ord (Symbolic a) | |
newtype Var a (v :: Type -> Type) #
Var (v a) |
Instances
FunctorB (Var a :: (Type -> Type) -> Type) | |
Defined in Hedgehog.Internal.State | |
TraversableB (Var a :: (Type -> Type) -> Type) | |
Defined in Hedgehog.Internal.State btraverse :: Applicative e => (forall (a0 :: k). f a0 -> e (g a0)) -> Var a f -> e (Var a g) # | |
(Show a, Show1 v) => Show (Var a v) | |
(Eq a, Eq1 v) => Eq (Var a v) | |
(Ord a, Ord1 v) => Ord (Var a v) | |
enumBounded :: (MonadGen m, Enum a, Bounded a) => m a #
subsequence :: MonadGen m => [a] -> m [a] #
unicodeAll :: MonadGen m => m Char #
parallel :: forall gen (m :: Type -> Type) state. (MonadGen gen, MonadTest m) => Range Int -> Range Int -> (forall (v :: Type -> Type). state v) -> [Command gen m state] -> gen (Parallel m state) #
sequential :: forall gen (m :: Type -> Type) state. (MonadGen gen, MonadTest m) => Range Int -> (forall (v :: Type -> Type). state v) -> [Command gen m state] -> gen (Sequential m state) #
adjustOption :: IsOption v => (v -> v) -> TestTree -> TestTree #
defaultIngredients :: [Ingredient] #
defaultMain :: TestTree -> IO () #
localOption :: IsOption v => v -> TestTree -> TestTree #
defaultMainWithIngredients :: [Ingredient] -> TestTree -> IO () #
after_ :: DependencyType -> Expr -> TestTree -> TestTree #
includingOptions :: [OptionDescription] -> Ingredient #
data DependencyType #
Instances
Show DependencyType | |
Defined in Test.Tasty.Core showsPrec :: Int -> DependencyType -> ShowS # show :: DependencyType -> String # showList :: [DependencyType] -> ShowS # | |
Eq DependencyType | |
Defined in Test.Tasty.Core (==) :: DependencyType -> DependencyType -> Bool # (/=) :: DependencyType -> DependencyType -> Bool # |
IsTest t => SingleTest TestName t | |
TestGroup TestName [TestTree] | |
PlusTestOptions (OptionSet -> OptionSet) TestTree | |
WithResource (ResourceSpec a) (IO a -> TestTree) | |
AskOptions (OptionSet -> TestTree) | |
After DependencyType Expr TestTree |
Instances
Show Timeout | |
IsOption Timeout | |
Defined in Test.Tasty.Options.Core defaultValue :: Timeout # parseValue :: String -> Maybe Timeout # optionName :: Tagged Timeout String # optionHelp :: Tagged Timeout String # showDefaultValue :: Timeout -> Maybe String # optionCLParser :: Parser Timeout # |
class Typeable v => IsOption v where #
defaultValue :: v #
parseValue :: String -> Maybe v #
optionName :: Tagged v String #
optionHelp :: Tagged v String #
showDefaultValue :: v -> Maybe String #
optionCLParser :: Parser v #
Instances
lookupOption :: IsOption v => OptionSet -> v #
changeOption :: IsOption v => (v -> v) -> OptionSet -> OptionSet #
flagCLParser :: IsOption v => Maybe Char -> v -> Parser v #
mkFlagCLParser :: IsOption v => Mod FlagFields v -> v -> Parser v #
mkOptionCLParser :: IsOption v => Mod OptionFields v -> Parser v #
safeReadBool :: String -> Maybe Bool #
singleOption :: IsOption v => v -> OptionSet #
data OptionDescription where #
Option :: forall v. IsOption v => Proxy v -> OptionDescription |
singleTest :: IsTest t => TestName -> t -> TestTree #
foldTestTree :: Monoid b => TreeFold b -> OptionSet -> TestTree -> b #
trivialFold :: Monoid b => TreeFold b #
foldSingle :: TreeFold b -> forall t. IsTest t => OptionSet -> TestName -> t -> b #
module Test.Tasty.HedgehogTest
Tests definition
prop :: HasCallStack => TestName -> PropertyT IO () -> TestTree Source #
Create a Tasty test from a Hedgehog property
test :: HasCallStack => TestName -> PropertyT IO () -> TestTree Source #
Create a Tasty test from a Hedgehog property called only once
Tests settings
minTestsOk :: Int -> TestTree -> TestTree Source #
Set the minimum number of tests which must be successful for a property to pass
Running tests
run :: Runnable t => t -> IO () Source #
Run either a test tree (a test or a property) whether it is in IO or not
Assertions
gotException :: forall a. (HasCallStack, Show a) => a -> PropertyT IO () Source #
Assert that an exception is thrown
Display
printDifference :: (MonadIO m, Show a, Show b, HasCallStack) => a -> b -> m () Source #