QuickSpec

The main QuickSpec module. Everything you need to run QuickSpec lives here.

To run QuickSpec, you need to tell it which functions to test. We call the list of functions the signature. Here is an example signature, which tells QuickSpec to test the ++, reverse and [] functions:

sig = [
  con "++"      ((++) :: [A] -> [A] -> [A]),
  con "reverse" (reverse :: [A] -> [A]),
  con "[]"      ([] :: [A]) ]

The con function, used above, adds a function to the signature, given its name and its value. When declaring polymorphic functions in the signature, we use the types A to E to represent type variables. Having defined this signature, we can say quickSpec sig to test it and see the discovered equations.

If you want to test functions over your own datatypes, those types need to implement Arbitrary and Ord (if the Ord instance is a problem, see Observe). You must also declare those instances to QuickSpec, by including them in the signature. For monomorphic types you can do this using monoType:

data T = ...
main = quickSpec [
  ...,
  monoType (Proxy :: Proxy T)]

You can only declare monomorphic types with monoType. If you want to test your own polymorphic types, you must explicitly declare Arbitrary and Ord instances using the inst function.

You can also use QuickSpec to find conditional equations. To do so, you need to include some predicates in the signature. These are functions returning Bool which can appear as conditions in other equations. Declaring a predicate works just like declaring a function, except that you declare it using predicate instead of con.

You can also put certain options in the signature. The most useful is withMaxTermSize, which you can use to tell QuickSpec to generate larger equations.

The examples directory contains many examples. Here are some interesting ones:

• Arith.hs: a simple arithmetic example. Demonstrates basic use of QuickSpec.
• Lists.hs: list functions. Demonstrates testing polymorphic functions.
• Sorted.hs: sorting. Demonstrates finding conditional equations.
• IntSet.hs: a few functions from Data.IntSet. Demonstrates testing user-defined datatypes and finding conditional equations.
• PrettyPrinting.hs: pretty printing combinators. Demonstrates testing user-defined datatypes and using observational equality.
• Parsing.hs: parser combinators. Demonstrates testing polymorphic datatypes and using observational equality.

You can also find some larger case studies in our paper, Quick specifications for the busy programmer.

Running QuickSpec

quickSpec :: Signature sig => sig -> IO ()

Run QuickSpec. See the documentation at the top of this file.

data Sig

A signature.

Instances

Semigroup Sig

Defined in QuickSpec.Internal

Methods

(<>) :: Sig -> Sig -> Sig

sconcat :: NonEmpty Sig -> Sig

stimes :: Integral b => b -> Sig -> Sig

Monoid Sig

Defined in QuickSpec.Internal

Methods

mempty :: Sig

mappend :: Sig -> Sig -> Sig

mconcat :: [Sig] -> Sig

Signature Sig

Defined in QuickSpec.Internal

Methods

signature :: Sig -> Sig

class Signature sig where

A class of things that can be used as a QuickSpec signature.

Methods

signature :: sig -> Sig

Convert the thing to a signature.

Instances

Signature Sig

Defined in QuickSpec.Internal

Methods

signature :: Sig -> Sig

Signature sig => Signature [sig]

Defined in QuickSpec.Internal

Methods

signature :: [sig] -> Sig

Declaring functions and predicates

con :: Typeable a => String -> a -> Sig

Declare a constant with a given name and value. If the constant you want to use is polymorphic, you can use the types A, B, C, D, E to monomorphise it, for example:

constant "reverse" (reverse :: [A] -> [A])

QuickSpec will then understand that the constant is really polymorphic.

predicate :: (Predicateable a, Typeable a, Typeable (PredicateTestCase a)) => String -> a -> Sig

Declare a predicate with a given name and value. The predicate should be a function which returns Bool. It will appear in equations just like any other constant, but will also be allowed to appear as a condition.

For example:

sig = [
  con "delete" (delete :: Int -> [Int] -> [Int]),
  con "insert" (insert :: Int -> [Int] -> [Int]),
  predicate "member" (member :: Int -> [Int] -> Bool) ]

predicateGen :: (Predicateable a, Typeable a, Typeable b, Typeable (PredicateTestCase a)) => String -> a -> (b -> Gen (PredicateTestCase a)) -> Sig

Declare a predicate with a given name and value. The predicate should be a function which returns Bool. It will appear in equations just like any other constant, but will also be allowed to appear as a condition. The third argument is a generator for values satisfying the predicate.

