Numeric.MixedTypes.Eq

Equality checks

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

Associated Types

type EqCompareType a b

Methods

equalTo :: a -> b -> EqCompareType a b

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

notEqualTo :: a -> b -> EqCompareType a b

notEqualTo :: CanNegSameType (EqCompareType a b) => a -> b -> EqCompareType a b

Instances

HasEqAsymmetric Bool Bool

Associated Types

type EqCompareType Bool Bool :: *

Methods

equalTo :: Bool -> Bool -> EqCompareType Bool Bool

notEqualTo :: Bool -> Bool -> EqCompareType Bool Bool

HasEqAsymmetric Char Char

Associated Types

type EqCompareType Char Char :: *

Methods

equalTo :: Char -> Char -> EqCompareType Char Char

notEqualTo :: Char -> Char -> EqCompareType Char Char

HasEqAsymmetric Double Double

Associated Types

type EqCompareType Double Double :: *

Methods

equalTo :: Double -> Double -> EqCompareType Double Double

notEqualTo :: Double -> Double -> EqCompareType Double Double

HasEqAsymmetric Double Int

Associated Types

type EqCompareType Double Int :: *

Methods

equalTo :: Double -> Int -> EqCompareType Double Int

notEqualTo :: Double -> Int -> EqCompareType Double Int

HasEqAsymmetric Double Integer

Associated Types

type EqCompareType Double Integer :: *

Methods

equalTo :: Double -> Integer -> EqCompareType Double Integer

notEqualTo :: Double -> Integer -> EqCompareType Double Integer

HasEqAsymmetric Int Double

Associated Types

type EqCompareType Int Double :: *

Methods

equalTo :: Int -> Double -> EqCompareType Int Double

notEqualTo :: Int -> Double -> EqCompareType Int Double

HasEqAsymmetric Int Int

Associated Types

type EqCompareType Int Int :: *

Methods

equalTo :: Int -> Int -> EqCompareType Int Int

notEqualTo :: Int -> Int -> EqCompareType Int Int

HasEqAsymmetric Int Integer

Associated Types

type EqCompareType Int Integer :: *

Methods

equalTo :: Int -> Integer -> EqCompareType Int Integer

notEqualTo :: Int -> Integer -> EqCompareType Int Integer

HasEqAsymmetric Int Rational

Associated Types

type EqCompareType Int Rational :: *

Methods

equalTo :: Int -> Rational -> EqCompareType Int Rational

notEqualTo :: Int -> Rational -> EqCompareType Int Rational

HasEqAsymmetric Integer Double

Associated Types

type EqCompareType Integer Double :: *

Methods

equalTo :: Integer -> Double -> EqCompareType Integer Double

notEqualTo :: Integer -> Double -> EqCompareType Integer Double

HasEqAsymmetric Integer Int

Associated Types

type EqCompareType Integer Int :: *

Methods

equalTo :: Integer -> Int -> EqCompareType Integer Int

notEqualTo :: Integer -> Int -> EqCompareType Integer Int

HasEqAsymmetric Integer Integer

Associated Types

type EqCompareType Integer Integer :: *

Methods

equalTo :: Integer -> Integer -> EqCompareType Integer Integer

notEqualTo :: Integer -> Integer -> EqCompareType Integer Integer

HasEqAsymmetric Integer Rational

Associated Types

type EqCompareType Integer Rational :: *

Methods

equalTo :: Integer -> Rational -> EqCompareType Integer Rational

notEqualTo :: Integer -> Rational -> EqCompareType Integer Rational

HasEqAsymmetric Rational Int

Associated Types

type EqCompareType Rational Int :: *

Methods

equalTo :: Rational -> Int -> EqCompareType Rational Int

notEqualTo :: Rational -> Int -> EqCompareType Rational Int

HasEqAsymmetric Rational Integer

Associated Types

type EqCompareType Rational Integer :: *

Methods

equalTo :: Rational -> Integer -> EqCompareType Rational Integer

notEqualTo :: Rational -> Integer -> EqCompareType Rational Integer

HasEqAsymmetric Rational Rational

Associated Types

type EqCompareType Rational Rational :: *

Methods

equalTo :: Rational -> Rational -> EqCompareType Rational Rational

notEqualTo :: Rational -> Rational -> EqCompareType Rational Rational

HasEqAsymmetric () ()

Associated Types

type EqCompareType () () :: *

Methods

equalTo :: () -> () -> EqCompareType () ()

notEqualTo :: () -> () -> EqCompareType () ()

(HasEqAsymmetric Bool b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Bool b0), IsBool (EnsureCE es0 (EqCompareType Bool b0)), SuitableForCE es0) => HasEqAsymmetric Bool (CollectErrors es0 b0)

Associated Types

type EqCompareType Bool (CollectErrors es0 b0) :: *

Methods

