Copyright	(c) Michal Konecny
License	BSD3
Maintainer	mikkonecny@gmail.com
Stability	experimental
Portability	portable
Safe Haskell	None
Language	Haskell2010

Numeric.MixedTypes.Eq

Contents

Equality checks
- Tests
- Specific comparisons

Description

Synopsis

type HasEq t1 t2 = (HasEqAsymmetric t1 t2, HasEqAsymmetric t2 t1, EqCompareType t1 t2 ~ EqCompareType t2 t1)
class IsBool (EqCompareType a b) => HasEqAsymmetric a b where
- type EqCompareType a b
- equalTo :: a -> b -> EqCompareType a b
- notEqualTo :: a -> b -> EqCompareType a b
(==) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b
(/=) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b
type HasEqCertainly t1 t2 = (HasEq t1 t2, CanTestCertainly (EqCompareType t1 t2))
type HasEqCertainlyAsymmetric t1 t2 = (HasEqAsymmetric t1 t2, CanTestCertainly (EqCompareType t1 t2))
notCertainlyDifferentFrom :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
certainlyEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
certainlyNotEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
(?==?) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
(!==!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
(!/=!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool
specHasEq :: _ => T t1 -> T t2 -> T t3 -> Spec
specHasEqNotMixed :: _ => T t -> Spec
specConversion :: (Arbitrary t1, Show t1, HasEqCertainly t1 t1) => T t1 -> T t2 -> (t1 -> t2) -> (t2 -> t1) -> Spec
class CanTestValid t where
- isValid :: t -> Bool
specResultIsValid1 :: (Arbitrary t1, Show t1, CanTestValid t1, CanTestValid t2) => (t1 -> t2) -> String -> T t1 -> Spec
specResultIsValid2 :: (Arbitrary t1, Show t1, Arbitrary t2, Show t2, CanTestValid t1, CanTestValid t2, CanTestValid t3) => (t1 -> t2 -> t3) -> String -> T t1 -> T t2 -> Spec
specResultIsValid1Pre :: (Arbitrary t1, Show t1, CanTestValid t1, CanTestValid t2) => (t1 -> Bool) -> (t1 -> t2) -> String -> T t1 -> Spec
specResultIsValid2Pre :: (Arbitrary t1, Show t1, Arbitrary t2, Show t2, CanTestValid t1, CanTestValid t2, CanTestValid t3) => (t1 -> t2 -> Bool) -> (t1 -> t2 -> t3) -> String -> T t1 -> T t2 -> Spec
class CanTestNaN t where
- isNaN :: t -> Bool
class CanTestFinite t where
- isInfinite :: t -> Bool
- isFinite :: t -> Bool
class CanTestInteger t where
- certainlyNotInteger :: t -> Bool
- certainlyInteger :: t -> Bool
- certainlyIntegerGetIt :: t -> Maybe Integer
class CanTestZero t where
- isCertainlyZero :: t -> Bool
- isCertainlyNonZero :: t -> Bool
specCanTestZero :: (CanTestZero t, ConvertibleExactly Integer t) => T t -> Spec
class CanPickNonZero t where
- pickNonZero :: [(t, s)] -> Maybe (t, s)
specCanPickNonZero :: (CanPickNonZero t, CanTestZero t, ConvertibleExactly Integer t, Show t, Arbitrary t) => T t -> Spec

Equality checks

type HasEq t1 t2 = (HasEqAsymmetric t1 t2, HasEqAsymmetric t2 t1, EqCompareType t1 t2 ~ EqCompareType t2 t1) Source #

class IsBool (EqCompareType a b) => HasEqAsymmetric a b where Source #

Minimal complete definition

Nothing

Associated Types

type EqCompareType a b Source #

type EqCompareType a b = Bool

Methods

equalTo :: a -> b -> EqCompareType a b Source #

default equalTo :: (EqCompareType a b ~ Bool, a ~ b, Eq a) => a -> b -> EqCompareType a b Source #

notEqualTo :: a -> b -> EqCompareType a b Source #

default notEqualTo :: CanNegSameType (EqCompareType a b) => a -> b -> EqCompareType a b Source #

Instances

Instances details

HasEqAsymmetric Bool Bool Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Bool Bool Source # Methods equalTo :: Bool -> Bool -> EqCompareType Bool Bool Source # notEqualTo :: Bool -> Bool -> EqCompareType Bool Bool Source #
HasEqAsymmetric Char Char Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Char Char Source # Methods equalTo :: Char -> Char -> EqCompareType Char Char Source # notEqualTo :: Char -> Char -> EqCompareType Char Char Source #
HasEqAsymmetric Double Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Double Double Source # Methods equalTo :: Double -> Double -> EqCompareType Double Double Source # notEqualTo :: Double -> Double -> EqCompareType Double Double Source #
HasEqAsymmetric Double Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Double Int Source # Methods equalTo :: Double -> Int -> EqCompareType Double Int Source # notEqualTo :: Double -> Int -> EqCompareType Double Int Source #
HasEqAsymmetric Double Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Double Integer Source # Methods equalTo :: Double -> Integer -> EqCompareType Double Integer Source # notEqualTo :: Double -> Integer -> EqCompareType Double Integer Source #
HasEqAsymmetric Int Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Int Double Source # Methods equalTo :: Int -> Double -> EqCompareType Int Double Source # notEqualTo :: Int -> Double -> EqCompareType Int Double Source #
HasEqAsymmetric Int Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Int Int Source # Methods equalTo :: Int -> Int -> EqCompareType Int Int Source # notEqualTo :: Int -> Int -> EqCompareType Int Int Source #
HasEqAsymmetric Int Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Int Integer Source # Methods equalTo :: Int -> Integer -> EqCompareType Int Integer Source # notEqualTo :: Int -> Integer -> EqCompareType Int Integer Source #
HasEqAsymmetric Int Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Int Rational Source # Methods equalTo :: Int -> Rational -> EqCompareType Int Rational Source # notEqualTo :: Int -> Rational -> EqCompareType Int Rational Source #
HasEqAsymmetric Integer Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Integer Double Source # Methods equalTo :: Integer -> Double -> EqCompareType Integer Double Source # notEqualTo :: Integer -> Double -> EqCompareType Integer Double Source #
HasEqAsymmetric Integer Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Integer Int Source # Methods equalTo :: Integer -> Int -> EqCompareType Integer Int Source # notEqualTo :: Integer -> Int -> EqCompareType Integer Int Source #
HasEqAsymmetric Integer Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Integer Integer Source # Methods equalTo :: Integer -> Integer -> EqCompareType Integer Integer Source # notEqualTo :: Integer -> Integer -> EqCompareType Integer Integer Source #
HasEqAsymmetric Integer Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Integer Rational Source # Methods equalTo :: Integer -> Rational -> EqCompareType Integer Rational Source # notEqualTo :: Integer -> Rational -> EqCompareType Integer Rational Source #
HasEqAsymmetric Rational Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Rational Int Source # Methods equalTo :: Rational -> Int -> EqCompareType Rational Int Source # notEqualTo :: Rational -> Int -> EqCompareType Rational Int Source #
HasEqAsymmetric Rational Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Rational Integer Source # Methods equalTo :: Rational -> Integer -> EqCompareType Rational Integer Source # notEqualTo :: Rational -> Integer -> EqCompareType Rational Integer Source #
HasEqAsymmetric Rational Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Rational Rational Source # Methods equalTo :: Rational -> Rational -> EqCompareType Rational Rational Source # notEqualTo :: Rational -> Rational -> EqCompareType Rational Rational Source #
HasEqAsymmetric () () Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType () () Source # Methods equalTo :: () -> () -> EqCompareType () () Source # notEqualTo :: () -> () -> EqCompareType () () Source #
HasEqAsymmetric Double b => HasEqAsymmetric Double (Complex b) Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType Double (Complex b) Source # Methods equalTo :: Double -> Complex b -> EqCompareType Double (Complex b) Source # notEqualTo :: Double -> Complex b -> EqCompareType Double (Complex b) Source #
HasEqAsymmetric Int b => HasEqAsymmetric Int (Complex b) Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType Int (Complex b) Source # Methods equalTo :: Int -> Complex b -> EqCompareType Int (Complex b) Source # notEqualTo :: Int -> Complex b -> EqCompareType Int (Complex b) Source #
HasEqAsymmetric Integer b => HasEqAsymmetric Integer (Complex b) Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType Integer (Complex b) Source # Methods equalTo :: Integer -> Complex b -> EqCompareType Integer (Complex b) Source # notEqualTo :: Integer -> Complex b -> EqCompareType Integer (Complex b) Source #
HasEqAsymmetric Rational b => HasEqAsymmetric Rational (Complex b) Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType Rational (Complex b) Source # Methods equalTo :: Rational -> Complex b -> EqCompareType Rational (Complex b) Source # notEqualTo :: Rational -> Complex b -> EqCompareType Rational (Complex b) Source #
(HasEqAsymmetric Bool b, CanBeErrors es, CanTestCertainly (EqCompareType Bool b)) => HasEqAsymmetric Bool (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Bool (CollectErrors es b) Source # Methods equalTo :: Bool -> CollectErrors es b -> EqCompareType Bool (CollectErrors es b) Source # notEqualTo :: Bool -> CollectErrors es b -> EqCompareType Bool (CollectErrors es b) Source #
(HasEqAsymmetric Double b, CanBeErrors es, CanTestCertainly (EqCompareType Double b)) => HasEqAsymmetric Double (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Double (CollectErrors es b) Source # Methods equalTo :: Double -> CollectErrors es b -> EqCompareType Double (CollectErrors es b) Source # notEqualTo :: Double -> CollectErrors es b -> EqCompareType Double (CollectErrors es b) Source #
(HasEqAsymmetric Int b, CanBeErrors es, CanTestCertainly (EqCompareType Int b)) => HasEqAsymmetric Int (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Int (CollectErrors es b) Source # Methods equalTo :: Int -> CollectErrors es b -> EqCompareType Int (CollectErrors es b) Source # notEqualTo :: Int -> CollectErrors es b -> EqCompareType Int (CollectErrors es b) Source #
(HasEqAsymmetric Integer b, CanBeErrors es, CanTestCertainly (EqCompareType Integer b)) => HasEqAsymmetric Integer (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Integer (CollectErrors es b) Source # Methods equalTo :: Integer -> CollectErrors es b -> EqCompareType Integer (CollectErrors es b) Source # notEqualTo :: Integer -> CollectErrors es b -> EqCompareType Integer (CollectErrors es b) Source #
(HasEqAsymmetric Rational b, CanBeErrors es, CanTestCertainly (EqCompareType Rational b)) => HasEqAsymmetric Rational (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType Rational (CollectErrors es b) Source # Methods equalTo :: Rational -> CollectErrors es b -> EqCompareType Rational (CollectErrors es b) Source # notEqualTo :: Rational -> CollectErrors es b -> EqCompareType Rational (CollectErrors es b) Source #
HasEqAsymmetric a Integer => HasEqAsymmetric (Complex a) Integer Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType (Complex a) Integer Source # Methods equalTo :: Complex a -> Integer -> EqCompareType (Complex a) Integer Source # notEqualTo :: Complex a -> Integer -> EqCompareType (Complex a) Integer Source #
HasEqAsymmetric a Int => HasEqAsymmetric (Complex a) Int Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType (Complex a) Int Source # Methods equalTo :: Complex a -> Int -> EqCompareType (Complex a) Int Source # notEqualTo :: Complex a -> Int -> EqCompareType (Complex a) Int Source #
HasEqAsymmetric a Rational => HasEqAsymmetric (Complex a) Rational Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType (Complex a) Rational Source # Methods equalTo :: Complex a -> Rational -> EqCompareType (Complex a) Rational Source # notEqualTo :: Complex a -> Rational -> EqCompareType (Complex a) Rational Source #
HasEqAsymmetric a Double => HasEqAsymmetric (Complex a) Double Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType (Complex a) Double Source # Methods equalTo :: Complex a -> Double -> EqCompareType (Complex a) Double Source # notEqualTo :: Complex a -> Double -> EqCompareType (Complex a) Double Source #
HasEqAsymmetric a b => HasEqAsymmetric [a] [b] Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType [a] [b] Source # Methods equalTo :: [a] -> [b] -> EqCompareType [a] [b] Source # notEqualTo :: [a] -> [b] -> EqCompareType [a] [b] Source #
HasEqAsymmetric a b => HasEqAsymmetric (Maybe a) (Maybe b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (Maybe a) (Maybe b) Source # Methods equalTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b) Source # notEqualTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b) Source #
HasEqAsymmetric a b => HasEqAsymmetric (Complex a) (Complex b) Source #
Instance details Defined in Numeric.MixedTypes.Complex Associated Types type EqCompareType (Complex a) (Complex b) Source # Methods equalTo :: Complex a -> Complex b -> EqCompareType (Complex a) (Complex b) Source # notEqualTo :: Complex a -> Complex b -> EqCompareType (Complex a) (Complex b) Source #
(HasEqAsymmetric (Maybe Bool) b, CanBeErrors es, CanTestCertainly (EqCompareType (Maybe Bool) b)) => HasEqAsymmetric (Maybe Bool) (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (Maybe Bool) (CollectErrors es b) Source # Methods equalTo :: Maybe Bool -> CollectErrors es b -> EqCompareType (Maybe Bool) (CollectErrors es b) Source # notEqualTo :: Maybe Bool -> CollectErrors es b -> EqCompareType (Maybe Bool) (CollectErrors es b) Source #
(HasEqAsymmetric a Bool, CanBeErrors es, CanTestCertainly (EqCompareType a Bool)) => HasEqAsymmetric (CollectErrors es a) Bool Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) Bool Source # Methods equalTo :: CollectErrors es a -> Bool -> EqCompareType (CollectErrors es a) Bool Source # notEqualTo :: CollectErrors es a -> Bool -> EqCompareType (CollectErrors es a) Bool Source #
(HasEqAsymmetric a Integer, CanBeErrors es, CanTestCertainly (EqCompareType a Integer)) => HasEqAsymmetric (CollectErrors es a) Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) Integer Source # Methods equalTo :: CollectErrors es a -> Integer -> EqCompareType (CollectErrors es a) Integer Source # notEqualTo :: CollectErrors es a -> Integer -> EqCompareType (CollectErrors es a) Integer Source #
(HasEqAsymmetric a Int, CanBeErrors es, CanTestCertainly (EqCompareType a Int)) => HasEqAsymmetric (CollectErrors es a) Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) Int Source # Methods equalTo :: CollectErrors es a -> Int -> EqCompareType (CollectErrors es a) Int Source # notEqualTo :: CollectErrors es a -> Int -> EqCompareType (CollectErrors es a) Int Source #
(HasEqAsymmetric a Rational, CanBeErrors es, CanTestCertainly (EqCompareType a Rational)) => HasEqAsymmetric (CollectErrors es a) Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) Rational Source # Methods equalTo :: CollectErrors es a -> Rational -> EqCompareType (CollectErrors es a) Rational Source # notEqualTo :: CollectErrors es a -> Rational -> EqCompareType (CollectErrors es a) Rational Source #
(HasEqAsymmetric a Double, CanBeErrors es, CanTestCertainly (EqCompareType a Double)) => HasEqAsymmetric (CollectErrors es a) Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) Double Source # Methods equalTo :: CollectErrors es a -> Double -> EqCompareType (CollectErrors es a) Double Source # notEqualTo :: CollectErrors es a -> Double -> EqCompareType (CollectErrors es a) Double Source #
(HasEqAsymmetric a (Maybe Bool), CanBeErrors es, CanTestCertainly (EqCompareType a (Maybe Bool))) => HasEqAsymmetric (CollectErrors es a) (Maybe Bool) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) (Maybe Bool) Source # Methods equalTo :: CollectErrors es a -> Maybe Bool -> EqCompareType (CollectErrors es a) (Maybe Bool) Source # notEqualTo :: CollectErrors es a -> Maybe Bool -> EqCompareType (CollectErrors es a) (Maybe Bool) Source #
(HasEqAsymmetric a1 b1, HasEqAsymmetric a2 b2, CanAndOrAsymmetric (EqCompareType a1 b1) (EqCompareType a2 b2), IsBool (AndOrType (EqCompareType a1 b1) (EqCompareType a2 b2))) => HasEqAsymmetric (a1, a2) (b1, b2) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (a1, a2) (b1, b2) Source # Methods equalTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2) Source # notEqualTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2) Source #
(HasEqAsymmetric a b, CanBeErrors es, CanTestCertainly (EqCompareType a b)) => HasEqAsymmetric (CollectErrors es a) (CollectErrors es b) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (CollectErrors es a) (CollectErrors es b) Source # Methods equalTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b) Source # notEqualTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b) Source #
HasEqAsymmetric ((a1, a2), a3) ((b1, b2), b3) => HasEqAsymmetric (a1, a2, a3) (b1, b2, b3) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (a1, a2, a3) (b1, b2, b3) Source # Methods equalTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3) Source # notEqualTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3) Source #
HasEqAsymmetric ((a1, a2, a3), a4) ((b1, b2, b3), b4) => HasEqAsymmetric (a1, a2, a3, a4) (b1, b2, b3, b4) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4) Source # Methods equalTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4) Source # notEqualTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4) Source #
HasEqAsymmetric ((a1, a2, a3, a4), a5) ((b1, b2, b3, b4), b5) => HasEqAsymmetric (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) Source #
Instance details Defined in Numeric.MixedTypes.Eq Associated Types type EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) Source # Methods equalTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) Source # notEqualTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) Source #

(==) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b infix 4 Source #

(/=) :: HasEqAsymmetric a b => a -> b -> EqCompareType a b infix 4 Source #

type HasEqCertainly t1 t2 = (HasEq t1 t2, CanTestCertainly (EqCompareType t1 t2)) Source #

type HasEqCertainlyAsymmetric t1 t2 = (HasEqAsymmetric t1 t2, CanTestCertainly (EqCompareType t1 t2)) Source #

notCertainlyDifferentFrom :: HasEqCertainlyAsymmetric a b => a -> b -> Bool Source #

certainlyEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool Source #

certainlyNotEqualTo :: HasEqCertainlyAsymmetric a b => a -> b -> Bool Source #

(?==?) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4 Source #

(!==!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4 Source #

(!/=!) :: HasEqCertainlyAsymmetric a b => a -> b -> Bool infix 4 Source #

Tests

specHasEq :: _ => T t1 -> T t2 -> T t3 -> Spec Source #

HSpec properties that each implementation of HasEq should satisfy.

specHasEqNotMixed :: _ => T t -> Spec Source #

HSpec properties that each implementation of HasEq should satisfy.

specConversion :: (Arbitrary t1, Show t1, HasEqCertainly t1 t1) => T t1 -> T t2 -> (t1 -> t2) -> (t2 -> t1) -> Spec Source #

HSpec property of there-and-back conversion.

Specific comparisons

class CanTestValid t where Source #

Methods

isValid :: t -> Bool Source #

specResultIsValid1 :: (Arbitrary t1, Show t1, CanTestValid t1, CanTestValid t2) => (t1 -> t2) -> String -> T t1 -> Spec Source #

HSpec property checking the validity of unary operations' results.

specResultIsValid2 :: (Arbitrary t1, Show t1, Arbitrary t2, Show t2, CanTestValid t1, CanTestValid t2, CanTestValid t3) => (t1 -> t2 -> t3) -> String -> T t1 -> T t2 -> Spec Source #

HSpec properties that check validity of operations' results.

specResultIsValid1Pre :: (Arbitrary t1, Show t1, CanTestValid t1, CanTestValid t2) => (t1 -> Bool) -> (t1 -> t2) -> String -> T t1 -> Spec Source #

specResultIsValid2Pre :: (Arbitrary t1, Show t1, Arbitrary t2, Show t2, CanTestValid t1, CanTestValid t2, CanTestValid t3) => (t1 -> t2 -> Bool) -> (t1 -> t2 -> t3) -> String -> T t1 -> T t2 -> Spec Source #

class CanTestNaN t where Source #

Minimal complete definition

Nothing

Methods

isNaN :: t -> Bool Source #

default isNaN :: RealFloat t => t -> Bool Source #

Instances

Instances details

CanTestNaN Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isNaN :: Double -> Bool Source #
CanTestNaN Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isNaN :: Integer -> Bool Source #
CanTestNaN Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isNaN :: Rational -> Bool Source #
(CanTestNaN t, CanBeErrors es) => CanTestNaN (CollectErrors es t) Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isNaN :: CollectErrors es t -> Bool Source #

class CanTestFinite t where Source #

Minimal complete definition

Nothing

Methods

isInfinite :: t -> Bool Source #

default isInfinite :: RealFloat t => t -> Bool Source #

isFinite :: t -> Bool Source #

default isFinite :: RealFloat t => t -> Bool Source #

Instances

Instances details

CanTestFinite Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isInfinite :: Double -> Bool Source # isFinite :: Double -> Bool Source #
CanTestFinite Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isInfinite :: Int -> Bool Source # isFinite :: Int -> Bool Source #
CanTestFinite Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isInfinite :: Integer -> Bool Source # isFinite :: Integer -> Bool Source #
CanTestFinite Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isInfinite :: Rational -> Bool Source # isFinite :: Rational -> Bool Source #
(CanTestFinite t, CanBeErrors es) => CanTestFinite (CollectErrors es t) Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isInfinite :: CollectErrors es t -> Bool Source # isFinite :: CollectErrors es t -> Bool Source #

class CanTestInteger t where Source #

Minimal complete definition

certainlyNotInteger, certainlyIntegerGetIt

Methods

certainlyNotInteger :: t -> Bool Source #

certainlyInteger :: t -> Bool Source #

certainlyIntegerGetIt :: t -> Maybe Integer Source #

Instances

Instances details

CanTestInteger Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods certainlyNotInteger :: Double -> Bool Source # certainlyInteger :: Double -> Bool Source # certainlyIntegerGetIt :: Double -> Maybe Integer Source #
CanTestInteger Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods certainlyNotInteger :: Int -> Bool Source # certainlyInteger :: Int -> Bool Source # certainlyIntegerGetIt :: Int -> Maybe Integer Source #
CanTestInteger Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods certainlyNotInteger :: Integer -> Bool Source # certainlyInteger :: Integer -> Bool Source # certainlyIntegerGetIt :: Integer -> Maybe Integer Source #
CanTestInteger Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods certainlyNotInteger :: Rational -> Bool Source # certainlyInteger :: Rational -> Bool Source # certainlyIntegerGetIt :: Rational -> Maybe Integer Source #
(CanTestInteger t, CanTestZero t) => CanTestInteger (Complex t) Source #
Instance details Defined in Numeric.MixedTypes.Complex Methods certainlyNotInteger :: Complex t -> Bool Source # certainlyInteger :: Complex t -> Bool Source # certainlyIntegerGetIt :: Complex t -> Maybe Integer Source #
(CanTestInteger t, CanBeErrors es) => CanTestInteger (CollectErrors es t) Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods certainlyNotInteger :: CollectErrors es t -> Bool Source # certainlyInteger :: CollectErrors es t -> Bool Source # certainlyIntegerGetIt :: CollectErrors es t -> Maybe Integer Source #

class CanTestZero t where Source #

Minimal complete definition

Nothing

Methods

isCertainlyZero :: t -> Bool Source #

default isCertainlyZero :: HasEqCertainly t Integer => t -> Bool Source #

isCertainlyNonZero :: t -> Bool Source #

default isCertainlyNonZero :: HasEqCertainly t Integer => t -> Bool Source #

Instances

Instances details

CanTestZero Double Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isCertainlyZero :: Double -> Bool Source # isCertainlyNonZero :: Double -> Bool Source #
CanTestZero Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isCertainlyZero :: Int -> Bool Source # isCertainlyNonZero :: Int -> Bool Source #
CanTestZero Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isCertainlyZero :: Integer -> Bool Source # isCertainlyNonZero :: Integer -> Bool Source #
CanTestZero Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isCertainlyZero :: Rational -> Bool Source # isCertainlyNonZero :: Rational -> Bool Source #
(CanTestZero t, CanBeErrors es) => CanTestZero (CollectErrors es t) Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods isCertainlyZero :: CollectErrors es t -> Bool Source # isCertainlyNonZero :: CollectErrors es t -> Bool Source #

specCanTestZero :: (CanTestZero t, ConvertibleExactly Integer t) => T t -> Spec Source #

HSpec properties that each implementation of CanTestZero should satisfy.

class CanPickNonZero t where Source #

Minimal complete definition

Nothing

Methods

pickNonZero :: [(t, s)] -> Maybe (t, s) Source #

Given a list [(a1,b1),(a2,b2),...] and assuming that at least one of a1,a2,... is non-zero, pick one of them and return the corresponding pair (ai,bi).

If none of a1,a2,... is zero, either throws an exception or loops forever.

The default implementation is based on a CanTestZero instance and is not parallel.

default pickNonZero :: (CanTestZero t, Show t) => [(t, s)] -> Maybe (t, s) Source #

Instances

Instances details

CanPickNonZero Int Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods pickNonZero :: [(Int, s)] -> Maybe (Int, s) Source #
CanPickNonZero Integer Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods pickNonZero :: [(Integer, s)] -> Maybe (Integer, s) Source #
CanPickNonZero Rational Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods pickNonZero :: [(Rational, s)] -> Maybe (Rational, s) Source #
(CanPickNonZero a, CanBeErrors es) => CanPickNonZero (CollectErrors es a) Source #
Instance details Defined in Numeric.MixedTypes.Eq Methods pickNonZero :: [(CollectErrors es a, s)] -> Maybe (CollectErrors es a, s) Source #

specCanPickNonZero :: (CanPickNonZero t, CanTestZero t, ConvertibleExactly Integer t, Show t, Arbitrary t) => T t -> Spec Source #

HSpec properties that each implementation of CanPickNonZero should satisfy.