Type variables for polymorphic functions

data A

data B

data C

data D

data E

Declaring types

monoType :: forall proxy a. (Ord a, Arbitrary a, Typeable a) => proxy a -> Sig

Declare a new monomorphic type. The type must implement Ord and Arbitrary.

monoTypeObserve :: forall proxy test outcome a. (Observe test outcome a, Arbitrary test, Ord outcome, Arbitrary a, Typeable test, Typeable outcome, Typeable a) => proxy a -> Sig

Declare a new monomorphic type using observational equivalence. The type must implement Observe and Arbitrary.

vars :: forall proxy a. Typeable a => [String] -> proxy a -> Sig

Customize how variables of a particular type are named.

monoTypeWithVars :: forall proxy a. (Ord a, Arbitrary a, Typeable a) => [String] -> proxy a -> Sig

Declare a new monomorphic type, saying how you want variables of that type to be named.

inst :: (Typeable c1, Typeable c2) => (c1 :- c2) -> Sig

Declare a typeclass instance. QuickSpec needs to have an Ord and Arbitrary instance for each type you want it to test.

For example, if you are testing Map k v, you will need to add the following two declarations to your signature:

inst (Sub Dict :: (Ord A, Ord B) :- Ord (Map A B))
inst (Sub Dict :: (Arbitrary A, Arbitrary B) :- Arbitrary (Map A B))

class (Arbitrary test, Ord outcome) => Observe test outcome a | a -> test outcome where

A typeclass for types which support observational equality, typically used for types that have no Ord instance.

An instance Observe test outcome a declares that values of type a can be tested for equality by random testing. You supply a function observe :: test -> outcome -> a. Then, two values x and y are considered equal, if for many random values of type test, observe test x == observe test y.

The function monoTypeObserve declares a monomorphic type with an observation function. For polymorphic types, use inst to declare the Observe instance.

For an example of using observational equality, see PrettyPrinting.hs.

Minimal complete definition

Nothing

Methods

observe :: test -> a -> outcome

Make an observation on a value. Should satisfy the following law: if x /= y, then there exists a value of test such that observe test x /= observe test y.

observe :: (test ~ (), outcome ~ a) => test -> a -> outcome

Make an observation on a value. Should satisfy the following law: if x /= y, then there exists a value of test such that observe test x /= observe test y.

Instances

(Arbitrary a, Observe test outcome b) => Observe (a, test) outcome (a -> b)

Defined in QuickSpec.Internal.Haskell

Methods

observe :: (a, test) -> (a -> b) -> outcome

Standard signatures

The "prelude": a standard signature containing useful functions like ++, which can be used as background theory.

lists :: Sig

A signature containing list operations: [], (:), (++).

arith :: forall proxy a. (Typeable a, Ord a, Num a, Arbitrary a) => proxy a -> Sig

A signature containing arithmetic operations: 0, 1, (+). Instantiate it with e.g. arith (Proxy :: Proxy Int).

funs :: Sig

A signature containing higher-order functions: (.) and id. Useful for testing map and similar.

bools :: Sig

A signature containing boolean functions: (||), (&&), not, True, False.

prelude :: Sig

The QuickSpec prelude. Contains boolean, arithmetic and list functions, and function composition. For more precise control over what gets included, see bools, arith, lists, funs and without.

without :: Signature sig => sig -> [String] -> Sig

Remove a function or predicate from the signature. Useful in combination with prelude and friends.

Exploring functions in series

background :: Signature sig => sig -> Sig

Declare some functions as being background functions. These are functions which are not interesting on their own, but which may appear in interesting laws with non-background functions. Declaring background functions may improve the laws you get out.

Here is an example, which tests ++ and length, giving 0 and + as background functions:

main = quickSpec [
  con "++" ((++) :: [A] -> [A] -> [A]),
  con "length" (length :: [A] -> Int),

  background [
    con "0" (0 :: Int),
    con "+" ((+) :: Int -> Int -> Int) ] ]

series :: Signature sig => [sig] -> Sig

Run QuickCheck on a series of signatures. Tests the functions in the first signature, then adds the functions in the second signature, then adds the functions in the third signature, and so on.

This can be useful when you have a core API you want to test first, and a larger API you want to test later. The laws for the core API will be printed separately from the laws for the larger API.

Here is an example which first tests 0 and + and then adds ++ and length:

main = quickSpec [sig1, sig2]
  where
    sig1 = [
      con "0" (0 :: Int),
      con "+" ((+) :: Int -> Int -> Int) ]
    sig2 = [
      con "++" ((++) :: [A] -> [A] -> [A]),
      con "length" (length :: [A] -> Int) ]

Including type class constraints (experimental, subject to change)

type (==>) c t = Dict c -> t

Type class constraints as first class citizens

liftC :: (c => a) -> c ==> a

Lift a constrained type to a ==> type which QuickSpec can work with

instanceOf :: forall c. (Typeable c, c) => Sig

Add an instance of a type class to the signature

Customising QuickSpec

withMaxTermSize :: Int -> Sig

Set the maximum size of terms to explore (default: 7).

withMaxTests :: Int -> Sig

Set how many times to test each discovered law (default: 1000).

withMaxTestSize :: Int -> Sig

Set the maximum value for QuickCheck's size parameter when generating test data (default: 20).

defaultTo :: Typeable a => proxy a -> Sig

Set which type polymorphic terms are tested at.

withPruningDepth :: Int -> Sig

Set how hard QuickSpec tries to filter out redundant equations (default: no limit).

If you experience long pauses when running QuickSpec, try setting this number to 2 or 3.

withPruningTermSize :: Int -> Sig

Set the maximum term size QuickSpec will reason about when it filters out redundant equations (default: same as maximum term size).

If you get laws you believe are redundant, try increasing this number to 1 or 2 more than the maximum term size.

withFixedSeed :: Int -> Sig

Set the random number seed used for test case generation. Useful if you want repeatable results.

withInferInstanceTypes :: Sig

Automatically infer types to add to the universe from available type class instances

Re-exported functionality

class Typeable (a :: k)

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

Instances

HasDict (Typeable k, Typeable a) (TypeRep a)

Defined in Data.Constraint

Methods

evidence :: TypeRep a -> Dict (Typeable k, Typeable a)

newtype a :- b infixr 9

This is the type of entailment.

a :- b is read as a "entails" b.

With this we can actually build a category for Constraint resolution.

e.g.

Because Eq a is a superclass of Ord a, we can show that Ord a entails Eq a.

Because instance Ord a => Ord [a] exists, we can show that Ord a entails Ord [a] as well.

This relationship is captured in the :- entailment type here.

Since p :- p and entailment composes, :- forms the arrows of a Category of constraints. However, Category only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.

But due to the coherence of instance resolution in Haskell, this Category has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.

This means that for instance, even though there are two ways to derive Ord a :- Eq [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".

What are the two ways?

Well, we can go from Ord a :- Eq a via the superclass relationship, and then from Eq a :- Eq [a] via the instance, or we can go from Ord a :- Ord [a] via the instance then from Ord [a] :- Eq [a] through the superclass relationship and this diagram by definition must "commute".

Diagrammatically,

                   Ord a
               ins /     \ cls
                  v       v
            Ord [a]     Eq a
               cls \     / ins
                    v   v
                   Eq [a]

This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors.

Constructors

Sub (a -> Dict b)

Instances

Category (:-)

Possible since GHC 7.8, when Category was made polykinded.

Defined in Data.Constraint

Methods

id :: a :- a

(.) :: (b :- c) -> (a :- b) -> a :- c

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

a => HasDict b (a :- b)

Defined in Data.Constraint

Methods

evidence :: (a :- b) -> Dict b

Eq (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

(==) :: (a :- b) -> (a :- b) -> Bool

(/=) :: (a :- b) -> (a :- b) -> Bool

(Typeable p, Typeable q, p, q) => Data (p :- q)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (p :- q) -> c (p :- q)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (p :- q)

toConstr :: (p :- q) -> Constr

dataTypeOf :: (p :- q) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (p :- q))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (p :- q))

gmapT :: (forall b. Data b => b -> b) -> (p :- q) -> p :- q

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQ :: (forall d. Data d => d -> u) -> (p :- q) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (p :- q) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

