packages feed

registry-hedgehog 0.8.2.1 → 0.8.2.2

raw patch · 1 files changed

+1/−1 lines, 1 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Test.Tasty.Hedgehogx: After :: DependencyType -> Expr -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: AllFinish :: DependencyType
- Test.Tasty.Hedgehogx: AllSucceed :: DependencyType
- Test.Tasty.Hedgehogx: AskOptions :: (OptionSet -> TestTree) -> TestTree
- Test.Tasty.Hedgehogx: NoTimeout :: Timeout
- Test.Tasty.Hedgehogx: PlusTestOptions :: (OptionSet -> OptionSet) -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: SingleTest :: TestName -> t -> TestTree
- Test.Tasty.Hedgehogx: TestGroup :: TestName -> [TestTree] -> TestTree
- Test.Tasty.Hedgehogx: Timeout :: Integer -> String -> Timeout
- Test.Tasty.Hedgehogx: WithResource :: ResourceSpec a -> (IO a -> TestTree) -> TestTree
- Test.Tasty.Hedgehogx: [Option] :: forall v. IsOption v => Proxy v -> OptionDescription
- Test.Tasty.Hedgehogx: adjustOption :: IsOption v => (v -> v) -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: after :: DependencyType -> String -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: after_ :: DependencyType -> Expr -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: askOption :: IsOption v => (v -> TestTree) -> TestTree
- Test.Tasty.Hedgehogx: changeOption :: IsOption v => (v -> v) -> OptionSet -> OptionSet
- Test.Tasty.Hedgehogx: class Typeable v => IsOption v
- Test.Tasty.Hedgehogx: data () => DependencyType
- Test.Tasty.Hedgehogx: data () => OptionDescription
- Test.Tasty.Hedgehogx: data () => OptionSet
- Test.Tasty.Hedgehogx: data () => TestTree
- Test.Tasty.Hedgehogx: data () => Timeout
- Test.Tasty.Hedgehogx: defaultIngredients :: [Ingredient]
- Test.Tasty.Hedgehogx: defaultMain :: TestTree -> IO ()
- Test.Tasty.Hedgehogx: defaultMainWithIngredients :: [Ingredient] -> TestTree -> IO ()
- Test.Tasty.Hedgehogx: defaultValue :: IsOption v => v
- Test.Tasty.Hedgehogx: flagCLParser :: IsOption v => Maybe Char -> v -> Parser v
- Test.Tasty.Hedgehogx: includingOptions :: [OptionDescription] -> Ingredient
- Test.Tasty.Hedgehogx: localOption :: IsOption v => v -> TestTree -> TestTree
- Test.Tasty.Hedgehogx: lookupOption :: IsOption v => OptionSet -> v
- Test.Tasty.Hedgehogx: mkFlagCLParser :: IsOption v => Mod FlagFields v -> v -> Parser v
- Test.Tasty.Hedgehogx: mkOptionCLParser :: IsOption v => Mod OptionFields v -> Parser v
- Test.Tasty.Hedgehogx: mkTimeout :: Integer -> Timeout
- Test.Tasty.Hedgehogx: optionCLParser :: IsOption v => Parser v
- Test.Tasty.Hedgehogx: optionHelp :: IsOption v => Tagged v String
- Test.Tasty.Hedgehogx: optionName :: IsOption v => Tagged v String
- Test.Tasty.Hedgehogx: parseValue :: IsOption v => String -> Maybe v
- Test.Tasty.Hedgehogx: safeRead :: Read a => String -> Maybe a
- Test.Tasty.Hedgehogx: safeReadBool :: String -> Maybe Bool
- Test.Tasty.Hedgehogx: sequentialTestGroup :: TestName -> DependencyType -> [TestTree] -> TestTree
- Test.Tasty.Hedgehogx: setOption :: IsOption v => v -> OptionSet -> OptionSet
- Test.Tasty.Hedgehogx: showDefaultValue :: IsOption v => v -> Maybe String
- Test.Tasty.Hedgehogx: singleOption :: IsOption v => v -> OptionSet
- Test.Tasty.Hedgehogx: testGroup :: TestName -> [TestTree] -> TestTree
- Test.Tasty.Hedgehogx: type TestName = String
- Test.Tasty.Hedgehogx: uniqueOptionDescriptions :: [OptionDescription] -> [OptionDescription]
- Test.Tasty.Hedgehogx: withResource :: IO a -> (a -> IO ()) -> (IO a -> TestTree) -> TestTree
+ Test.Tasty.Hedgehogx: ($dmbmap) :: forall f g. (FunctorB b, CanDeriveFunctorB b f g) => (forall (a :: k). () => f a -> g a) -> b f -> b g
+ Test.Tasty.Hedgehogx: ($dmbtraverse) :: forall e f g. (TraversableB b, Applicative e, CanDeriveTraversableB b f g) => (forall (a :: k). () => f a -> e (g a)) -> b f -> e (b g)
+ Test.Tasty.Hedgehogx: pattern AskOptions :: () => (OptionSet -> TestTree) -> TestTree
+ Test.Tasty.Hedgehogx: pattern After :: () => DependencyType -> Expr -> TestTree -> TestTree
+ Test.Tasty.Hedgehogx: pattern WithResource :: () => ResourceSpec a -> (IO a -> TestTree) -> TestTree
+ Test.Tasty.Hedgehogx: pattern TestGroup :: () => TestName -> [TestTree] -> TestTree
+ Test.Tasty.Hedgehogx: type GenBase (m :: Type -> Type) :: Type -> Type;
- Data.Registry.Hedgehog: Chooser :: Text -> (forall a. [Gen a] -> Gen a) -> Chooser
+ Data.Registry.Hedgehog: Chooser :: Text -> (forall a. () => [Gen a] -> Gen a) -> Chooser
- Data.Registry.Hedgehog: [pickOne] :: Chooser -> forall a. [Gen a] -> Gen a
+ Data.Registry.Hedgehog: [pickOne] :: Chooser -> forall a. () => [Gen a] -> Gen a
- Data.Registry.Hedgehog: distinctPairOf :: forall a. Eq a => Gen a -> Gen (a, a)
+ Data.Registry.Hedgehog: distinctPairOf :: Eq a => Gen a -> Gen (a, a)
- Data.Registry.Hedgehog: distinctTripleOf :: forall a. Eq a => Gen a -> Gen (a, a, a)
+ Data.Registry.Hedgehog: distinctTripleOf :: Eq a => Gen a -> Gen (a, a, a)
- Data.Registry.Hedgehog: eitherOf :: forall a b. Gen a -> Gen b -> Gen (Either a b)
+ Data.Registry.Hedgehog: eitherOf :: Gen a -> Gen b -> Gen (Either a b)
- Data.Registry.Hedgehog: genFun :: forall a b. (ApplyVariadic Gen a b, Typeable a, Typeable b) => a -> Typed b
+ Data.Registry.Hedgehog: genFun :: (ApplyVariadic Gen a b, Typeable a, Typeable b) => a -> Typed b
- Data.Registry.Hedgehog: genHashMapOf :: forall k v. (Ord k, Hashable k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (HashMap k v))
+ Data.Registry.Hedgehog: genHashMapOf :: (Ord k, Hashable k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (HashMap k v))
- Data.Registry.Hedgehog: genListOf :: forall a. Typeable a => Typed (Gen a -> Gen [a])
+ Data.Registry.Hedgehog: genListOf :: Typeable a => Typed (Gen a -> Gen [a])
- Data.Registry.Hedgehog: genListOfMinMax :: forall a. Typeable a => Int -> Int -> Typed (Gen a -> Gen [a])
+ Data.Registry.Hedgehog: genListOfMinMax :: Typeable a => Int -> Int -> Typed (Gen a -> Gen [a])
- Data.Registry.Hedgehog: genMapOf :: forall k v. (Ord k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (Map k v))
+ Data.Registry.Hedgehog: genMapOf :: (Ord k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (Map k v))
- Data.Registry.Hedgehog: genMaybeOf :: forall a. Typeable a => Typed (Gen a -> Gen (Maybe a))
+ Data.Registry.Hedgehog: genMaybeOf :: Typeable a => Typed (Gen a -> Gen (Maybe a))
- Data.Registry.Hedgehog: genNonEmptyMapOf :: forall k v. (Ord k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (Map k v))
+ Data.Registry.Hedgehog: genNonEmptyMapOf :: (Ord k, Typeable k, Typeable v) => Typed (Gen k -> Gen v -> Gen (Map k v))
- Data.Registry.Hedgehog: genNonEmptyOf :: forall a. Typeable a => Typed (Gen a -> Gen (NonEmpty a))
+ Data.Registry.Hedgehog: genNonEmptyOf :: Typeable a => Typed (Gen a -> Gen (NonEmpty a))
- Data.Registry.Hedgehog: genNonEmptyOfMinMax :: forall a. Typeable a => Int -> Int -> Typed (Gen a -> Gen (NonEmpty a))
+ Data.Registry.Hedgehog: genNonEmptyOfMinMax :: Typeable a => Int -> Int -> Typed (Gen a -> Gen (NonEmpty a))
- Data.Registry.Hedgehog: genPairOf :: forall a b. (Typeable a, Typeable b) => Typed (Gen a -> Gen b -> Gen (a, b))
+ Data.Registry.Hedgehog: genPairOf :: (Typeable a, Typeable b) => Typed (Gen a -> Gen b -> Gen (a, b))
- Data.Registry.Hedgehog: genTripleOf :: forall a b c. (Typeable a, Typeable b, Typeable c) => Typed (Gen a -> Gen b -> Gen c -> Gen (a, b, c))
+ Data.Registry.Hedgehog: genTripleOf :: (Typeable a, Typeable b, Typeable c) => Typed (Gen a -> Gen b -> Gen c -> Gen (a, b, c))
- Data.Registry.Hedgehog: genTuple4Of :: forall a b c d. (Typeable a, Typeable b, Typeable c, Typeable d) => Typed (Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d))
+ Data.Registry.Hedgehog: genTuple4Of :: (Typeable a, Typeable b, Typeable c, Typeable d) => Typed (Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d))
- Data.Registry.Hedgehog: genVal :: forall a. Typeable a => Gen a -> Typed (Gen a)
+ Data.Registry.Hedgehog: genVal :: Typeable a => Gen a -> Typed (Gen a)
- Data.Registry.Hedgehog: genWith :: forall a ins out. Typeable a => Registry ins out -> Gen a
+ Data.Registry.Hedgehog: genWith :: forall a (ins :: [Type]) (out :: [Type]). Typeable a => Registry ins out -> Gen a
- Data.Registry.Hedgehog: hashMapOf :: forall k v. (Ord k, Hashable k) => Gen k -> Gen v -> Gen (HashMap k v)
+ Data.Registry.Hedgehog: hashMapOf :: (Ord k, Hashable k) => Gen k -> Gen v -> Gen (HashMap k v)
- Data.Registry.Hedgehog: listOf :: forall a. Gen a -> Gen [a]
+ Data.Registry.Hedgehog: listOf :: Gen a -> Gen [a]
- Data.Registry.Hedgehog: listOfMinMax :: forall a. Int -> Int -> Gen a -> Gen [a]
+ Data.Registry.Hedgehog: listOfMinMax :: Int -> Int -> Gen a -> Gen [a]
- Data.Registry.Hedgehog: makeNonEmpty :: forall (a :: Type) ins out. Typeable a => Registry ins out -> Registry ins out
+ Data.Registry.Hedgehog: makeNonEmpty :: forall a (ins :: [Type]) (out :: [Type]). Typeable a => Registry ins out -> Registry ins out
- Data.Registry.Hedgehog: mapOf :: forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
+ Data.Registry.Hedgehog: mapOf :: Ord k => Gen k -> Gen v -> Gen (Map k v)
- Data.Registry.Hedgehog: maybeOf :: forall a. Gen a -> Gen (Maybe a)
+ Data.Registry.Hedgehog: maybeOf :: Gen a -> Gen (Maybe a)
- Data.Registry.Hedgehog: nonEmptyMapOf :: forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
+ Data.Registry.Hedgehog: nonEmptyMapOf :: Ord k => Gen k -> Gen v -> Gen (Map k v)
- Data.Registry.Hedgehog: pairOf :: forall a b. Gen a -> Gen b -> Gen (a, b)
+ Data.Registry.Hedgehog: pairOf :: Gen a -> Gen b -> Gen (a, b)
- Data.Registry.Hedgehog: setDistinctPairOf :: forall a. (Typeable a, Eq a) => Registry _ _ -> Registry _ _
+ Data.Registry.Hedgehog: setDistinctPairOf :: forall a {ins :: [Type]} {out :: [Type]}. (Typeable a, Eq a) => Registry ins out -> Registry (GenT Identity a ': ins) (GenT Identity (a, a) ': out)
- Data.Registry.Hedgehog: setDistinctPairOfOn :: forall a b. (Typeable a, Eq b) => (a -> b) -> Registry _ _ -> Registry _ _
+ Data.Registry.Hedgehog: setDistinctPairOfOn :: forall a b {ins :: [Type]} {out :: [Type]}. (Typeable a, Eq b) => (a -> b) -> Registry ins out -> Registry (GenT Identity a ': ins) (GenT Identity (a, a) ': out)
- Data.Registry.Hedgehog: setDistinctTripleOf :: forall a. (Typeable a, Eq a) => Registry _ _ -> Registry _ _
+ Data.Registry.Hedgehog: setDistinctTripleOf :: forall a {ins :: [Type]} {out :: [Type]}. (Typeable a, Eq a) => Registry ins out -> Registry (GenT Identity a ': ins) (GenT Identity (a, a, a) ': out)
- Data.Registry.Hedgehog: setDistinctTripleOfOn :: forall a b. (Typeable a, Eq b) => (a -> b) -> Registry _ _ -> Registry _ _
+ Data.Registry.Hedgehog: setDistinctTripleOfOn :: forall a b {ins :: [Type]} {out :: [Type]}. (Typeable a, Eq b) => (a -> b) -> Registry ins out -> Registry (GenT Identity a ': ins) (GenT Identity (a, a, a) ': out)
- Data.Registry.Hedgehog: setGen :: forall a ins out. Typeable a => Gen a -> Registry ins out -> Registry ins out
+ Data.Registry.Hedgehog: setGen :: forall a (ins :: [Type]) (out :: [Type]). Typeable a => Gen a -> Registry ins out -> Registry ins out
- Data.Registry.Hedgehog: setOf :: forall a. Ord a => Gen a -> Gen (Set a)
+ Data.Registry.Hedgehog: setOf :: Ord a => Gen a -> Gen (Set a)
- Data.Registry.Hedgehog: setOfMinMax :: forall a. Ord a => Int -> Int -> Gen a -> Gen (Set a)
+ Data.Registry.Hedgehog: setOfMinMax :: Ord a => Int -> Int -> Gen a -> Gen (Set a)
- Data.Registry.Hedgehog: specializeGen :: forall (a :: Type) b ins out. (Typeable a, Typeable b) => Gen b -> Registry ins out -> Registry ins out
+ Data.Registry.Hedgehog: specializeGen :: forall a b (ins :: [Type]) (out :: [Type]). (Typeable a, Typeable b) => Gen b -> Registry ins out -> Registry ins out
- Data.Registry.Hedgehog: tripleOf :: forall a b c. Gen a -> Gen b -> Gen c -> Gen (a, b, c)
+ Data.Registry.Hedgehog: tripleOf :: Gen a -> Gen b -> Gen c -> Gen (a, b, c)
- Data.Registry.Hedgehog: tuple4Of :: forall a b c d. Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d)
+ Data.Registry.Hedgehog: tuple4Of :: Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d)
- Data.Registry.Hedgehog: tuple5Of :: forall a b c d e. Gen a -> Gen b -> Gen c -> Gen d -> Gen e -> Gen (a, b, c, d, e)
+ Data.Registry.Hedgehog: tuple5Of :: Gen a -> Gen b -> Gen c -> Gen d -> Gen e -> Gen (a, b, c, d, e)
- Data.Registry.Hedgehog: tweakGen :: forall a ins out. Typeable a => (a -> a) -> Registry ins out -> Registry ins out
+ Data.Registry.Hedgehog: tweakGen :: forall a (ins :: [Type]) (out :: [Type]). Typeable a => (a -> a) -> Registry ins out -> Registry ins out
- Data.Registry.Hedgehog.TH: emptyRegistry :: Registry '[] '[]
+ Data.Registry.Hedgehog.TH: emptyRegistry :: Registry ('[] :: [Type]) ('[] :: [Type])
- Data.Registry.Internal.Hedgehog: Chooser :: Text -> (forall a. [Gen a] -> Gen a) -> Chooser
+ Data.Registry.Internal.Hedgehog: Chooser :: Text -> (forall a. () => [Gen a] -> Gen a) -> Chooser
- Data.Registry.Internal.Hedgehog: [pickOne] :: Chooser -> forall a. [Gen a] -> Gen a
+ Data.Registry.Internal.Hedgehog: [pickOne] :: Chooser -> forall a. () => [Gen a] -> Gen a
- Data.Registry.Internal.Hedgehog: liftGen :: Monad m => Gen a -> GenT m a
+ Data.Registry.Internal.Hedgehog: liftGen :: forall (m :: Type -> Type) a. Monad m => Gen a -> GenT m a
- Test.Tasty.Hedgehogx: class () => FunctorB (b :: k -> Type -> Type)
+ Test.Tasty.Hedgehogx: class FunctorB (b :: k -> Type -> Type)
- Test.Tasty.Hedgehogx: class () => HTraversable (t :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: class HTraversable (t :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: data () => Action (m :: Type -> Type) (state :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: data Action (m :: Type -> Type) (state :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: data () => Callback (input :: Type -> Type -> Type) output (state :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: data Callback (input :: Type -> Type -> Type) output (state :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: data () => Command (gen :: Type -> Type) (m :: Type -> Type) (state :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: data Command (gen :: Type -> Type) (m :: Type -> Type) (state :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: data () => Confidence
+ Test.Tasty.Hedgehogx: data Confidence
- Test.Tasty.Hedgehogx: data () => DiscardLimit
+ Test.Tasty.Hedgehogx: data DiscardLimit
- Test.Tasty.Hedgehogx: data () => GenT (m :: Type -> Type) a
+ Test.Tasty.Hedgehogx: data GenT (m :: Type -> Type) a
- Test.Tasty.Hedgehogx: data () => Group
+ Test.Tasty.Hedgehogx: data Group
- Test.Tasty.Hedgehogx: data () => GroupName
+ Test.Tasty.Hedgehogx: data GroupName
- Test.Tasty.Hedgehogx: data () => LabelName
+ Test.Tasty.Hedgehogx: data LabelName
- Test.Tasty.Hedgehogx: data () => Parallel (m :: Type -> Type) (state :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: data Parallel (m :: Type -> Type) (state :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: data () => Property
+ Test.Tasty.Hedgehogx: data Property
- Test.Tasty.Hedgehogx: data () => PropertyName
+ Test.Tasty.Hedgehogx: data PropertyName
- Test.Tasty.Hedgehogx: data () => PropertyT (m :: Type -> Type) a
+ Test.Tasty.Hedgehogx: data PropertyT (m :: Type -> Type) a
- Test.Tasty.Hedgehogx: data () => Range a
+ Test.Tasty.Hedgehogx: data Range a
- Test.Tasty.Hedgehogx: data () => Seed
+ Test.Tasty.Hedgehogx: data Seed
- Test.Tasty.Hedgehogx: data () => ShrinkLimit
+ Test.Tasty.Hedgehogx: data ShrinkLimit
- Test.Tasty.Hedgehogx: data () => ShrinkRetries
+ Test.Tasty.Hedgehogx: data ShrinkRetries
- Test.Tasty.Hedgehogx: data () => Skip
+ Test.Tasty.Hedgehogx: data Skip
- Test.Tasty.Hedgehogx: data () => Symbolic a
+ Test.Tasty.Hedgehogx: data Symbolic a
- Test.Tasty.Hedgehogx: data () => TestLimit
+ Test.Tasty.Hedgehogx: data TestLimit
- Test.Tasty.Hedgehogx: data () => TestT (m :: Type -> Type) a
+ Test.Tasty.Hedgehogx: data TestT (m :: Type -> Type) a
- Test.Tasty.Hedgehogx: display :: (Show a, Monad m, HasCallStack) => a -> PropertyT m a
+ Test.Tasty.Hedgehogx: display :: forall a (m :: Type -> Type). (Show a, Monad m, HasCallStack) => a -> PropertyT m a
- Test.Tasty.Hedgehogx: gotException :: forall a. (HasCallStack, Show a) => a -> PropertyT IO ()
+ Test.Tasty.Hedgehogx: gotException :: (HasCallStack, Show a) => a -> PropertyT IO ()
- Test.Tasty.Hedgehogx: newtype () => Concrete a
+ Test.Tasty.Hedgehogx: newtype Concrete a
- Test.Tasty.Hedgehogx: newtype () => Opaque a
+ Test.Tasty.Hedgehogx: newtype Opaque a
- Test.Tasty.Hedgehogx: newtype () => Rec p a (x :: k)
+ Test.Tasty.Hedgehogx: newtype Rec p a (x :: k)
- Test.Tasty.Hedgehogx: newtype () => Sequential (m :: Type -> Type) (state :: Type -> Type -> Type)
+ Test.Tasty.Hedgehogx: newtype Sequential (m :: Type -> Type) (state :: Type -> Type -> Type)
- Test.Tasty.Hedgehogx: newtype () => Size
+ Test.Tasty.Hedgehogx: newtype Size
- Test.Tasty.Hedgehogx: newtype () => Var a (v :: Type -> Type)
+ Test.Tasty.Hedgehogx: newtype Var a (v :: Type -> Type)

Files

registry-hedgehog.cabal view
@@ -7,7 +7,7 @@ -- hash: 8f91154bd5dc81b34d27c5e31a8ec2b694b29bcb0c68cc3e3844cd8494f6b8f3  name:           registry-hedgehog-version:        0.8.2.1+version:        0.8.2.2 synopsis:       utilities to work with Hedgehog generators and `registry` description:    This library provides some functions to extract generators from a "Registry" and make stateful modifications of that Registry to precisely control the generation of data category:       Control