Savage

Documentation

type Gen = GenT Identity

Generator for random values of a.

data GenT m a

Monad transformer which can generate random values of a.

Instances

MMonad GenT

Methods

embed :: Monad n => (forall a. m a -> GenT n a) -> GenT m b -> GenT n b

MonadTrans GenT

Methods

lift :: Monad m => m a -> GenT m a

Distributive GenT

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (GenT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f GenT m => GenT (f m) a -> f (GenT m) a

MonadBase b m => MonadBase b (GenT m)

Methods

liftBase :: b α -> GenT m α

MonadError e m => MonadError e (GenT m)

Methods

throwError :: e -> GenT m a

catchError :: GenT m a -> (e -> GenT m a) -> GenT m a

MonadReader r m => MonadReader r (GenT m)

Methods

ask :: GenT m r

local :: (r -> r) -> GenT m a -> GenT m a

reader :: (r -> a) -> GenT m a

MonadState s m => MonadState s (GenT m)

Methods

get :: GenT m s

put :: s -> GenT m ()

state :: (s -> (a, s)) -> GenT m a

MonadWriter w m => MonadWriter w (GenT m)

Methods

writer :: (a, w) -> GenT m a

tell :: w -> GenT m ()

listen :: GenT m a -> GenT m (a, w)

pass :: GenT m (a, w -> w) -> GenT m a

Monad m => Monad (GenT m)

Methods

(>>=) :: GenT m a -> (a -> GenT m b) -> GenT m b

(>>) :: GenT m a -> GenT m b -> GenT m b

return :: a -> GenT m a

fail :: String -> GenT m a

Functor m => Functor (GenT m)

Methods

fmap :: (a -> b) -> GenT m a -> GenT m b

(<$) :: a -> GenT m b -> GenT m a

Monad m => Applicative (GenT m)

Methods

pure :: a -> GenT m a

(<*>) :: GenT m (a -> b) -> GenT m a -> GenT m b

(*>) :: GenT m a -> GenT m b -> GenT m b

(<*) :: GenT m a -> GenT m b -> GenT m a

MonadIO m => MonadIO (GenT m)

Methods

liftIO :: IO a -> GenT m a

Monad m => Alternative (GenT m)

Methods

empty :: GenT m a

(<|>) :: GenT m a -> GenT m a -> GenT m a

some :: GenT m a -> GenT m [a]

many :: GenT m a -> GenT m [a]

Monad m => MonadPlus (GenT m)

Methods

mzero :: GenT m a

mplus :: GenT m a -> GenT m a -> GenT m a

MonadCatch m => MonadCatch (GenT m)

Methods

catch :: Exception e => GenT m a -> (e -> GenT m a) -> GenT m a

MonadThrow m => MonadThrow (GenT m)

Methods

throwM :: Exception e => e -> GenT m a

PrimMonad m => PrimMonad (GenT m)

Associated Types

type PrimState (GenT m :: * -> *) :: *

Methods

primitive :: (State# (PrimState (GenT m)) -> (#VoidRep, PtrRepLifted, State# (PrimState (GenT m)), a#)) -> GenT m a

MonadResource m => MonadResource (GenT m)

Methods

liftResourceT :: ResourceT IO a -> GenT m a

Monad m => MonadGen (GenT m)

Methods

liftGen :: Gen a -> GenT m a

shrinkGen :: (a -> [a]) -> GenT m a -> GenT m a

pruneGen :: GenT m a -> GenT m a

scaleGen :: (Size -> Size) -> GenT m a -> GenT m a

freezeGen :: GenT m a -> GenT m (a, GenT m a)

MFunctor * GenT

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

type Transformer t GenT m

type Transformer t GenT m = (Monad (t (GenT m)), Transformer t MaybeT m, Transformer t Tree (MaybeT m))

type PrimState (GenT m)

type PrimState (GenT m) = PrimState m

class Monad m => MonadGen m where

Class of monads which can generate input data for tests.

The functions on this class can, and should, be used without their Gen suffix by importing Hedgehog.Gen qualified.

Minimal complete definition

liftGen, shrinkGen, pruneGen, scaleGen, freezeGen

Methods

liftGen :: Gen a -> m a

See Gen.lift

shrinkGen :: (a -> [a]) -> m a -> m a

See Gen.shrink

pruneGen :: m a -> m a

See Gen.prune

scaleGen :: (Size -> Size) -> m a -> m a

See Gen.scale

freezeGen :: m a -> m (a, m a)

See Gen.freeze

Instances

MonadGen m => MonadGen (MaybeT m)

Methods

liftGen :: Gen a -> MaybeT m a

shrinkGen :: (a -> [a]) -> MaybeT m a -> MaybeT m a

pruneGen :: MaybeT m a -> MaybeT m a

scaleGen :: (Size -> Size) -> MaybeT m a -> MaybeT m a

freezeGen :: MaybeT m a -> MaybeT m (a, MaybeT m a)

Monad m => MonadGen (GenT m)

Methods

liftGen :: Gen a -> GenT m a

shrinkGen :: (a -> [a]) -> GenT m a -> GenT m a

pruneGen :: GenT m a -> GenT m a

scaleGen :: (Size -> Size) -> GenT m a -> GenT m a

freezeGen :: GenT m a -> GenT m (a, GenT m a)

(MonadGen m, Monoid w) => MonadGen (WriterT w m)

Methods

liftGen :: Gen a -> WriterT w m a

shrinkGen :: (a -> [a]) -> WriterT w m a -> WriterT w m a

pruneGen :: WriterT w m a -> WriterT w m a

scaleGen :: (Size -> Size) -> WriterT w m a -> WriterT w m a

freezeGen :: WriterT w m a -> WriterT w m (a, WriterT w m a)

MonadGen m => MonadGen (StateT s m)

Methods

liftGen :: Gen a -> StateT s m a

shrinkGen :: (a -> [a]) -> StateT s m a -> StateT s m a

pruneGen :: StateT s m a -> StateT s m a

scaleGen :: (Size -> Size) -> StateT s m a -> StateT s m a

freezeGen :: StateT s m a -> StateT s m (a, StateT s m a)

MonadGen m => MonadGen (ExceptT x m)

Methods

liftGen :: Gen a -> ExceptT x m a

shrinkGen :: (a -> [a]) -> ExceptT x m a -> ExceptT x m a

pruneGen :: ExceptT x m a -> ExceptT x m a

scaleGen :: (Size -> Size) -> ExceptT x m a -> ExceptT x m a

freezeGen :: ExceptT x m a -> ExceptT x m (a, ExceptT x m a)

MonadGen m => MonadGen (IdentityT * m)

Methods

liftGen :: Gen a -> IdentityT * m a

shrinkGen :: (a -> [a]) -> IdentityT * m a -> IdentityT * m a

pruneGen :: IdentityT * m a -> IdentityT * m a

scaleGen :: (Size -> Size) -> IdentityT * m a -> IdentityT * m a

freezeGen :: IdentityT * m a -> IdentityT * m (a, IdentityT * m a)

MonadGen m => MonadGen (StateT s m)

Methods

liftGen :: Gen a -> StateT s m a

shrinkGen :: (a -> [a]) -> StateT s m a -> StateT s m a

pruneGen :: StateT s m a -> StateT s m a

scaleGen :: (Size -> Size) -> StateT s m a -> StateT s m a

freezeGen :: StateT s m a -> StateT s m (a, StateT s m a)

(MonadGen m, Monoid w) => MonadGen (WriterT w m)

Methods

liftGen :: Gen a -> WriterT w m a

shrinkGen :: (a -> [a]) -> WriterT w m a -> WriterT w m a

pruneGen :: WriterT w m a -> WriterT w m a

scaleGen :: (Size -> Size) -> WriterT w m a -> WriterT w m a

freezeGen :: WriterT w m a -> WriterT w m (a, WriterT w m a)

MonadGen m => MonadGen (ReaderT * r m)

Methods

liftGen :: Gen a -> ReaderT * r m a

shrinkGen :: (a -> [a]) -> ReaderT * r m a -> ReaderT * r m a

pruneGen :: ReaderT * r m a -> ReaderT * r m a

scaleGen :: (Size -> Size) -> ReaderT * r m a -> ReaderT * r m a

freezeGen :: ReaderT * r m a -> ReaderT * r m (a, ReaderT * r m a)

(MonadGen m, Monoid w) => MonadGen (RWST r w s m)

Methods

liftGen :: Gen a -> RWST r w s m a

shrinkGen :: (a -> [a]) -> RWST r w s m a -> RWST r w s m a

pruneGen :: RWST r w s m a -> RWST r w s m a

scaleGen :: (Size -> Size) -> RWST r w s m a -> RWST r w s m a

freezeGen :: RWST r w s m a -> RWST r w s m (a, RWST r w s m a)

(MonadGen m, Monoid w) => MonadGen (RWST r w s m)

Methods

liftGen :: Gen a -> RWST r w s m a

shrinkGen :: (a -> [a]) -> RWST r w s m a -> RWST r w s m a

pruneGen :: RWST r w s m a -> RWST r w s m a

scaleGen :: (Size -> Size) -> RWST r w s m a -> RWST r w s m a

freezeGen :: RWST r w s m a -> RWST r w s m (a, RWST r w s m a)

data Range a

A range describes the bounds of a number to generate, which may or may not be dependent on a Size.

Instances

Functor Range

Methods

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

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

newtype Size

Tests are parameterized by the size of the randomly-generated data, the meaning of which depends on the particular generator used.

Constructors

Size

Fields

• unSize :: Int

Instances

Enum Size

Methods

succ :: Size -> Size

pred :: Size -> Size

toEnum :: Int -> Size

fromEnum :: Size -> Int

enumFrom :: Size -> [Size]

enumFromThen :: Size -> Size -> [Size]

enumFromTo :: Size -> Size -> [Size]

enumFromThenTo :: Size -> Size -> Size -> [Size]

Eq Size

Methods

(==) :: Size -> Size -> Bool

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

Integral Size

Methods

quot :: Size -> Size -> Size

rem :: Size -> Size -> Size

div :: Size -> Size -> Size

mod :: Size -> Size -> Size

quotRem :: Size -> Size -> (Size, Size)

divMod :: Size -> Size -> (Size, Size)

toInteger :: Size -> Integer

Num Size

Methods

(+) :: Size -> Size -> Size

(-) :: Size -> Size -> Size

(*) :: Size -> Size -> Size

negate :: Size -> Size

abs :: Size -> Size

signum :: Size -> Size

fromInteger :: Integer -> Size

Ord Size

Methods

compare :: Size -> Size -> Ordering

(<) :: Size -> Size -> Bool

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

(>) :: Size -> Size -> Bool

(>=) :: Size -> Size -> Bool

max :: Size -> Size -> Size

min :: Size -> Size -> Size

Read Size

Methods

readsPrec :: Int -> ReadS Size

readList :: ReadS [Size]

readPrec :: ReadPrec Size

readListPrec :: ReadPrec [Size]

Real Size

Methods

toRational :: Size -> Rational

Show Size

Methods

showsPrec :: Int -> Size -> ShowS

show :: Size -> String

showList :: [Size] -> ShowS

data Seed

A splittable random number generator.

Constructors

Seed

Fields

• seedValue :: !Int64
• seedGamma :: !Int64

  must be an odd number

Instances

Eq Seed

Methods

(==) :: Seed -> Seed -> Bool

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

Ord Seed

Methods

compare :: Seed -> Seed -> Ordering

(<) :: Seed -> Seed -> Bool

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

(>) :: Seed -> Seed -> Bool

(>=) :: Seed -> Seed -> Bool

max :: Seed -> Seed -> Seed

min :: Seed -> Seed -> Seed

Read Seed

Methods

readsPrec :: Int -> ReadS Seed

readList :: ReadS [Seed]

readPrec :: ReadPrec Seed

readListPrec :: ReadPrec [Seed]

Show Seed

Methods

showsPrec :: Int -> Seed -> ShowS

show :: Seed -> String

showList :: [Seed] -> ShowS

RandomGen Seed

Methods

next :: Seed -> (Int, Seed)

genRange :: Seed -> (Int, Int)

split :: Seed -> (Seed, Seed)

class Distributive g where

Minimal complete definition

distribute

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (g :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f g m => g (f m) a -> f (g m) a

Distribute one monad transformer over another.

Instances

Distributive MaybeT

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (MaybeT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f MaybeT m => MaybeT (f m) a -> f (MaybeT m) a

Distributive Tree

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (Tree :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f Tree m => Tree (f m) a -> f (Tree m) a

Distributive GenT

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (GenT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f GenT m => GenT (f m) a -> f (GenT m) a

Monoid w => Distributive (WriterT w)

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (WriterT w :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f (WriterT w) m => WriterT w (f m) a -> f (WriterT w m) a

Distributive (ExceptT x)

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (ExceptT x :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f (ExceptT x) m => ExceptT x (f m) a -> f (ExceptT x m) a

Distributive (ReaderT * r)

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (ReaderT * r :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint

Methods

distribute :: Transformer f (ReaderT * r) m => ReaderT * r (f m) a -> f (ReaderT * r m) a