equalTo :: Bool -> CollectErrors es0 b0 -> EqCompareType Bool (CollectErrors es0 b0)

notEqualTo :: Bool -> CollectErrors es0 b0 -> EqCompareType Bool (CollectErrors es0 b0)

(HasEqAsymmetric Double b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Double b0), IsBool (EnsureCE es0 (EqCompareType Double b0)), SuitableForCE es0) => HasEqAsymmetric Double (CollectErrors es0 b0)

Associated Types

type EqCompareType Double (CollectErrors es0 b0) :: *

Methods

equalTo :: Double -> CollectErrors es0 b0 -> EqCompareType Double (CollectErrors es0 b0)

notEqualTo :: Double -> CollectErrors es0 b0 -> EqCompareType Double (CollectErrors es0 b0)

(HasEqAsymmetric Int b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Int b0), IsBool (EnsureCE es0 (EqCompareType Int b0)), SuitableForCE es0) => HasEqAsymmetric Int (CollectErrors es0 b0)

Associated Types

type EqCompareType Int (CollectErrors es0 b0) :: *

Methods

equalTo :: Int -> CollectErrors es0 b0 -> EqCompareType Int (CollectErrors es0 b0)

notEqualTo :: Int -> CollectErrors es0 b0 -> EqCompareType Int (CollectErrors es0 b0)

(HasEqAsymmetric Integer b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Integer b0), IsBool (EnsureCE es0 (EqCompareType Integer b0)), SuitableForCE es0) => HasEqAsymmetric Integer (CollectErrors es0 b0)

Associated Types

type EqCompareType Integer (CollectErrors es0 b0) :: *

Methods

equalTo :: Integer -> CollectErrors es0 b0 -> EqCompareType Integer (CollectErrors es0 b0)

notEqualTo :: Integer -> CollectErrors es0 b0 -> EqCompareType Integer (CollectErrors es0 b0)

(HasEqAsymmetric Rational b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Rational b0), IsBool (EnsureCE es0 (EqCompareType Rational b0)), SuitableForCE es0) => HasEqAsymmetric Rational (CollectErrors es0 b0)

Associated Types

type EqCompareType Rational (CollectErrors es0 b0) :: *

Methods

equalTo :: Rational -> CollectErrors es0 b0 -> EqCompareType Rational (CollectErrors es0 b0)

notEqualTo :: Rational -> CollectErrors es0 b0 -> EqCompareType Rational (CollectErrors es0 b0)

HasEqAsymmetric a b => HasEqAsymmetric [a] [b]

Associated Types

type EqCompareType [a] [b] :: *

Methods

equalTo :: [a] -> [b] -> EqCompareType [a] [b]

notEqualTo :: [a] -> [b] -> EqCompareType [a] [b]

HasEqAsymmetric a b => HasEqAsymmetric (Maybe a) (Maybe b)

Associated Types

type EqCompareType (Maybe a) (Maybe b) :: *

Methods

equalTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b)

notEqualTo :: Maybe a -> Maybe b -> EqCompareType (Maybe a) (Maybe b)

(HasEqAsymmetric (Maybe Bool) b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType (Maybe Bool) b0), IsBool (EnsureCE es0 (EqCompareType (Maybe Bool) b0)), SuitableForCE es0) => HasEqAsymmetric (Maybe Bool) (CollectErrors es0 b0)

Associated Types

type EqCompareType (Maybe Bool) (CollectErrors es0 b0) :: *

Methods

equalTo :: Maybe Bool -> CollectErrors es0 b0 -> EqCompareType (Maybe Bool) (CollectErrors es0 b0)

notEqualTo :: Maybe Bool -> CollectErrors es0 b0 -> EqCompareType (Maybe Bool) (CollectErrors es0 b0)

