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

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 CanTestFinite t where

Methods

isNaN :: t -> Bool

isNaN :: RealFloat t => t -> Bool

isInfinite :: t -> Bool

isInfinite :: RealFloat t => t -> Bool

isFinite :: t -> Bool

Instances

CanTestFinite Double

Methods

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isFinite :: Double -> Bool

CanTestFinite Rational

Methods

isNaN :: Rational -> Bool

isInfinite :: Rational -> Bool

isFinite :: Rational -> 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

class CanTestZero t where

Methods

isCertainlyZero :: t -> Bool

isNonZero :: t -> Bool

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

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

Instances

CanTestZero Double

Methods

isCertainlyZero :: Double -> Bool

isNonZero :: Double -> Bool

CanTestZero Int

Methods

isCertainlyZero :: Int -> Bool

isNonZero :: Int -> Bool

CanTestZero Integer

Methods

isCertainlyZero :: Integer -> Bool

isNonZero :: Integer -> Bool

CanTestZero Rational

Methods

isCertainlyZero :: Rational -> Bool

isNonZero :: Rational -> 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)] -> (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)] -> (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)] -> (Int, s)

CanPickNonZero Integer

Methods

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

CanPickNonZero Rational

Methods

pickNonZero :: [(Rational, s)] -> (Rational, 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.