mixed-types-num-0.3.1.4: Alternative Prelude with numeric and logic expressions typed bottom-up

Copyright(c) Michal Konecny
LicenseBSD3
Maintainermikkonecny@gmail.com
Stabilityexperimental
Portabilityportable
Safe HaskellNone
LanguageHaskell98

Numeric.MixedTypes.Eq

Contents

Description

 

Synopsis

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 #

Associated Types

type EqCompareType a b Source #

Methods

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

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

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

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

Instances

HasEqAsymmetric Bool Bool Source # 
HasEqAsymmetric Char Char Source # 
HasEqAsymmetric Double Double Source # 
HasEqAsymmetric Double Int Source # 
HasEqAsymmetric Double Integer Source # 
HasEqAsymmetric Int Double Source # 
HasEqAsymmetric Int Int Source # 
HasEqAsymmetric Int Integer Source # 
HasEqAsymmetric Int Rational Source # 
HasEqAsymmetric Integer Double Source # 
HasEqAsymmetric Integer Int Source # 
HasEqAsymmetric Integer Integer Source # 
HasEqAsymmetric Integer Rational Source # 
HasEqAsymmetric Rational Int Source # 
HasEqAsymmetric Rational Integer Source # 
HasEqAsymmetric Rational Rational Source # 
HasEqAsymmetric () () Source # 

Associated Types

type EqCompareType () () :: * Source #

Methods

equalTo :: () -> () -> EqCompareType () () Source #

notEqualTo :: () -> () -> EqCompareType () () Source #

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

Associated Types

type EqCompareType Bool (CollectErrors es0 b0) :: * Source #

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

Associated Types

type EqCompareType Int (CollectErrors es0 b0) :: * Source #

(HasEqAsymmetric Integer b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Integer b0), IsBool (EnsureCE es0 (EqCompareType Integer b0)), SuitableForCE es0) => HasEqAsymmetric Integer (CollectErrors es0 b0) Source # 
(HasEqAsymmetric Rational b0, CanEnsureCE es0 b0, CanEnsureCE es0 (EqCompareType Rational b0), IsBool (EnsureCE es0 (EqCompareType Rational b0)), SuitableForCE es0) => HasEqAsymmetric Rational (CollectErrors es0 b0) Source # 
HasEqAsymmetric a b => HasEqAsymmetric [a] [b] Source # 

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 # 

Associated Types

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

(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) Source # 
(HasEqAsymmetric a0 Double, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Double), IsBool (EnsureCE es0 (EqCompareType a0 Double)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Double Source # 
(HasEqAsymmetric a0 Rational, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Rational), IsBool (EnsureCE es0 (EqCompareType a0 Rational)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Rational Source # 
(HasEqAsymmetric a0 Int, CanEnsureCE es0 a0, CanEnsureCE es0 (EqCompareType a0 Int), IsBool (EnsureCE es0 (EqCompareType a0 Int)), SuitableForCE es0) => HasEqAsymmetric (CollectErrors es0 a0) Int Source # 

Associated Types

type EqCompareType (CollectErrors es0 a0) Int :: * Source #

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

Associated Types

type EqCompareType (CollectErrors es0 a0) Bool :: * Source #

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

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, 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) Source # 
HasEqAsymmetric ((a1, a2), a3) ((b1, b2), b3) => HasEqAsymmetric (a1, a2, a3) (b1, b2, b3) Source # 

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 # 

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 # 

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 HasEqCertainlyCE es t1 t2 = (HasEqCertainly t1 t2, HasEqCertainly (EnsureCE es t1) (EnsureCE es t2)) 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 :: (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 Source #

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

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

HSpec properties that each implementation of CanTestZero should satisfy.

class CanPickNonZero t where Source #

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.

pickNonZero :: (CanTestZero t, Show t) => [(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.

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.