(HasEqAsymmetric a0 Double, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Double), IsBool (EnsureCE es0 (EqCompareType a0 Double)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Double

Associated Types

type EqCompareType (CollectErrors es0 a0) Double :: *

Methods

equalTo :: CollectErrors es0 a0 -> Double -> EqCompareType (CollectErrors es0 a0) Double

notEqualTo :: CollectErrors es0 a0 -> Double -> EqCompareType (CollectErrors es0 a0) Double

(HasEqAsymmetric a0 Rational, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Rational), IsBool (EnsureCE es0 (EqCompareType a0 Rational)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Rational

Associated Types

type EqCompareType (CollectErrors es0 a0) Rational :: *

Methods

equalTo :: CollectErrors es0 a0 -> Rational -> EqCompareType (CollectErrors es0 a0) Rational

notEqualTo :: CollectErrors es0 a0 -> Rational -> EqCompareType (CollectErrors es0 a0) Rational

(HasEqAsymmetric a0 Int, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Int), IsBool (EnsureCE es0 (EqCompareType a0 Int)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Int

Associated Types

type EqCompareType (CollectErrors es0 a0) Int :: *

Methods

equalTo :: CollectErrors es0 a0 -> Int -> EqCompareType (CollectErrors es0 a0) Int

notEqualTo :: CollectErrors es0 a0 -> Int -> EqCompareType (CollectErrors es0 a0) Int

(HasEqAsymmetric a0 Integer, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Integer), IsBool (EnsureCE es0 (EqCompareType a0 Integer)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Integer

Associated Types

type EqCompareType (CollectErrors es0 a0) Integer :: *

Methods

equalTo :: CollectErrors es0 a0 -> Integer -> EqCompareType (CollectErrors es0 a0) Integer

notEqualTo :: CollectErrors es0 a0 -> Integer -> EqCompareType (CollectErrors es0 a0) Integer

(HasEqAsymmetric a0 Bool, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Bool), IsBool (EnsureCE es0 (EqCompareType a0 Bool)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Bool

Associated Types

type EqCompareType (CollectErrors es0 a0) Bool :: *

Methods

equalTo :: CollectErrors es0 a0 -> Bool -> EqCompareType (CollectErrors es0 a0) Bool

notEqualTo :: CollectErrors es0 a0 -> Bool -> EqCompareType (CollectErrors es0 a0) Bool

(HasEqAsymmetric a0 (Maybe Bool), CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 (Maybe Bool)), IsBool (EnsureCE es0 (EqCompareType a0 (Maybe Bool))), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) (Maybe Bool)

Associated Types

type EqCompareType (CollectErrors es0 a0) (Maybe Bool) :: *

Methods

equalTo :: CollectErrors es0 a0 -> Maybe Bool -> EqCompareType (CollectErrors es0 a0) (Maybe Bool)

notEqualTo :: CollectErrors es0 a0 -> Maybe Bool -> EqCompareType (CollectErrors es0 a0) (Maybe Bool)

(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)

Associated Types

type EqCompareType (a1, a2) (b1, b2) :: *

Methods

equalTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2)

notEqualTo :: (a1, a2) -> (b1, b2) -> EqCompareType (a1, a2) (b1, b2)

(HasEqAsymmetric a b, CanEnsureCE es (EqCompareType a b), CanEnsureCE es a, CanEnsureCE es b, IsBool (EnsureCE es (EqCompareType a b)), SuitableForCE es) => HasEqAsymmetric (CollectErrors es a) (CollectErrors es b)

Associated Types

type EqCompareType (CollectErrors es a) (CollectErrors es b) :: *

Methods

equalTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b)

notEqualTo :: CollectErrors es a -> CollectErrors es b -> EqCompareType (CollectErrors es a) (CollectErrors es b)

HasEqAsymmetric ((a1, a2), a3) ((b1, b2), b3) => HasEqAsymmetric (a1, a2, a3) (b1, b2, b3)

Associated Types

type EqCompareType (a1, a2, a3) (b1, b2, b3) :: *

Methods

equalTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3)

notEqualTo :: (a1, a2, a3) -> (b1, b2, b3) -> EqCompareType (a1, a2, a3) (b1, b2, b3)

HasEqAsymmetric ((a1, a2, a3), a4) ((b1, b2, b3), b4) => HasEqAsymmetric (a1, a2, a3, a4) (b1, b2, b3, b4)

Associated Types

type EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4) :: *

Methods

equalTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4)

notEqualTo :: (a1, a2, a3, a4) -> (b1, b2, b3, b4) -> EqCompareType (a1, a2, a3, a4) (b1, b2, b3, b4)

HasEqAsymmetric ((a1, a2, a3, a4), a5) ((b1, b2, b3, b4), b5) => HasEqAsymmetric (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

Associated Types

type EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5) :: *

Methods

equalTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

notEqualTo :: (a1, a2, a3, a4, a5) -> (b1, b2, b3, b4, b5) -> EqCompareType (a1, a2, a3, a4, a5) (b1, b2, b3, b4, b5)

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

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

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

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

type HasEqCertainlyCE es t1 t2 = (HasEqCertainly t1 t2, HasEqCertainly (EnsureCE es t1) (EnsureCE es t2))

type HasEqCertainlyCN t1 t2 = HasEqCertainlyCE NumErrors 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 infix 4

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

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

Tests

specHasEq :: (Show t1, Show t2, Show t3, Arbitrary t1, Arbitrary t2, Arbitrary t3, CanTestCertainly (EqCompareType t1 t1), CanTestCertainly (EqCompareType t1 t2), CanTestCertainly (EqCompareType t2 t1), CanTestCertainly (EqCompareType t2 t3), CanTestCertainly (AndOrType (EqCompareType t1 t2) (EqCompareType t2 t3)), CanAndOrAsymmetric (EqCompareType t1 t2) (EqCompareType t2 t3), HasEqAsymmetric t1 t1, HasEqAsymmetric t1 t2, HasEqAsymmetric t2 t1, HasEqAsymmetric t2 t3) => T t1 -> T t2 -> T t3 -> Spec

