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 -> Bool

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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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), 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 :: (HasEqX t1 t1, HasEqX t1 t2, HasEqX t2 t1, HasEqX t1 t3, HasEqX t2 t3, CanAndOrX (EqCompareType t1 t2) (EqCompareType t2 t3)) => T t1 -> T t2 -> T t3 -> Spec

HSpec properties that each implementation of HasEq should satisfy.

specHasEqNotMixed :: (HasEqX t t, CanAndOrX (EqCompareType t t) (EqCompareType t t)) => T t -> Spec

HSpec properties that each implementation of HasEq should satisfy.

type HasEqX t1 t2 = (HasEqCertainly t1 t2, Show t1, Arbitrary t1, Show t2, Arbitrary t2)

Compound type constraint useful for test definition.

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.