Test.StateMachine.Types.References

This module contains reference related types. It's taken almost verbatim from the Hedgehog library.

Documentation

newtype Reference v a

References are the potential or actual result of executing an action. They are parameterised by either Symbolic or Concrete depending on the phase of the test.

Symbolic variables are the potential results of actions. These are used when generating the sequence of actions to execute. They allow actions which occur later in the sequence to make use of the result of an action which came earlier in the sequence.

Concrete variables are the actual results of actions. These are used during test execution. They provide access to the actual runtime value of a variable.

Constructors

Reference (v a)

Instances

HTraversable Reference

Methods

htraverse :: Applicative f => (forall a. g a -> f (h a)) -> Reference g b -> f (Reference h b)

HFoldable Reference

Methods

hfoldMap :: Monoid m => (forall a. v a -> m) -> Reference v b -> m

HFunctor Reference

Methods

hfmap :: (forall a. g a -> h a) -> Reference g b -> Reference h b

(Eq1 v, Eq a) => Eq (Reference v a)

Methods

(==) :: Reference v a -> Reference v a -> Bool

(/=) :: Reference v a -> Reference v a -> Bool

(Ord1 v, Ord a) => Ord (Reference v a)

Methods

compare :: Reference v a -> Reference v a -> Ordering

(<) :: Reference v a -> Reference v a -> Bool

(<=) :: Reference v a -> Reference v a -> Bool

(>) :: Reference v a -> Reference v a -> Bool

(>=) :: Reference v a -> Reference v a -> Bool

max :: Reference v a -> Reference v a -> Reference v a

min :: Reference v a -> Reference v a -> Reference v a

Read (v a) => Read (Reference v a)

Methods

readsPrec :: Int -> ReadS (Reference v a)

readList :: ReadS [Reference v a]

readPrec :: ReadPrec (Reference v a)

readListPrec :: ReadPrec [Reference v a]

(Show1 v, Show a) => Show (Reference v a)

Methods

showsPrec :: Int -> Reference v a -> ShowS

show :: Reference v a -> String

showList :: [Reference v a] -> ShowS

concrete :: Reference Concrete a -> a

Take the value from a concrete variable.

opaque :: Reference Concrete (Opaque a) -> a

Take the value from an opaque concrete variable.

newtype Opaque a

Opaque values.

Useful if you want to put something without a Show instance inside something which you'd like to be able to display.

Constructors

Opaque

Fields

• unOpaque :: a

Instances

Eq a => Eq (Opaque a)

Methods

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

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

Ord a => Ord (Opaque a)

Methods

compare :: Opaque a -> Opaque a -> Ordering

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

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

(>) :: Opaque a -> Opaque a -> Bool

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

max :: Opaque a -> Opaque a -> Opaque a

min :: Opaque a -> Opaque a -> Opaque a

Show (Opaque a)

Methods

showsPrec :: Int -> Opaque a -> ShowS

show :: Opaque a -> String

showList :: [Opaque a] -> ShowS

data Symbolic a where

Symbolic values.

Constructors

Symbolic :: Typeable a => Var -> Symbolic a

Instances

Foldable Symbolic

Methods

fold :: Monoid m => Symbolic m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Symbolic a -> a

foldl1 :: (a -> a -> a) -> Symbolic a -> a

toList :: Symbolic a -> [a]

null :: Symbolic a -> Bool

length :: Symbolic a -> Int

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

maximum :: Ord a => Symbolic a -> a

minimum :: Ord a => Symbolic a -> a

sum :: Num a => Symbolic a -> a

product :: Num a => Symbolic a -> a

Eq1 Symbolic

Methods

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

Ord1 Symbolic

Methods

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

Show1 Symbolic

Methods

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

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

Eq (Symbolic a)

Methods

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

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

Ord (Symbolic a)

Methods

compare :: Symbolic a -> Symbolic a -> Ordering

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

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

(>) :: Symbolic a -> Symbolic a -> Bool

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

max :: Symbolic a -> Symbolic a -> Symbolic a

min :: Symbolic a -> Symbolic a -> Symbolic a

Typeable * a => Read (Symbolic a)

Methods

readsPrec :: Int -> ReadS (Symbolic a)

readList :: ReadS [Symbolic a]

readPrec :: ReadPrec (Symbolic a)

readListPrec :: ReadPrec [Symbolic a]

Show (Symbolic a)

Methods

showsPrec :: Int -> Symbolic a -> ShowS

show :: Symbolic a -> String

showList :: [Symbolic a] -> ShowS

newtype Concrete a where

Concrete values.

Constructors

Concrete :: a -> Concrete a

Instances

Functor Concrete

Methods

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

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

Foldable Concrete

Methods

fold :: Monoid m => Concrete m -> 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

toList :: Concrete a -> [a]

null :: Concrete a -> Bool

length :: Concrete a -> Int

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

maximum :: Ord a => Concrete a -> a

minimum :: Ord a => Concrete a -> a

sum :: Num a => Concrete a -> a

product :: Num a => Concrete a -> a

Traversable Concrete

Methods

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

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

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

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

Eq1 Concrete

Methods

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

Ord1 Concrete

Methods

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

Show1 Concrete

Methods

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

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

Eq a => Eq (Concrete a)

Methods

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

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

Ord a => Ord (Concrete a)

Methods

compare :: Concrete a -> Concrete a -> Ordering

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

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

(>) :: Concrete a -> Concrete a -> Bool

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

max :: Concrete a -> Concrete a -> Concrete a

min :: Concrete a -> Concrete a -> Concrete a

Read a => Read (Concrete a)

Methods

readsPrec :: Int -> ReadS (Concrete a)

readList :: ReadS [Concrete a]

readPrec :: ReadPrec (Concrete a)

readListPrec :: ReadPrec [Concrete a]

Show a => Show (Concrete a)

Methods

showsPrec :: Int -> Concrete a -> ShowS

show :: Concrete a -> String

showList :: [Concrete a] -> ShowS

newtype Var

Symbolic variable names.

Constructors

Var Int

Instances

Eq Var

Methods

(==) :: Var -> Var -> Bool

(/=) :: Var -> Var -> Bool

Num Var

Methods

(+) :: Var -> Var -> Var

(-) :: Var -> Var -> Var

(*) :: Var -> Var -> Var

negate :: Var -> Var

abs :: Var -> Var

signum :: Var -> Var

fromInteger :: Integer -> Var

Ord Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

(<=) :: Var -> Var -> Bool

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

Read Var

Methods

readsPrec :: Int -> ReadS Var

readList :: ReadS [Var]

readPrec :: ReadPrec Var

readListPrec :: ReadPrec [Var]

Show Var

Methods

showsPrec :: Int -> Var -> ShowS

show :: Var -> String

showList :: [Var] -> ShowS