HSpec properties that each implementation of HasEq should satisfy.

specHasEqNotMixed :: (Show t, Arbitrary t, CanTestCertainly (EqCompareType t t), CanTestCertainly (AndOrType (EqCompareType t t) (EqCompareType t t)), HasEqAsymmetric t t) => T t -> Spec

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

HSpec property of there-and-back conversion.

Specific comparisons

class CanTestNaN t where

Methods

isNaN :: t -> Bool

isNaN :: RealFloat t => t -> Bool

Instances

CanTestNaN Double

Methods

isNaN :: Double -> Bool

CanTestNaN Rational

Methods

isNaN :: Rational -> Bool

(CanTestNaN t, SuitableForCE es) => CanTestNaN (CollectErrors es t)

Methods

isNaN :: CollectErrors es t -> Bool

class CanTestFinite t where

Methods

isInfinite :: t -> Bool

isInfinite :: RealFloat t => t -> Bool

isFinite :: t -> Bool

isFinite :: RealFloat t => t -> Bool

Instances

CanTestFinite Double

Methods

isInfinite :: Double -> Bool

isFinite :: Double -> Bool

CanTestFinite Rational

Methods

isInfinite :: Rational -> Bool

isFinite :: Rational -> Bool

(CanTestFinite t, SuitableForCE es) => CanTestFinite (CollectErrors es t)

Methods

isInfinite :: CollectErrors es t -> Bool

isFinite :: CollectErrors es t -> Bool

class CanTestInteger t where

Minimal complete definition

certainlyNotInteger, certainlyIntegerGetIt

Methods

certainlyNotInteger :: t -> Bool

certainlyInteger :: t -> Bool

certainlyIntegerGetIt :: t -> Maybe Integer

Instances

CanTestInteger Double

Methods

certainlyNotInteger :: Double -> Bool

certainlyInteger :: Double -> Bool

certainlyIntegerGetIt :: Double -> Maybe Integer

CanTestInteger Int

Methods

certainlyNotInteger :: Int -> Bool

certainlyInteger :: Int -> Bool

certainlyIntegerGetIt :: Int -> Maybe Integer

CanTestInteger Integer

Methods

certainlyNotInteger :: Integer -> Bool

certainlyInteger :: Integer -> Bool

certainlyIntegerGetIt :: Integer -> Maybe Integer

CanTestInteger Rational

Methods

certainlyNotInteger :: Rational -> Bool

certainlyInteger :: Rational -> Bool

certainlyIntegerGetIt :: Rational -> Maybe Integer

(CanTestInteger t, SuitableForCE es) => CanTestInteger (CollectErrors es t)

Methods

certainlyNotInteger :: CollectErrors es t -> Bool

certainlyInteger :: CollectErrors es t -> Bool

certainlyIntegerGetIt :: CollectErrors es t -> Maybe Integer

class CanTestZero t where

Methods

isCertainlyZero :: t -> Bool

isCertainlyNonZero :: t -> Bool

isCertainlyZero :: HasEqCertainly t Integer => t -> Bool

isCertainlyNonZero :: HasEqCertainly t Integer => t -> Bool

Instances

CanTestZero Double

Methods

isCertainlyZero :: Double -> Bool

isCertainlyNonZero :: Double -> Bool

CanTestZero Int

Methods

isCertainlyZero :: Int -> Bool

isCertainlyNonZero :: Int -> Bool

CanTestZero Integer

Methods

isCertainlyZero :: Integer -> Bool

isCertainlyNonZero :: Integer -> Bool

CanTestZero Rational

Methods

isCertainlyZero :: Rational -> Bool

isCertainlyNonZero :: Rational -> Bool

(CanTestZero t, SuitableForCE es) => CanTestZero (CollectErrors es t)

Methods

isCertainlyZero :: CollectErrors es t -> Bool

isCertainlyNonZero :: CollectErrors es t -> Bool

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

HSpec properties that each implementation of CanTestZero should satisfy.

class CanPickNonZero t where

Methods

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

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.

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

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.

Instances

CanPickNonZero Int

Methods

pickNonZero :: [(Int, s)] -> Maybe (Int, s)

CanPickNonZero Integer

Methods

pickNonZero :: [(Integer, s)] -> Maybe (Integer, s)

CanPickNonZero Rational

Methods

pickNonZero :: [(Rational, s)] -> Maybe (Rational, s)

(CanPickNonZero a, SuitableForCE es) => CanPickNonZero (CollectErrors es a)

Methods

pickNonZero :: [(CollectErrors es a, s)] -> Maybe (CollectErrors es a, s)

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

HSpec properties that each implementation of CanPickNonZero should satisfy.