Safe Haskell	None
Language	GHC2021

Polysemy.Test.Hedgehog

Description

Hedgehog interpreters, internal

Synopsis

interpretHedgehog :: forall (m :: Type -> Type) (r :: EffectRow). Member (Embed (TestT m)) r => InterpreterFor (Hedgehog m) r
rewriteHedgehog :: forall (m :: Type -> Type) (r :: EffectRow). Members '[Error Failure :: (Type -> Type) -> Type -> Type, Writer Journal, Embed m] r => InterpreterFor (Hedgehog m) r
assert :: forall (m :: Type -> Type) (r :: EffectRow). (Monad m, HasCallStack, Member (Hedgehog m) r) => Bool -> Sem r ()
(===) :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r ()
assertEq :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r ()
(/==) :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r ()
assertNeq :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r ()
evalEither :: forall a (m :: Type -> Type) e (r :: EffectRow). (Show e, Monad m, HasCallStack, Member (Hedgehog m) r) => Either e a -> Sem r a
assertRight :: forall a (m :: Type -> Type) e (r :: EffectRow). (Eq a, Show e, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e a -> Sem r ()
assertRight2 :: forall a (m :: Type -> Type) e1 e2 (r :: EffectRow). (Eq a, Show e1, Show e2, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e1 (Either e2 a) -> Sem r ()
assertRight3 :: forall a (m :: Type -> Type) e1 e2 e3 (r :: EffectRow). (Eq a, Show e1, Show e2, Show e3, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e1 (Either e2 (Either e3 a)) -> Sem r ()
evalLeft :: forall a (m :: Type -> Type) e (r :: EffectRow). (Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => Either e a -> Sem r e
assertLeft :: forall a (m :: Type -> Type) e (r :: EffectRow). (Eq e, Show e, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => e -> Either e a -> Sem r ()
evalMaybe :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, HasCallStack, Member (Hedgehog m) r) => Maybe a -> Sem r a
assertJust :: forall a (m :: Type -> Type) (r :: EffectRow). (Eq a, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Maybe a -> Sem r ()
evalError :: forall e a (m :: Type -> Type) (r :: EffectRow). (Show e, Monad m, HasCallStack, Member (Hedgehog m) r) => Sem ((Error e :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a
assertCloseBy :: forall a (m :: Type -> Type) (r :: EffectRow). (Num a, Ord a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> a -> a -> Sem r ()
assertClose :: forall a (m :: Type -> Type) (r :: EffectRow). (Ord a, Fractional a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r ()

Documentation

interpretHedgehog :: forall (m :: Type -> Type) (r :: EffectRow). Member (Embed (TestT m)) r => InterpreterFor (Hedgehog m) r Source #

Interpret Hedgehog into TestT IO by simple embedding of the native combinators.

rewriteHedgehog :: forall (m :: Type -> Type) (r :: EffectRow). Members '[Error Failure :: (Type -> Type) -> Type -> Type, Writer Journal, Embed m] r => InterpreterFor (Hedgehog m) r Source #

Interpret Hedgehog in terms of Error Failure and Writer Journal, which correspond to the monad stack wrapped by TestT.

assert :: forall (m :: Type -> Type) (r :: EffectRow). (Monad m, HasCallStack, Member (Hedgehog m) r) => Bool -> Sem r () Source #

Embeds assert.

(===) :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r () infix 4 Source #

Embeds ===.

>>> 5 === 6
5 === 6
^^^^^^^
│ ━━━ Failed (- lhs) (+ rhs) ━━━
│ - 5
│ + 6

assertEq :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r () Source #

Prefix variant of (===).

(/==) :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r () infix 4 Source #

Embeds /==.

>>> 5 /== 5
5 /== 5
^^^^^^^
│ ━━━ Failed (no differences) ━━━
│ 5

assertNeq :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, Eq a, Show a, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r () Source #

Prefix variant of (/==).

evalEither :: forall a (m :: Type -> Type) e (r :: EffectRow). (Show e, Monad m, HasCallStack, Member (Hedgehog m) r) => Either e a -> Sem r a Source #

Embeds evalEither.

assertRight :: forall a (m :: Type -> Type) e (r :: EffectRow). (Eq a, Show e, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e a -> Sem r () Source #

Given a reference value, unpacks an Either with evalEither and applies === to the result in the Right case, and produces a test failure in the Left case.

assertRight2 :: forall a (m :: Type -> Type) e1 e2 (r :: EffectRow). (Eq a, Show e1, Show e2, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e1 (Either e2 a) -> Sem r () Source #

Like assertRight, but for two nested Eithers.

assertRight3 :: forall a (m :: Type -> Type) e1 e2 e3 (r :: EffectRow). (Eq a, Show e1, Show e2, Show e3, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Either e1 (Either e2 (Either e3 a)) -> Sem r () Source #

Like assertRight, but for three nested Eithers.

evalLeft :: forall a (m :: Type -> Type) e (r :: EffectRow). (Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => Either e a -> Sem r e Source #

Like evalEither, but for Left.

assertLeft :: forall a (m :: Type -> Type) e (r :: EffectRow). (Eq e, Show e, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => e -> Either e a -> Sem r () Source #

Like assertRight, but for Left.

evalMaybe :: forall a (m :: Type -> Type) (r :: EffectRow). (Monad m, HasCallStack, Member (Hedgehog m) r) => Maybe a -> Sem r a Source #

Like evalEither, but for Maybe.

assertJust :: forall a (m :: Type -> Type) (r :: EffectRow). (Eq a, Show a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> Maybe a -> Sem r () Source #

Given a reference value, asserts that the scrutinee is Just and its contained value matches the target.

evalError :: forall e a (m :: Type -> Type) (r :: EffectRow). (Show e, Monad m, HasCallStack, Member (Hedgehog m) r) => Sem ((Error e :: (Type -> Type) -> Type -> Type) ': r) a -> Sem r a Source #

Run a Polysemy Error effect and assert its result.

assertCloseBy :: forall a (m :: Type -> Type) (r :: EffectRow). (Num a, Ord a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> a -> a -> Sem r () Source #

Assert that two numeric values are closer to each other than the specified delta.

assertClose :: forall a (m :: Type -> Type) (r :: EffectRow). (Ord a, Fractional a, Monad m, HasCallStack, Member (Hedgehog m) r) => a -> a -> Sem r () Source #

Assert that two fractional values are closer to each other than 0.001.