Ord (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

compare :: (a :- b) -> (a :- b) -> Ordering

(<) :: (a :- b) -> (a :- b) -> Bool

(<=) :: (a :- b) -> (a :- b) -> Bool

(>) :: (a :- b) -> (a :- b) -> Bool

(>=) :: (a :- b) -> (a :- b) -> Bool

max :: (a :- b) -> (a :- b) -> a :- b

min :: (a :- b) -> (a :- b) -> a :- b

Show (a :- b)

Defined in Data.Constraint

Methods

showsPrec :: Int -> (a :- b) -> ShowS

show :: (a :- b) -> String

showList :: [a :- b] -> ShowS

a => NFData (a :- b)

Defined in Data.Constraint

Methods

rnf :: (a :- b) -> ()

data Dict a where

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq 'Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: forall a. a => Dict a

Instances

HasDict a (Dict a)

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

Eq (Dict a)

Defined in Data.Constraint

Methods

(==) :: Dict a -> Dict a -> Bool

(/=) :: Dict a -> Dict a -> Bool

(Typeable p, p) => Data (Dict p)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p)

toConstr :: Dict p -> Constr

dataTypeOf :: Dict p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p))

gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

sconcat :: NonEmpty (Dict a) -> Dict a

stimes :: Integral b => b -> Dict a -> Dict a

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

c => Arbitrary (Dict c)

Defined in QuickSpec.Internal.Haskell

Methods

arbitrary :: Gen (Dict c)

shrink :: Dict c -> [Dict c]

NFData (Dict c)

Defined in Data.Constraint

Methods

rnf :: Dict c -> ()

data Proxy (t :: k) :: forall k. k -> Type

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the 'undefined :: a' idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy

Constructors

Proxy

Instances

Generic1 (Proxy :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 Proxy :: k -> Type

Methods

from1 :: Proxy a -> Rep1 Proxy a

to1 :: Rep1 Proxy a -> Proxy a

Monad (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b

(>>) :: Proxy a -> Proxy b -> Proxy b

return :: a -> Proxy a

fail :: String -> Proxy a

Functor (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

fmap :: (a -> b) -> Proxy a -> Proxy b

(<$) :: a -> Proxy b -> Proxy a

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Foldable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Traversable (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Proxy a -> f (Proxy b)

sequenceA :: Applicative f => Proxy (f a) -> f (Proxy a)

mapM :: Monad m => (a -> m b) -> Proxy a -> m (Proxy b)

sequence :: Monad m => Proxy (m a) -> m (Proxy a)

Eq1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a -> b -> Bool) -> Proxy a -> Proxy b -> Bool

Ord1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy a -> Proxy b -> Ordering

Read1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy a]

Show1 (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy a] -> ShowS

Alternative (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

empty :: Proxy a

(<|>) :: Proxy a -> Proxy a -> Proxy a

some :: Proxy a -> Proxy [a]

many :: Proxy a -> Proxy [a]

MonadPlus (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

mzero :: Proxy a

mplus :: Proxy a -> Proxy a -> Proxy a

Hashable1 (Proxy :: Type -> Type)

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Proxy a -> Int

Bounded (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

minBound :: Proxy t

maxBound :: Proxy t

Enum (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

succ :: Proxy s -> Proxy s

pred :: Proxy s -> Proxy s

toEnum :: Int -> Proxy s

fromEnum :: Proxy s -> Int

enumFrom :: Proxy s -> [Proxy s]

enumFromThen :: Proxy s -> Proxy s -> [Proxy s]

enumFromTo :: Proxy s -> Proxy s -> [Proxy s]

enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s]

Eq (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

(==) :: Proxy s -> Proxy s -> Bool

(/=) :: Proxy s -> Proxy s -> Bool

Ord (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

compare :: Proxy s -> Proxy s -> Ordering

(<) :: Proxy s -> Proxy s -> Bool

(<=) :: Proxy s -> Proxy s -> Bool

(>) :: Proxy s -> Proxy s -> Bool

(>=) :: Proxy s -> Proxy s -> Bool

max :: Proxy s -> Proxy s -> Proxy s

min :: Proxy s -> Proxy s -> Proxy s

Read (Proxy t)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

readsPrec :: Int -> ReadS (Proxy t)

readList :: ReadS [Proxy t]

readPrec :: ReadPrec (Proxy t)

readListPrec :: ReadPrec [Proxy t]

Show (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

showsPrec :: Int -> Proxy s -> ShowS

show :: Proxy s -> String

showList :: [Proxy s] -> ShowS

Ix (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

range :: (Proxy s, Proxy s) -> [Proxy s]

index :: (Proxy s, Proxy s) -> Proxy s -> Int

unsafeIndex :: (Proxy s, Proxy s) -> Proxy s -> Int

inRange :: (Proxy s, Proxy s) -> Proxy s -> Bool

rangeSize :: (Proxy s, Proxy s) -> Int

unsafeRangeSize :: (Proxy s, Proxy s) -> Int

Generic (Proxy t)

Defined in GHC.Generics

Associated Types

type Rep (Proxy t) :: Type -> Type

Methods

from :: Proxy t -> Rep (Proxy t) x

to :: Rep (Proxy t) x -> Proxy t

Semigroup (Proxy s)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

(<>) :: Proxy s -> Proxy s -> Proxy s

sconcat :: NonEmpty (Proxy s) -> Proxy s

stimes :: Integral b => b -> Proxy s -> Proxy s

Monoid (Proxy s)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

mempty :: Proxy s

mappend :: Proxy s -> Proxy s -> Proxy s

mconcat :: [Proxy s] -> Proxy s

Hashable (Proxy a)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Proxy a -> Int

hash :: Proxy a -> Int

type Rep1 (Proxy :: k -> Type)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep1 (Proxy :: k -> Type) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: k -> Type))

type Rep (Proxy t)

Since: base-4.6.0.0

Defined in GHC.Generics

type Rep (Proxy t) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) (U1 :: Type -> Type))

class Arbitrary a

Random generation and shrinking of values.

QuickCheck provides Arbitrary instances for most types in base, except those which incur extra dependencies. For a wider range of Arbitrary instances see the quickcheck-instances package.

Minimal complete definition

arbitrary

Instances

Arbitrary Bool

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Bool

shrink :: Bool -> [Bool]

Arbitrary Char

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Char

shrink :: Char -> [Char]

Arbitrary Double

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Double

shrink :: Double -> [Double]

Arbitrary Float

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Float

shrink :: Float -> [Float]

Arbitrary Int

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int

shrink :: Int -> [Int]

Arbitrary Int8

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int8

shrink :: Int8 -> [Int8]

Arbitrary Int16

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int16

shrink :: Int16 -> [Int16]

Arbitrary Int32

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int32

shrink :: Int32 -> [Int32]

Arbitrary Int64

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Int64

shrink :: Int64 -> [Int64]

Arbitrary Integer

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Integer

shrink :: Integer -> [Integer]

Arbitrary Ordering

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Ordering

shrink :: Ordering -> [Ordering]

Arbitrary Word

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word

shrink :: Word -> [Word]

Arbitrary Word8

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word8

shrink :: Word8 -> [Word8]

Arbitrary Word16

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word16

shrink :: Word16 -> [Word16]

Arbitrary Word32

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word32

shrink :: Word32 -> [Word32]

Arbitrary Word64

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Word64

shrink :: Word64 -> [Word64]

Arbitrary ()

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen ()

shrink :: () -> [()]

Arbitrary Version

Generates Version with non-empty non-negative versionBranch, and empty versionTags

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Version

shrink :: Version -> [Version]

Arbitrary QCGen

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen QCGen

shrink :: QCGen -> [QCGen]

Arbitrary ASCIIString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen ASCIIString

shrink :: ASCIIString -> [ASCIIString]

Arbitrary UnicodeString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen UnicodeString

shrink :: UnicodeString -> [UnicodeString]

Arbitrary PrintableString

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen PrintableString

shrink :: PrintableString -> [PrintableString]

Arbitrary A

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen A

shrink :: A -> [A]

Arbitrary B

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen B

shrink :: B -> [B]

Arbitrary C

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen C

shrink :: C -> [C]

Arbitrary OrdA

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen OrdA

shrink :: OrdA -> [OrdA]

Arbitrary OrdB

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen OrdB

shrink :: OrdB -> [OrdB]

Arbitrary OrdC

Defined in Test.QuickCheck.Poly

Methods

arbitrary :: Gen OrdC

shrink :: OrdC -> [OrdC]

Arbitrary ExitCode

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen ExitCode

shrink :: ExitCode -> [ExitCode]

Arbitrary All

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen All

shrink :: All -> [All]

Arbitrary Any

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen Any

shrink :: Any -> [Any]

Arbitrary CChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CChar

shrink :: CChar -> [CChar]

Arbitrary CSChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSChar

shrink :: CSChar -> [CSChar]

Arbitrary CUChar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUChar

shrink :: CUChar -> [CUChar]

Arbitrary CShort

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CShort

shrink :: CShort -> [CShort]

Arbitrary CUShort

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUShort

shrink :: CUShort -> [CUShort]

Arbitrary CInt

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CInt

shrink :: CInt -> [CInt]

Arbitrary CUInt

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUInt

shrink :: CUInt -> [CUInt]

Arbitrary CLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CLong

shrink :: CLong -> [CLong]

Arbitrary CULong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CULong

shrink :: CULong -> [CULong]

Arbitrary CLLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CLLong

shrink :: CLLong -> [CLLong]

Arbitrary CULLong

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CULLong

shrink :: CULLong -> [CULLong]

Arbitrary CFloat

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CFloat

shrink :: CFloat -> [CFloat]

Arbitrary CDouble

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CDouble

shrink :: CDouble -> [CDouble]

Arbitrary CPtrdiff

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CPtrdiff

shrink :: CPtrdiff -> [CPtrdiff]

Arbitrary CSize

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSize

shrink :: CSize -> [CSize]

Arbitrary CWchar

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CWchar

shrink :: CWchar -> [CWchar]

Arbitrary CSigAtomic

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSigAtomic

shrink :: CSigAtomic -> [CSigAtomic]

Arbitrary CClock

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CClock

shrink :: CClock -> [CClock]

Arbitrary CTime

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CTime

shrink :: CTime -> [CTime]

Arbitrary CUSeconds

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUSeconds

shrink :: CUSeconds -> [CUSeconds]

Arbitrary CSUSeconds

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CSUSeconds

shrink :: CSUSeconds -> [CSUSeconds]

Arbitrary CIntPtr

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CIntPtr

shrink :: CIntPtr -> [CIntPtr]

Arbitrary CUIntPtr

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUIntPtr

shrink :: CUIntPtr -> [CUIntPtr]

Arbitrary CIntMax

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CIntMax

shrink :: CIntMax -> [CIntMax]

Arbitrary CUIntMax

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen CUIntMax

shrink :: CUIntMax -> [CUIntMax]

Arbitrary IntSet

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen IntSet

shrink :: IntSet -> [IntSet]

Arbitrary a => Arbitrary [a]

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen [a]

shrink :: [a] -> [[a]]

Arbitrary a => Arbitrary (Maybe a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Maybe a)

shrink :: Maybe a -> [Maybe a]

Integral a => Arbitrary (Ratio a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Ratio a)

shrink :: Ratio a -> [Ratio a]

Arbitrary a => Arbitrary (Blind a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Blind a)

shrink :: Blind a -> [Blind a]

Arbitrary a => Arbitrary (Fixed a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

(Ord a, Arbitrary a) => Arbitrary (OrderedList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (OrderedList a)

shrink :: OrderedList a -> [OrderedList a]

Arbitrary a => Arbitrary (NonEmptyList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonEmptyList a)

shrink :: NonEmptyList a -> [NonEmptyList a]

Arbitrary a => Arbitrary (InfiniteList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (InfiniteList a)

shrink :: InfiniteList a -> [InfiniteList a]

(Arbitrary a, Ord a) => Arbitrary (SortedList a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (SortedList a)

shrink :: SortedList a -> [SortedList a]

(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Positive a)

shrink :: Positive a -> [Positive a]

(Num a, Ord a, Arbitrary a) => Arbitrary (Negative a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Negative a)

shrink :: Negative a -> [Negative a]

(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonZero a)

shrink :: NonZero a -> [NonZero a]

(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonNegative a)

shrink :: NonNegative a -> [NonNegative a]

(Num a, Ord a, Arbitrary a) => Arbitrary (NonPositive a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (NonPositive a)

shrink :: NonPositive a -> [NonPositive a]

(Integral a, Bounded a) => Arbitrary (Large a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Large a)

shrink :: Large a -> [Large a]

Integral a => Arbitrary (Small a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Small a)

shrink :: Small a -> [Small a]

Arbitrary a => Arbitrary (Shrink2 a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrink2 a)

shrink :: Shrink2 a -> [Shrink2 a]

Arbitrary a => Arbitrary (Smart a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Smart a)

shrink :: Smart a -> [Smart a]

(RealFloat a, Arbitrary a) => Arbitrary (Complex a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Complex a)

shrink :: Complex a -> [Complex a]

HasResolution a => Arbitrary (Fixed a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Fixed a)

shrink :: Fixed a -> [Fixed a]

Arbitrary a => Arbitrary (ZipList a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (ZipList a)

shrink :: ZipList a -> [ZipList a]

Arbitrary a => Arbitrary (Identity a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Identity a)

shrink :: Identity a -> [Identity a]

Arbitrary a => Arbitrary (First a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (First a)

shrink :: First a -> [First a]

Arbitrary a => Arbitrary (Last a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Last a)

shrink :: Last a -> [Last a]

Arbitrary a => Arbitrary (Dual a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Dual a)

shrink :: Dual a -> [Dual a]

(Arbitrary a, CoArbitrary a) => Arbitrary (Endo a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Endo a)

shrink :: Endo a -> [Endo a]

Arbitrary a => Arbitrary (Sum a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Sum a)

shrink :: Sum a -> [Sum a]

Arbitrary a => Arbitrary (Product a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Product a)

shrink :: Product a -> [Product a]

c => Arbitrary (Dict c)

Defined in QuickSpec.Internal.Haskell

Methods

arbitrary :: Gen (Dict c)

shrink :: Dict c -> [Dict c]

Arbitrary a => Arbitrary (IntMap a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (IntMap a)

shrink :: IntMap a -> [IntMap a]

Arbitrary a => Arbitrary (Seq a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Seq a)

shrink :: Seq a -> [Seq a]

(Ord a, Arbitrary a) => Arbitrary (Set a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Set a)

shrink :: Set a -> [Set a]

Arbitrary a => Arbitrary (InfiniteListInternalData a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (InfiniteListInternalData a)

shrink :: InfiniteListInternalData a -> [InfiniteListInternalData a]

(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a -> b)

shrink :: (a -> b) -> [a -> b]

(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Either a b)

shrink :: Either a b -> [Either a b]

(Arbitrary a, Arbitrary b) => Arbitrary (a, b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b)

shrink :: (a, b) -> [(a, b)]

(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (a :-> b)

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (a :-> b)

shrink :: (a :-> b) -> [a :-> b]

(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b)

Defined in Test.QuickCheck.Function

Methods

arbitrary :: Gen (Fun a b)

shrink :: Fun a b -> [Fun a b]

(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)

Defined in Test.QuickCheck.Modifiers

Methods

arbitrary :: Gen (Shrinking s a)

shrink :: Shrinking s a -> [Shrinking s a]

Arbitrary (m a) => Arbitrary (WrappedMonad m a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (WrappedMonad m a)

shrink :: WrappedMonad m a -> [WrappedMonad m a]

(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Map k v)

shrink :: Map k v -> [Map k v]

(Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c)

shrink :: (a, b, c) -> [(a, b, c)]

Arbitrary (a b c) => Arbitrary (WrappedArrow a b c)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (WrappedArrow a b c)

shrink :: WrappedArrow a b c -> [WrappedArrow a b c]

Arbitrary a => Arbitrary (Const a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Const a b)

shrink :: Const a b -> [Const a b]

Arbitrary (f a) => Arbitrary (Alt f a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Alt f a)

shrink :: Alt f a -> [Alt f a]

Arbitrary a => Arbitrary (Constant a b)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Constant a b)

shrink :: Constant a b -> [Constant a b]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d)

shrink :: (a, b, c, d) -> [(a, b, c, d)]

(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Product f g a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Product f g a)

shrink :: Product f g a -> [Product f g a]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e)

shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)]

(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Compose f g a)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Compose f g a)

shrink :: Compose f g a -> [Compose f g a]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f) => Arbitrary (a, b, c, d, e, f)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f)

shrink :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g) => Arbitrary (a, b, c, d, e, f, g)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g)

shrink :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h) => Arbitrary (a, b, c, d, e, f, g, h)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h)

shrink :: (a, b, c, d, e, f, g, h) -> [(a, b, c, d, e, f, g, h)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i) => Arbitrary (a, b, c, d, e, f, g, h, i)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h, i)

shrink :: (a, b, c, d, e, f, g, h, i) -> [(a, b, c, d, e, f, g, h, i)]

(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i, Arbitrary j) => Arbitrary (a, b, c, d, e, f, g, h, i, j)

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (a, b, c, d, e, f, g, h, i, j)

shrink :: (a, b, c, d, e, f, g, h, i, j) -> [(a, b, c, d, e, f, g, h, i, j)]