Control.CollectErrors

Monad for collecting errors in expressions

data CollectErrors es v

A wrapper around values which can accommodate a list of (potential) errors that have (maybe) occurred during the computation of a value. A value may be missing, leaving only the error(s).

Such error collection allows one to write expressions with partial functions (ie functions that fail for some inputs) instead of branching after each application of such function. Dealing with the errors can be moved outside the expression. If the error data contain enough information, their list can be used to trace the source of the errors.

Constructors

CollectErrors

Fields

• getMaybeValueCE :: Maybe v
• getErrorsCE :: es

Instances

SuitableForCE es => CanEnsureCE es (CollectErrors es a)

Associated Types

type EnsureCE es (CollectErrors es a) :: *

type EnsureNoCE es (CollectErrors es a) :: *

Methods

ensureCE :: Maybe es -> CollectErrors es a -> EnsureCE es (CollectErrors es a)

deEnsureCE :: Maybe es -> EnsureCE es (CollectErrors es a) -> Either es (CollectErrors es a)

ensureNoCE :: Maybe es -> CollectErrors es a -> Either es (EnsureNoCE es (CollectErrors es a))

noValueECE :: Maybe (CollectErrors es a) -> es -> EnsureCE es (CollectErrors es a)

(ConvertibleExactly Bool t0, Monoid es0) => ConvertibleExactly Bool (CollectErrors es0 t0)

Methods

safeConvertExactly :: Bool -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Double t0, Monoid es0) => ConvertibleExactly Double (CollectErrors es0 t0)

Methods

safeConvertExactly :: Double -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Int t0, Monoid es0) => ConvertibleExactly Int (CollectErrors es0 t0)

Methods

safeConvertExactly :: Int -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Integer t0, Monoid es0) => ConvertibleExactly Integer (CollectErrors es0 t0)

Methods

safeConvertExactly :: Integer -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Rational t0, Monoid es0) => ConvertibleExactly Rational (CollectErrors es0 t0)

Methods

safeConvertExactly :: Rational -> ConvertResult (CollectErrors es0 t0)

(CanAndOrAsymmetric Bool t2, SuitableForCE es, CanEnsureCE es (AndOrType Bool t2)) => CanAndOrAsymmetric Bool (CollectErrors es t2)

Associated Types

type AndOrType Bool (CollectErrors es t2) :: *

Methods

and2 :: Bool -> CollectErrors es t2 -> AndOrType Bool (CollectErrors es t2)

or2 :: Bool -> CollectErrors es t2 -> AndOrType Bool (CollectErrors es t2)

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

(HasOrderAsymmetric Double b0, CanEnsureCE es0 (OrderCompareType Double b0), IsBool (EnsureCE es0 (OrderCompareType Double b0)), SuitableForCE es0) => HasOrderAsymmetric Double (CollectErrors es0 b0)

Associated Types

type OrderCompareType Double (CollectErrors es0 b0) :: *

Methods

lessThan :: Double -> CollectErrors es0 b0 -> OrderCompareType Double (CollectErrors es0 b0)

greaterThan :: Double -> CollectErrors es0 b0 -> OrderCompareType Double (CollectErrors es0 b0)

leq :: Double -> CollectErrors es0 b0 -> OrderCompareType Double (CollectErrors es0 b0)

geq :: Double -> CollectErrors es0 b0 -> OrderCompareType Double (CollectErrors es0 b0)

(HasOrderAsymmetric Int b0, CanEnsureCE es0 (OrderCompareType Int b0), IsBool (EnsureCE es0 (OrderCompareType Int b0)), SuitableForCE es0) => HasOrderAsymmetric Int (CollectErrors es0 b0)

Associated Types

type OrderCompareType Int (CollectErrors es0 b0) :: *

Methods

lessThan :: Int -> CollectErrors es0 b0 -> OrderCompareType Int (CollectErrors es0 b0)

greaterThan :: Int -> CollectErrors es0 b0 -> OrderCompareType Int (CollectErrors es0 b0)

leq :: Int -> CollectErrors es0 b0 -> OrderCompareType Int (CollectErrors es0 b0)

geq :: Int -> CollectErrors es0 b0 -> OrderCompareType Int (CollectErrors es0 b0)

(HasOrderAsymmetric Integer b0, CanEnsureCE es0 (OrderCompareType Integer b0), IsBool (EnsureCE es0 (OrderCompareType Integer b0)), SuitableForCE es0) => HasOrderAsymmetric Integer (CollectErrors es0 b0)

Associated Types

type OrderCompareType Integer (CollectErrors es0 b0) :: *

Methods

lessThan :: Integer -> CollectErrors es0 b0 -> OrderCompareType Integer (CollectErrors es0 b0)

greaterThan :: Integer -> CollectErrors es0 b0 -> OrderCompareType Integer (CollectErrors es0 b0)

leq :: Integer -> CollectErrors es0 b0 -> OrderCompareType Integer (CollectErrors es0 b0)

geq :: Integer -> CollectErrors es0 b0 -> OrderCompareType Integer (CollectErrors es0 b0)

(HasOrderAsymmetric Rational b0, CanEnsureCE es0 (OrderCompareType Rational b0), IsBool (EnsureCE es0 (OrderCompareType Rational b0)), SuitableForCE es0) => HasOrderAsymmetric Rational (CollectErrors es0 b0)

Associated Types

type OrderCompareType Rational (CollectErrors es0 b0) :: *

Methods

lessThan :: Rational -> CollectErrors es0 b0 -> OrderCompareType Rational (CollectErrors es0 b0)

greaterThan :: Rational -> CollectErrors es0 b0 -> OrderCompareType Rational (CollectErrors es0 b0)

leq :: Rational -> CollectErrors es0 b0 -> OrderCompareType Rational (CollectErrors es0 b0)

geq :: Rational -> CollectErrors es0 b0 -> OrderCompareType Rational (CollectErrors es0 b0)

(CanMinMaxAsymmetric Double b0, CanEnsureCE es0 (MinMaxType Double b0), SuitableForCE es0) => CanMinMaxAsymmetric Double (CollectErrors es0 b0)

Associated Types

type MinMaxType Double (CollectErrors es0 b0) :: *

Methods

min :: Double -> CollectErrors es0 b0 -> MinMaxType Double (CollectErrors es0 b0)

max :: Double -> CollectErrors es0 b0 -> MinMaxType Double (CollectErrors es0 b0)

(CanMinMaxAsymmetric Int b0, CanEnsureCE es0 (MinMaxType Int b0), SuitableForCE es0) => CanMinMaxAsymmetric Int (CollectErrors es0 b0)

Associated Types

type MinMaxType Int (CollectErrors es0 b0) :: *

Methods

min :: Int -> CollectErrors es0 b0 -> MinMaxType Int (CollectErrors es0 b0)

max :: Int -> CollectErrors es0 b0 -> MinMaxType Int (CollectErrors es0 b0)

(CanMinMaxAsymmetric Integer b0, CanEnsureCE es0 (MinMaxType Integer b0), SuitableForCE es0) => CanMinMaxAsymmetric Integer (CollectErrors es0 b0)

Associated Types

type MinMaxType Integer (CollectErrors es0 b0) :: *

Methods

min :: Integer -> CollectErrors es0 b0 -> MinMaxType Integer (CollectErrors es0 b0)

max :: Integer -> CollectErrors es0 b0 -> MinMaxType Integer (CollectErrors es0 b0)

(CanMinMaxAsymmetric Rational b0, CanEnsureCE es0 (MinMaxType Rational b0), SuitableForCE es0) => CanMinMaxAsymmetric Rational (CollectErrors es0 b0)

Associated Types

type MinMaxType Rational (CollectErrors es0 b0) :: *

Methods

min :: Rational -> CollectErrors es0 b0 -> MinMaxType Rational (CollectErrors es0 b0)

max :: Rational -> CollectErrors es0 b0 -> MinMaxType Rational (CollectErrors es0 b0)

(CanSub Double b0, CanEnsureCE es0 (SubType Double b0), SuitableForCE es0) => CanSub Double (CollectErrors es0 b0)

Associated Types

type SubType Double (CollectErrors es0 b0) :: *

Methods

sub :: Double -> CollectErrors es0 b0 -> SubType Double (CollectErrors es0 b0)

(CanSub Int b0, CanEnsureCE es0 (SubType Int b0), SuitableForCE es0) => CanSub Int (CollectErrors es0 b0)

Associated Types

type SubType Int (CollectErrors es0 b0) :: *

Methods

sub :: Int -> CollectErrors es0 b0 -> SubType Int (CollectErrors es0 b0)

(CanSub Integer b0, CanEnsureCE es0 (SubType Integer b0), SuitableForCE es0) => CanSub Integer (CollectErrors es0 b0)

Associated Types

type SubType Integer (CollectErrors es0 b0) :: *

Methods

sub :: Integer -> CollectErrors es0 b0 -> SubType Integer (CollectErrors es0 b0)

(CanSub Rational b0, CanEnsureCE es0 (SubType Rational b0), SuitableForCE es0) => CanSub Rational (CollectErrors es0 b0)

Associated Types

type SubType Rational (CollectErrors es0 b0) :: *

Methods

sub :: Rational -> CollectErrors es0 b0 -> SubType Rational (CollectErrors es0 b0)

(CanAddAsymmetric Double b0, CanEnsureCE es0 (AddType Double b0), SuitableForCE es0) => CanAddAsymmetric Double (CollectErrors es0 b0)

Associated Types

type AddType Double (CollectErrors es0 b0) :: *

Methods

add :: Double -> CollectErrors es0 b0 -> AddType Double (CollectErrors es0 b0)

(CanAddAsymmetric Int b0, CanEnsureCE es0 (AddType Int b0), SuitableForCE es0) => CanAddAsymmetric Int (CollectErrors es0 b0)

Associated Types

type AddType Int (CollectErrors es0 b0) :: *

Methods

add :: Int -> CollectErrors es0 b0 -> AddType Int (CollectErrors es0 b0)

(CanAddAsymmetric Integer b0, CanEnsureCE es0 (AddType Integer b0), SuitableForCE es0) => CanAddAsymmetric Integer (CollectErrors es0 b0)

Associated Types

type AddType Integer (CollectErrors es0 b0) :: *

Methods

add :: Integer -> CollectErrors es0 b0 -> AddType Integer (CollectErrors es0 b0)

(CanAddAsymmetric Rational b0, CanEnsureCE es0 (AddType Rational b0), SuitableForCE es0) => CanAddAsymmetric Rational (CollectErrors es0 b0)

Associated Types

type AddType Rational (CollectErrors es0 b0) :: *

Methods

add :: Rational -> CollectErrors es0 b0 -> AddType Rational (CollectErrors es0 b0)

(CanPow Double b0, CanEnsureCE es0 (PowType Double b0), SuitableForCE es0) => CanPow Double (CollectErrors es0 b0)

Associated Types

type PowType Double (CollectErrors es0 b0) :: *

Methods

pow :: Double -> CollectErrors es0 b0 -> PowType Double (CollectErrors es0 b0)

(CanPow Int b0, CanEnsureCE es0 (PowType Int b0), SuitableForCE es0) => CanPow Int (CollectErrors es0 b0)

Associated Types

type PowType Int (CollectErrors es0 b0) :: *

Methods

pow :: Int -> CollectErrors es0 b0 -> PowType Int (CollectErrors es0 b0)

(CanPow Integer b0, CanEnsureCE es0 (PowType Integer b0), SuitableForCE es0) => CanPow Integer (CollectErrors es0 b0)

Associated Types

type PowType Integer (CollectErrors es0 b0) :: *

Methods

pow :: Integer -> CollectErrors es0 b0 -> PowType Integer (CollectErrors es0 b0)

(CanPow Rational b0, CanEnsureCE es0 (PowType Rational b0), SuitableForCE es0) => CanPow Rational (CollectErrors es0 b0)

Associated Types

type PowType Rational (CollectErrors es0 b0) :: *

Methods

pow :: Rational -> CollectErrors es0 b0 -> PowType Rational (CollectErrors es0 b0)

(CanMulAsymmetric Double b0, CanEnsureCE es0 (MulType Double b0), SuitableForCE es0) => CanMulAsymmetric Double (CollectErrors es0 b0)

Associated Types

type MulType Double (CollectErrors es0 b0) :: *

Methods

mul :: Double -> CollectErrors es0 b0 -> MulType Double (CollectErrors es0 b0)

(CanMulAsymmetric Int b0, CanEnsureCE es0 (MulType Int b0), SuitableForCE es0) => CanMulAsymmetric Int (CollectErrors es0 b0)

Associated Types

type MulType Int (CollectErrors es0 b0) :: *

Methods

mul :: Int -> CollectErrors es0 b0 -> MulType Int (CollectErrors es0 b0)

(CanMulAsymmetric Integer b0, CanEnsureCE es0 (MulType Integer b0), SuitableForCE es0) => CanMulAsymmetric Integer (CollectErrors es0 b0)

Associated Types

type MulType Integer (CollectErrors es0 b0) :: *

Methods

mul :: Integer -> CollectErrors es0 b0 -> MulType Integer (CollectErrors es0 b0)

(CanMulAsymmetric Rational b0, CanEnsureCE es0 (MulType Rational b0), SuitableForCE es0) => CanMulAsymmetric Rational (CollectErrors es0 b0)

Associated Types

type MulType Rational (CollectErrors es0 b0) :: *

Methods

mul :: Rational -> CollectErrors es0 b0 -> MulType Rational (CollectErrors es0 b0)

(CanDiv Double b0, CanEnsureCE es0 (DivType Double b0), CanEnsureCE es0 (DivTypeNoCN Double b0), SuitableForCE es0) => CanDiv Double (CollectErrors es0 b0)

Associated Types

type DivTypeNoCN Double (CollectErrors es0 b0) :: *

type DivType Double (CollectErrors es0 b0) :: *

Methods

divideNoCN :: Double -> CollectErrors es0 b0 -> DivTypeNoCN Double (CollectErrors es0 b0)

divide :: Double -> CollectErrors es0 b0 -> DivType Double (CollectErrors es0 b0)

(CanDiv Int b0, CanEnsureCE es0 (DivType Int b0), CanEnsureCE es0 (DivTypeNoCN Int b0), SuitableForCE es0) => CanDiv Int (CollectErrors es0 b0)

Associated Types

type DivTypeNoCN Int (CollectErrors es0 b0) :: *

type DivType Int (CollectErrors es0 b0) :: *

Methods

divideNoCN :: Int -> CollectErrors es0 b0 -> DivTypeNoCN Int (CollectErrors es0 b0)

divide :: Int -> CollectErrors es0 b0 -> DivType Int (CollectErrors es0 b0)

(CanDiv Integer b0, CanEnsureCE es0 (DivType Integer b0), CanEnsureCE es0 (DivTypeNoCN Integer b0), SuitableForCE es0) => CanDiv Integer (CollectErrors es0 b0)

Associated Types

type DivTypeNoCN Integer (CollectErrors es0 b0) :: *

type DivType Integer (CollectErrors es0 b0) :: *

Methods

divideNoCN :: Integer -> CollectErrors es0 b0 -> DivTypeNoCN Integer (CollectErrors es0 b0)

divide :: Integer -> CollectErrors es0 b0 -> DivType Integer (CollectErrors es0 b0)

(CanDiv Rational b0, CanEnsureCE es0 (DivType Rational b0), CanEnsureCE es0 (DivTypeNoCN Rational b0), SuitableForCE es0) => CanDiv Rational (CollectErrors es0 b0)

Associated Types

type DivTypeNoCN Rational (CollectErrors es0 b0) :: *

type DivType Rational (CollectErrors es0 b0) :: *

Methods

divideNoCN :: Rational -> CollectErrors es0 b0 -> DivTypeNoCN Rational (CollectErrors es0 b0)

divide :: Rational -> CollectErrors es0 b0 -> DivType Rational (CollectErrors es0 b0)

Monoid es => Monad (CollectErrors es)

Methods

(>>=) :: CollectErrors es a -> (a -> CollectErrors es b) -> CollectErrors es b

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

return :: a -> CollectErrors es a

fail :: String -> CollectErrors es a

Functor (CollectErrors es)

Methods

fmap :: (a -> b) -> CollectErrors es a -> CollectErrors es b

(<$) :: a -> CollectErrors es b -> CollectErrors es a

Monoid es => Applicative (CollectErrors es)

Methods

pure :: a -> CollectErrors es a

(<*>) :: CollectErrors es (a -> b) -> CollectErrors es a -> CollectErrors es b

(*>) :: CollectErrors es a -> CollectErrors es b -> CollectErrors es b

(<*) :: CollectErrors es a -> CollectErrors es b -> CollectErrors es a

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

(Show v, SuitableForCE es) => Show (CollectErrors es v)

Methods

showsPrec :: Int -> CollectErrors es v -> ShowS

show :: CollectErrors es v -> String

showList :: [CollectErrors es v] -> ShowS

(Arbitrary t, Monoid es) => Arbitrary (CollectErrors es t)

Methods

arbitrary :: Gen (CollectErrors es t)

shrink :: CollectErrors es t -> [CollectErrors es t]

(CanNeg t, SuitableForCE es, CanEnsureCE es (NegType t)) => CanNeg (CollectErrors es t)

Associated Types

type NegType (CollectErrors es t) :: *

Methods

negate :: CollectErrors es t -> NegType (CollectErrors es t)

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

Methods

isCertainlyTrue :: CollectErrors es t -> Bool

isCertainlyFalse :: CollectErrors es t -> Bool

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

Methods

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

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

Methods

isCertainlyZero :: CollectErrors es t -> Bool

isCertainlyNonZero :: CollectErrors es t -> Bool

(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

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

Methods

isInfinite :: CollectErrors es t -> Bool

isFinite :: CollectErrors es t -> Bool

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

Methods

isNaN :: CollectErrors es t -> Bool

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

Methods

isCertainlyPositive :: CollectErrors es t -> Bool

isCertainlyNonNegative :: CollectErrors es t -> Bool

isCertainlyNegative :: CollectErrors es t -> Bool

isCertainlyNonPositive :: CollectErrors es t -> Bool

(CanAbs a, CanEnsureCE es (AbsType a), SuitableForCE es) => CanAbs (CollectErrors es a)

Associated Types

type AbsType (CollectErrors es a) :: *

Methods

abs :: CollectErrors es a -> AbsType (CollectErrors es a)

(CanSinCos a, CanEnsureCE es (SinCosType a), SuitableForCE es) => CanSinCos (CollectErrors es a)

Associated Types

type SinCosType (CollectErrors es a) :: *

Methods

cos :: CollectErrors es a -> SinCosType (CollectErrors es a)

sin :: CollectErrors es a -> SinCosType (CollectErrors es a)

(CanLog a, CanEnsureCE es (LogType a), SuitableForCE es) => CanLog (CollectErrors es a)

Associated Types

type LogType (CollectErrors es a) :: *

Methods

log :: CollectErrors es a -> LogType (CollectErrors es a)

(CanExp a, CanEnsureCE es (ExpType a), SuitableForCE es) => CanExp (CollectErrors es a)

Associated Types

type ExpType (CollectErrors es a) :: *

Methods

exp :: CollectErrors es a -> ExpType (CollectErrors es a)

(CanSqrt a, CanEnsureCE es (SqrtType a), SuitableForCE es) => CanSqrt (CollectErrors es a)

Associated Types

type SqrtType (CollectErrors es a) :: *

Methods

sqrt :: CollectErrors es a -> SqrtType (CollectErrors es a)

(CanAndOrAsymmetric t1 Bool, SuitableForCE es, CanEnsureCE es (AndOrType t1 Bool)) => CanAndOrAsymmetric (CollectErrors es t1) Bool

Associated Types

type AndOrType (CollectErrors es t1) Bool :: *

Methods

and2 :: CollectErrors es t1 -> Bool -> AndOrType (CollectErrors es t1) Bool

or2 :: CollectErrors es t1 -> Bool -> AndOrType (CollectErrors es t1) Bool

(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

(HasOrderAsymmetric a0 Double, CanEnsureCE es0 (OrderCompareType a0 Double), IsBool (EnsureCE es0 (OrderCompareType a0 Double)), SuitableForCE es0) => HasOrderAsymmetric (CollectErrors es0 a0) Double

Associated Types

type OrderCompareType (CollectErrors es0 a0) Double :: *

Methods

lessThan :: CollectErrors es0 a0 -> Double -> OrderCompareType (CollectErrors es0 a0) Double

greaterThan :: CollectErrors es0 a0 -> Double -> OrderCompareType (CollectErrors es0 a0) Double

leq :: CollectErrors es0 a0 -> Double -> OrderCompareType (CollectErrors es0 a0) Double

geq :: CollectErrors es0 a0 -> Double -> OrderCompareType (CollectErrors es0 a0) Double

(HasOrderAsymmetric a0 Rational, CanEnsureCE es0 (OrderCompareType a0 Rational), IsBool (EnsureCE es0 (OrderCompareType a0 Rational)), SuitableForCE es0) => HasOrderAsymmetric (CollectErrors es0 a0) Rational

Associated Types

type OrderCompareType (CollectErrors es0 a0) Rational :: *

Methods

lessThan :: CollectErrors es0 a0 -> Rational -> OrderCompareType (CollectErrors es0 a0) Rational

greaterThan :: CollectErrors es0 a0 -> Rational -> OrderCompareType (CollectErrors es0 a0) Rational

leq :: CollectErrors es0 a0 -> Rational -> OrderCompareType (CollectErrors es0 a0) Rational

geq :: CollectErrors es0 a0 -> Rational -> OrderCompareType (CollectErrors es0 a0) Rational

(HasOrderAsymmetric a0 Int, CanEnsureCE es0 (OrderCompareType a0 Int), IsBool (EnsureCE es0 (OrderCompareType a0 Int)), SuitableForCE es0) => HasOrderAsymmetric (CollectErrors es0 a0) Int

Associated Types

type OrderCompareType (CollectErrors es0 a0) Int :: *

Methods

lessThan :: CollectErrors es0 a0 -> Int -> OrderCompareType (CollectErrors es0 a0) Int

greaterThan :: CollectErrors es0 a0 -> Int -> OrderCompareType (CollectErrors es0 a0) Int

leq :: CollectErrors es0 a0 -> Int -> OrderCompareType (CollectErrors es0 a0) Int

geq :: CollectErrors es0 a0 -> Int -> OrderCompareType (CollectErrors es0 a0) Int

(HasOrderAsymmetric a0 Integer, CanEnsureCE es0 (OrderCompareType a0 Integer), IsBool (EnsureCE es0 (OrderCompareType a0 Integer)), SuitableForCE es0) => HasOrderAsymmetric (CollectErrors es0 a0) Integer

Associated Types

type OrderCompareType (CollectErrors es0 a0) Integer :: *

Methods

lessThan :: CollectErrors es0 a0 -> Integer -> OrderCompareType (CollectErrors es0 a0) Integer

greaterThan :: CollectErrors es0 a0 -> Integer -> OrderCompareType (CollectErrors es0 a0) Integer

leq :: CollectErrors es0 a0 -> Integer -> OrderCompareType (CollectErrors es0 a0) Integer

geq :: CollectErrors es0 a0 -> Integer -> OrderCompareType (CollectErrors es0 a0) Integer

(CanMinMaxAsymmetric a0 Double, CanEnsureCE es0 (MinMaxType a0 Double), SuitableForCE es0) => CanMinMaxAsymmetric (CollectErrors es0 a0) Double

Associated Types

type MinMaxType (CollectErrors es0 a0) Double :: *

Methods

min :: CollectErrors es0 a0 -> Double -> MinMaxType (CollectErrors es0 a0) Double

max :: CollectErrors es0 a0 -> Double -> MinMaxType (CollectErrors es0 a0) Double

(CanMinMaxAsymmetric a0 Rational, CanEnsureCE es0 (MinMaxType a0 Rational), SuitableForCE es0) => CanMinMaxAsymmetric (CollectErrors es0 a0) Rational

Associated Types

type MinMaxType (CollectErrors es0 a0) Rational :: *

Methods

min :: CollectErrors es0 a0 -> Rational -> MinMaxType (CollectErrors es0 a0) Rational

max :: CollectErrors es0 a0 -> Rational -> MinMaxType (CollectErrors es0 a0) Rational

(CanMinMaxAsymmetric a0 Int, CanEnsureCE es0 (MinMaxType a0 Int), SuitableForCE es0) => CanMinMaxAsymmetric (CollectErrors es0 a0) Int

Associated Types

type MinMaxType (CollectErrors es0 a0) Int :: *

Methods

min :: CollectErrors es0 a0 -> Int -> MinMaxType (CollectErrors es0 a0) Int

max :: CollectErrors es0 a0 -> Int -> MinMaxType (CollectErrors es0 a0) Int

(CanMinMaxAsymmetric a0 Integer, CanEnsureCE es0 (MinMaxType a0 Integer), SuitableForCE es0) => CanMinMaxAsymmetric (CollectErrors es0 a0) Integer

Associated Types

type MinMaxType (CollectErrors es0 a0) Integer :: *

Methods

min :: CollectErrors es0 a0 -> Integer -> MinMaxType (CollectErrors es0 a0) Integer

max :: CollectErrors es0 a0 -> Integer -> MinMaxType (CollectErrors es0 a0) Integer

(CanSub a0 Double, CanEnsureCE es0 (SubType a0 Double), SuitableForCE es0) => CanSub (CollectErrors es0 a0) Double

Associated Types

type SubType (CollectErrors es0 a0) Double :: *

Methods

sub :: CollectErrors es0 a0 -> Double -> SubType (CollectErrors es0 a0) Double

(CanSub a0 Rational, CanEnsureCE es0 (SubType a0 Rational), SuitableForCE es0) => CanSub (CollectErrors es0 a0) Rational

Associated Types

type SubType (CollectErrors es0 a0) Rational :: *

Methods

sub :: CollectErrors es0 a0 -> Rational -> SubType (CollectErrors es0 a0) Rational

(CanSub a0 Int, CanEnsureCE es0 (SubType a0 Int), SuitableForCE es0) => CanSub (CollectErrors es0 a0) Int

Associated Types

type SubType (CollectErrors es0 a0) Int :: *

Methods

sub :: CollectErrors es0 a0 -> Int -> SubType (CollectErrors es0 a0) Int

(CanSub a0 Integer, CanEnsureCE es0 (SubType a0 Integer), SuitableForCE es0) => CanSub (CollectErrors es0 a0) Integer

Associated Types

type SubType (CollectErrors es0 a0) Integer :: *

Methods

sub :: CollectErrors es0 a0 -> Integer -> SubType (CollectErrors es0 a0) Integer

(CanAddAsymmetric a0 Double, CanEnsureCE es0 (AddType a0 Double), SuitableForCE es0) => CanAddAsymmetric (CollectErrors es0 a0) Double

Associated Types

type AddType (CollectErrors es0 a0) Double :: *

Methods

add :: CollectErrors es0 a0 -> Double -> AddType (CollectErrors es0 a0) Double

(CanAddAsymmetric a0 Rational, CanEnsureCE es0 (AddType a0 Rational), SuitableForCE es0) => CanAddAsymmetric (CollectErrors es0 a0) Rational

Associated Types

type AddType (CollectErrors es0 a0) Rational :: *

Methods

add :: CollectErrors es0 a0 -> Rational -> AddType (CollectErrors es0 a0) Rational

(CanAddAsymmetric a0 Int, CanEnsureCE es0 (AddType a0 Int), SuitableForCE es0) => CanAddAsymmetric (CollectErrors es0 a0) Int

Associated Types

type AddType (CollectErrors es0 a0) Int :: *

Methods

add :: CollectErrors es0 a0 -> Int -> AddType (CollectErrors es0 a0) Int

(CanAddAsymmetric a0 Integer, CanEnsureCE es0 (AddType a0 Integer), SuitableForCE es0) => CanAddAsymmetric (CollectErrors es0 a0) Integer

Associated Types

type AddType (CollectErrors es0 a0) Integer :: *

Methods

add :: CollectErrors es0 a0 -> Integer -> AddType (CollectErrors es0 a0) Integer

(CanPow a0 Double, CanEnsureCE es0 (PowType a0 Double), SuitableForCE es0) => CanPow (CollectErrors es0 a0) Double

Associated Types

type PowType (CollectErrors es0 a0) Double :: *

Methods

pow :: CollectErrors es0 a0 -> Double -> PowType (CollectErrors es0 a0) Double

(CanPow a0 Rational, CanEnsureCE es0 (PowType a0 Rational), SuitableForCE es0) => CanPow (CollectErrors es0 a0) Rational

Associated Types

type PowType (CollectErrors es0 a0) Rational :: *

Methods

pow :: CollectErrors es0 a0 -> Rational -> PowType (CollectErrors es0 a0) Rational

(CanPow a0 Int, CanEnsureCE es0 (PowType a0 Int), SuitableForCE es0) => CanPow (CollectErrors es0 a0) Int

Associated Types

type PowType (CollectErrors es0 a0) Int :: *

Methods

pow :: CollectErrors es0 a0 -> Int -> PowType (CollectErrors es0 a0) Int

(CanPow a0 Integer, CanEnsureCE es0 (PowType a0 Integer), SuitableForCE es0) => CanPow (CollectErrors es0 a0) Integer

Associated Types

type PowType (CollectErrors es0 a0) Integer :: *

Methods

pow :: CollectErrors es0 a0 -> Integer -> PowType (CollectErrors es0 a0) Integer

(CanMulAsymmetric a0 Double, CanEnsureCE es0 (MulType a0 Double), SuitableForCE es0) => CanMulAsymmetric (CollectErrors es0 a0) Double

Associated Types

type MulType (CollectErrors es0 a0) Double :: *

Methods

mul :: CollectErrors es0 a0 -> Double -> MulType (CollectErrors es0 a0) Double

(CanMulAsymmetric a0 Rational, CanEnsureCE es0 (MulType a0 Rational), SuitableForCE es0) => CanMulAsymmetric (CollectErrors es0 a0) Rational

Associated Types

type MulType (CollectErrors es0 a0) Rational :: *

Methods

mul :: CollectErrors es0 a0 -> Rational -> MulType (CollectErrors es0 a0) Rational

(CanMulAsymmetric a0 Int, CanEnsureCE es0 (MulType a0 Int), SuitableForCE es0) => CanMulAsymmetric (CollectErrors es0 a0) Int

Associated Types

type MulType (CollectErrors es0 a0) Int :: *

Methods

mul :: CollectErrors es0 a0 -> Int -> MulType (CollectErrors es0 a0) Int

(CanMulAsymmetric a0 Integer, CanEnsureCE es0 (MulType a0 Integer), SuitableForCE es0) => CanMulAsymmetric (CollectErrors es0 a0) Integer

Associated Types

type MulType (CollectErrors es0 a0) Integer :: *

Methods

mul :: CollectErrors es0 a0 -> Integer -> MulType (CollectErrors es0 a0) Integer

(CanDiv a0 Double, CanEnsureCE es0 (DivType a0 Double), CanEnsureCE es0 (DivTypeNoCN a0 Double), SuitableForCE es0) => CanDiv (CollectErrors es0 a0) Double

Associated Types

type DivTypeNoCN (CollectErrors es0 a0) Double :: *

type DivType (CollectErrors es0 a0) Double :: *

Methods

divideNoCN :: CollectErrors es0 a0 -> Double -> DivTypeNoCN (CollectErrors es0 a0) Double

divide :: CollectErrors es0 a0 -> Double -> DivType (CollectErrors es0 a0) Double

(CanDiv a0 Rational, CanEnsureCE es0 (DivType a0 Rational), CanEnsureCE es0 (DivTypeNoCN a0 Rational), SuitableForCE es0) => CanDiv (CollectErrors es0 a0) Rational

Associated Types

type DivTypeNoCN (CollectErrors es0 a0) Rational :: *

type DivType (CollectErrors es0 a0) Rational :: *

Methods

divideNoCN :: CollectErrors es0 a0 -> Rational -> DivTypeNoCN (CollectErrors es0 a0) Rational

divide :: CollectErrors es0 a0 -> Rational -> DivType (CollectErrors es0 a0) Rational

(CanDiv a0 Int, CanEnsureCE es0 (DivType a0 Int), CanEnsureCE es0 (DivTypeNoCN a0 Int), SuitableForCE es0) => CanDiv (CollectErrors es0 a0) Int

Associated Types

type DivTypeNoCN (CollectErrors es0 a0) Int :: *

type DivType (CollectErrors es0 a0) Int :: *

Methods

divideNoCN :: CollectErrors es0 a0 -> Int -> DivTypeNoCN (CollectErrors es0 a0) Int

divide :: CollectErrors es0 a0 -> Int -> DivType (CollectErrors es0 a0) Int

(CanDiv a0 Integer, CanEnsureCE es0 (DivType a0 Integer), CanEnsureCE es0 (DivTypeNoCN a0 Integer), SuitableForCE es0) => CanDiv (CollectErrors es0 a0) Integer

Associated Types

type DivTypeNoCN (CollectErrors es0 a0) Integer :: *

type DivType (CollectErrors es0 a0) Integer :: *

Methods

divideNoCN :: CollectErrors es0 a0 -> Integer -> DivTypeNoCN (CollectErrors es0 a0) Integer

divide :: CollectErrors es0 a0 -> Integer -> DivType (CollectErrors es0 a0) Integer

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

(CanAndOrAsymmetric t1 t2, SuitableForCE es, CanEnsureCE es (AndOrType t1 t2)) => CanAndOrAsymmetric (CollectErrors es t1) (CollectErrors es t2)

Associated Types

type AndOrType (CollectErrors es t1) (CollectErrors es t2) :: *

Methods

and2 :: CollectErrors es t1 -> CollectErrors es t2 -> AndOrType (CollectErrors es t1) (CollectErrors es t2)

or2 :: CollectErrors es t1 -> CollectErrors es t2 -> AndOrType (CollectErrors es t1) (CollectErrors es t2)

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

(HasOrderAsymmetric a b, CanEnsureCE es (OrderCompareType a b), IsBool (EnsureCE es (OrderCompareType a b)), SuitableForCE es) => HasOrderAsymmetric (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

lessThan :: CollectErrors es a -> CollectErrors es b -> OrderCompareType (CollectErrors es a) (CollectErrors es b)

greaterThan :: CollectErrors es a -> CollectErrors es b -> OrderCompareType (CollectErrors es a) (CollectErrors es b)

leq :: CollectErrors es a -> CollectErrors es b -> OrderCompareType (CollectErrors es a) (CollectErrors es b)

geq :: CollectErrors es a -> CollectErrors es b -> OrderCompareType (CollectErrors es a) (CollectErrors es b)

(CanMinMaxAsymmetric a b, CanEnsureCE es (MinMaxType a b), SuitableForCE es) => CanMinMaxAsymmetric (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

min :: CollectErrors es a -> CollectErrors es b -> MinMaxType (CollectErrors es a) (CollectErrors es b)

max :: CollectErrors es a -> CollectErrors es b -> MinMaxType (CollectErrors es a) (CollectErrors es b)

(CanSub a b, CanEnsureCE es (SubType a b), SuitableForCE es) => CanSub (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

sub :: CollectErrors es a -> CollectErrors es b -> SubType (CollectErrors es a) (CollectErrors es b)

(CanAddAsymmetric a b, CanEnsureCE es (AddType a b), SuitableForCE es) => CanAddAsymmetric (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

add :: CollectErrors es a -> CollectErrors es b -> AddType (CollectErrors es a) (CollectErrors es b)

(CanPow a b, CanEnsureCE es (PowType a b), SuitableForCE es) => CanPow (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

pow :: CollectErrors es a -> CollectErrors es b -> PowType (CollectErrors es a) (CollectErrors es b)

(CanMulAsymmetric a b, CanEnsureCE es (MulType a b), SuitableForCE es) => CanMulAsymmetric (CollectErrors es a) (CollectErrors es b)

Associated Types

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

Methods

mul :: CollectErrors es a -> CollectErrors es b -> MulType (CollectErrors es a) (CollectErrors es b)

(CanDiv a b, CanEnsureCE es (DivType a b), CanEnsureCE es (DivTypeNoCN a b), SuitableForCE es) => CanDiv (CollectErrors es a) (CollectErrors es b)

Associated Types

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

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

Methods

divideNoCN :: CollectErrors es a -> CollectErrors es b -> DivTypeNoCN (CollectErrors es a) (CollectErrors es b)

divide :: CollectErrors es a -> CollectErrors es b -> DivType (CollectErrors es a) (CollectErrors es b)

type EnsureCE es (CollectErrors es a)

type EnsureCE es (CollectErrors es a) = CollectErrors es a

type EnsureNoCE es (CollectErrors es a)

type EnsureNoCE es (CollectErrors es a) = a

type AndOrType Bool (CollectErrors es t2)

type AndOrType Bool (CollectErrors es t2) = EnsureCE es (AndOrType Bool t2)

type EqCompareType Bool (CollectErrors es0 b0)

type EqCompareType Bool (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType Bool b0)

type EqCompareType Double (CollectErrors es0 b0)

type EqCompareType Double (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType Double b0)

type EqCompareType Int (CollectErrors es0 b0)

type EqCompareType Int (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType Int b0)

type EqCompareType Integer (CollectErrors es0 b0)

type EqCompareType Integer (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType Integer b0)

type EqCompareType Rational (CollectErrors es0 b0)

type EqCompareType Rational (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType Rational b0)

type OrderCompareType Double (CollectErrors es0 b0)

type OrderCompareType Double (CollectErrors es0 b0) = EnsureCE es0 (OrderCompareType Double b0)

type OrderCompareType Int (CollectErrors es0 b0)

type OrderCompareType Int (CollectErrors es0 b0) = EnsureCE es0 (OrderCompareType Int b0)

type OrderCompareType Integer (CollectErrors es0 b0)

type OrderCompareType Integer (CollectErrors es0 b0) = EnsureCE es0 (OrderCompareType Integer b0)

type OrderCompareType Rational (CollectErrors es0 b0)

type OrderCompareType Rational (CollectErrors es0 b0) = EnsureCE es0 (OrderCompareType Rational b0)

type MinMaxType Double (CollectErrors es0 b0)

type MinMaxType Double (CollectErrors es0 b0) = EnsureCE es0 (MinMaxType Double b0)

type MinMaxType Int (CollectErrors es0 b0)

type MinMaxType Int (CollectErrors es0 b0) = EnsureCE es0 (MinMaxType Int b0)

type MinMaxType Integer (CollectErrors es0 b0)

type MinMaxType Integer (CollectErrors es0 b0) = EnsureCE es0 (MinMaxType Integer b0)

type MinMaxType Rational (CollectErrors es0 b0)

type MinMaxType Rational (CollectErrors es0 b0) = EnsureCE es0 (MinMaxType Rational b0)

type SubType Double (CollectErrors es0 b0)

type SubType Double (CollectErrors es0 b0) = EnsureCE es0 (SubType Double b0)

type SubType Int (CollectErrors es0 b0)

type SubType Int (CollectErrors es0 b0) = EnsureCE es0 (SubType Int b0)

type SubType Integer (CollectErrors es0 b0)

type SubType Integer (CollectErrors es0 b0) = EnsureCE es0 (SubType Integer b0)

type SubType Rational (CollectErrors es0 b0)

type SubType Rational (CollectErrors es0 b0) = EnsureCE es0 (SubType Rational b0)

type AddType Double (CollectErrors es0 b0)

type AddType Double (CollectErrors es0 b0) = EnsureCE es0 (AddType Double b0)

type AddType Int (CollectErrors es0 b0)

type AddType Int (CollectErrors es0 b0) = EnsureCE es0 (AddType Int b0)

type AddType Integer (CollectErrors es0 b0)

type AddType Integer (CollectErrors es0 b0) = EnsureCE es0 (AddType Integer b0)

type AddType Rational (CollectErrors es0 b0)

type AddType Rational (CollectErrors es0 b0) = EnsureCE es0 (AddType Rational b0)

type PowType Double (CollectErrors es0 b0)

type PowType Double (CollectErrors es0 b0) = EnsureCE es0 (PowType Double b0)

type PowType Int (CollectErrors es0 b0)

type PowType Int (CollectErrors es0 b0) = EnsureCE es0 (PowType Int b0)

type PowType Integer (CollectErrors es0 b0)

type PowType Integer (CollectErrors es0 b0) = EnsureCE es0 (PowType Integer b0)

type PowType Rational (CollectErrors es0 b0)

type PowType Rational (CollectErrors es0 b0) = EnsureCE es0 (PowType Rational b0)

type MulType Double (CollectErrors es0 b0)

type MulType Double (CollectErrors es0 b0) = EnsureCE es0 (MulType Double b0)

type MulType Int (CollectErrors es0 b0)

type MulType Int (CollectErrors es0 b0) = EnsureCE es0 (MulType Int b0)

type MulType Integer (CollectErrors es0 b0)

type MulType Integer (CollectErrors es0 b0) = EnsureCE es0 (MulType Integer b0)

type MulType Rational (CollectErrors es0 b0)

type MulType Rational (CollectErrors es0 b0) = EnsureCE es0 (MulType Rational b0)

type DivTypeNoCN Double (CollectErrors es0 b0)

type DivTypeNoCN Double (CollectErrors es0 b0) = EnsureCE es0 (DivTypeNoCN Double b0)

type DivTypeNoCN Int (CollectErrors es0 b0)

type DivTypeNoCN Int (CollectErrors es0 b0) = EnsureCE es0 (DivTypeNoCN Int b0)

type DivTypeNoCN Integer (CollectErrors es0 b0)

type DivTypeNoCN Integer (CollectErrors es0 b0) = EnsureCE es0 (DivTypeNoCN Integer b0)

type DivTypeNoCN Rational (CollectErrors es0 b0)

type DivTypeNoCN Rational (CollectErrors es0 b0) = EnsureCE es0 (DivTypeNoCN Rational b0)

type DivType Double (CollectErrors es0 b0)

type DivType Double (CollectErrors es0 b0) = EnsureCE es0 (DivType Double b0)

type DivType Int (CollectErrors es0 b0)

type DivType Int (CollectErrors es0 b0) = EnsureCE es0 (DivType Int b0)

type DivType Integer (CollectErrors es0 b0)

type DivType Integer (CollectErrors es0 b0) = EnsureCE es0 (DivType Integer b0)

type DivType Rational (CollectErrors es0 b0)

type DivType Rational (CollectErrors es0 b0) = EnsureCE es0 (DivType Rational b0)

type EqCompareType (Maybe Bool) (CollectErrors es0 b0)

type EqCompareType (Maybe Bool) (CollectErrors es0 b0) = EnsureCE es0 (EqCompareType (Maybe Bool) b0)

type NegType (CollectErrors es t)

type NegType (CollectErrors es t) = EnsureCE es (NegType t)

type AbsType (CollectErrors es a)

type AbsType (CollectErrors es a) = EnsureCE es (AbsType a)

type SinCosType (CollectErrors es a)

type SinCosType (CollectErrors es a) = EnsureCE es (SinCosType a)

type LogType (CollectErrors es a)

type LogType (CollectErrors es a) = EnsureCE es (LogType a)

type ExpType (CollectErrors es a)

type ExpType (CollectErrors es a) = EnsureCE es (ExpType a)

type SqrtType (CollectErrors es a)

type SqrtType (CollectErrors es a) = EnsureCE es (SqrtType a)

type AndOrType (CollectErrors es t1) Bool

type AndOrType (CollectErrors es t1) Bool = EnsureCE es (AndOrType t1 Bool)

type EqCompareType (CollectErrors es0 a0) Double

type EqCompareType (CollectErrors es0 a0) Double = EnsureCE es0 (EqCompareType a0 Double)

type EqCompareType (CollectErrors es0 a0) Rational

type EqCompareType (CollectErrors es0 a0) Rational = EnsureCE es0 (EqCompareType a0 Rational)

type EqCompareType (CollectErrors es0 a0) Int

type EqCompareType (CollectErrors es0 a0) Int = EnsureCE es0 (EqCompareType a0 Int)

type EqCompareType (CollectErrors es0 a0) Integer

type EqCompareType (CollectErrors es0 a0) Integer = EnsureCE es0 (EqCompareType a0 Integer)

type EqCompareType (CollectErrors es0 a0) Bool

type EqCompareType (CollectErrors es0 a0) Bool = EnsureCE es0 (EqCompareType a0 Bool)

type OrderCompareType (CollectErrors es0 a0) Double

type OrderCompareType (CollectErrors es0 a0) Double = EnsureCE es0 (OrderCompareType a0 Double)

type OrderCompareType (CollectErrors es0 a0) Rational

type OrderCompareType (CollectErrors es0 a0) Rational = EnsureCE es0 (OrderCompareType a0 Rational)

type OrderCompareType (CollectErrors es0 a0) Int

type OrderCompareType (CollectErrors es0 a0) Int = EnsureCE es0 (OrderCompareType a0 Int)

type OrderCompareType (CollectErrors es0 a0) Integer

type OrderCompareType (CollectErrors es0 a0) Integer = EnsureCE es0 (OrderCompareType a0 Integer)

type MinMaxType (CollectErrors es0 a0) Double

type MinMaxType (CollectErrors es0 a0) Double = EnsureCE es0 (MinMaxType a0 Double)

type MinMaxType (CollectErrors es0 a0) Rational

type MinMaxType (CollectErrors es0 a0) Rational = EnsureCE es0 (MinMaxType a0 Rational)

type MinMaxType (CollectErrors es0 a0) Int

type MinMaxType (CollectErrors es0 a0) Int = EnsureCE es0 (MinMaxType a0 Int)

type MinMaxType (CollectErrors es0 a0) Integer

type MinMaxType (CollectErrors es0 a0) Integer = EnsureCE es0 (MinMaxType a0 Integer)

type SubType (CollectErrors es0 a0) Double

type SubType (CollectErrors es0 a0) Double = EnsureCE es0 (SubType a0 Double)

type SubType (CollectErrors es0 a0) Rational

type SubType (CollectErrors es0 a0) Rational = EnsureCE es0 (SubType a0 Rational)

type SubType (CollectErrors es0 a0) Int

type SubType (CollectErrors es0 a0) Int = EnsureCE es0 (SubType a0 Int)

type SubType (CollectErrors es0 a0) Integer

type SubType (CollectErrors es0 a0) Integer = EnsureCE es0 (SubType a0 Integer)

type AddType (CollectErrors es0 a0) Double

type AddType (CollectErrors es0 a0) Double = EnsureCE es0 (AddType a0 Double)

type AddType (CollectErrors es0 a0) Rational

type AddType (CollectErrors es0 a0) Rational = EnsureCE es0 (AddType a0 Rational)

type AddType (CollectErrors es0 a0) Int

type AddType (CollectErrors es0 a0) Int = EnsureCE es0 (AddType a0 Int)

type AddType (CollectErrors es0 a0) Integer

type AddType (CollectErrors es0 a0) Integer = EnsureCE es0 (AddType a0 Integer)

type PowType (CollectErrors es0 a0) Double

type PowType (CollectErrors es0 a0) Double = EnsureCE es0 (PowType a0 Double)

type PowType (CollectErrors es0 a0) Rational

type PowType (CollectErrors es0 a0) Rational = EnsureCE es0 (PowType a0 Rational)

type PowType (CollectErrors es0 a0) Int

type PowType (CollectErrors es0 a0) Int = EnsureCE es0 (PowType a0 Int)

type PowType (CollectErrors es0 a0) Integer

type PowType (CollectErrors es0 a0) Integer = EnsureCE es0 (PowType a0 Integer)

type MulType (CollectErrors es0 a0) Double

type MulType (CollectErrors es0 a0) Double = EnsureCE es0 (MulType a0 Double)

type MulType (CollectErrors es0 a0) Rational

type MulType (CollectErrors es0 a0) Rational = EnsureCE es0 (MulType a0 Rational)

type MulType (CollectErrors es0 a0) Int

type MulType (CollectErrors es0 a0) Int = EnsureCE es0 (MulType a0 Int)

type MulType (CollectErrors es0 a0) Integer

type MulType (CollectErrors es0 a0) Integer = EnsureCE es0 (MulType a0 Integer)

type DivTypeNoCN (CollectErrors es0 a0) Double

type DivTypeNoCN (CollectErrors es0 a0) Double = EnsureCE es0 (DivTypeNoCN a0 Double)

type DivTypeNoCN (CollectErrors es0 a0) Rational

type DivTypeNoCN (CollectErrors es0 a0) Rational = EnsureCE es0 (DivTypeNoCN a0 Rational)

type DivTypeNoCN (CollectErrors es0 a0) Int

type DivTypeNoCN (CollectErrors es0 a0) Int = EnsureCE es0 (DivTypeNoCN a0 Int)

type DivTypeNoCN (CollectErrors es0 a0) Integer

type DivTypeNoCN (CollectErrors es0 a0) Integer = EnsureCE es0 (DivTypeNoCN a0 Integer)

type DivType (CollectErrors es0 a0) Double

type DivType (CollectErrors es0 a0) Double = EnsureCE es0 (DivType a0 Double)

type DivType (CollectErrors es0 a0) Rational

type DivType (CollectErrors es0 a0) Rational = EnsureCE es0 (DivType a0 Rational)

type DivType (CollectErrors es0 a0) Int

type DivType (CollectErrors es0 a0) Int = EnsureCE es0 (DivType a0 Int)

type DivType (CollectErrors es0 a0) Integer

type DivType (CollectErrors es0 a0) Integer = EnsureCE es0 (DivType a0 Integer)

type EqCompareType (CollectErrors es0 a0) (Maybe Bool)

type EqCompareType (CollectErrors es0 a0) (Maybe Bool) = EnsureCE es0 (EqCompareType a0 (Maybe Bool))

type AndOrType (CollectErrors es t1) (CollectErrors es t2)

type AndOrType (CollectErrors es t1) (CollectErrors es t2) = EnsureCE es (AndOrType t1 t2)

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

type EqCompareType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (EqCompareType a b)

type OrderCompareType (CollectErrors es a) (CollectErrors es b)

type OrderCompareType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (OrderCompareType a b)

type MinMaxType (CollectErrors es a) (CollectErrors es b)

type MinMaxType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (MinMaxType a b)

type SubType (CollectErrors es a) (CollectErrors es b)

type SubType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (SubType a b)

type AddType (CollectErrors es a) (CollectErrors es b)

type AddType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (AddType a b)

type PowType (CollectErrors es a) (CollectErrors es b)

type PowType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (PowType a b)

type MulType (CollectErrors es a) (CollectErrors es b)

type MulType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (MulType a b)

type DivTypeNoCN (CollectErrors es a) (CollectErrors es b)

type DivTypeNoCN (CollectErrors es a) (CollectErrors es b) = EnsureCE es (DivTypeNoCN a b)

type DivType (CollectErrors es a) (CollectErrors es b)

type DivType (CollectErrors es a) (CollectErrors es b) = EnsureCE es (DivType a b)

type SuitableForCE es = (Monoid es, Eq es, Show es)

noValueCE :: es -> CollectErrors es v

prependErrorsCE :: Monoid es => es -> CollectErrors es v -> CollectErrors es v

filterValuesWithoutErrorCE :: SuitableForCE es => [CollectErrors es v] -> [v]

getValueIfNoErrorCE :: SuitableForCE es => CollectErrors es v -> (v -> t) -> (es -> t) -> t

A safe way to get a value out of the CollectErrors wrapper.

ce2ConvertResult :: (Typeable t, Show t, SuitableForCE es) => CollectErrors es t -> Either ConvertError t

Tools for avoiding CollectErrors(CollectErrors t) and putting CE inside containers

class Monoid es => CanEnsureCE es a where

A mechanism for adding and removing CollectErrors to a type in a manner that depends on the shape of the type, especially whether it already has CollectErrors.

Associated Types

type EnsureCE es a

Add CollectErrors to a type except when the type already has CollectErrors in it.

type EnsureNoCE es a

Methods

ensureCE :: Maybe es -> a -> EnsureCE es a

Translate a value of a type a to a value of a type EnsureCE es a.

ensureCE :: EnsureCE es a ~ CollectErrors es a => Maybe es -> a -> EnsureCE es a

Translate a value of a type a to a value of a type EnsureCE es a.

deEnsureCE :: Maybe es -> EnsureCE es a -> Either es a

deEnsureCE :: (EnsureCE es a ~ CollectErrors es a, Eq es) => Maybe es -> EnsureCE es a -> Either es a

ensureNoCE :: Maybe es -> a -> Either es (EnsureNoCE es a)

ensureNoCE :: (EnsureNoCE es a ~ a, Eq es) => Maybe es -> a -> Either es (EnsureNoCE es a)

noValueECE :: Maybe a -> es -> EnsureCE es a

Make CollectErrors record with no value, only errors.

noValueECE :: EnsureCE es a ~ CollectErrors es a => Maybe a -> es -> CollectErrors es a

Make CollectErrors record with no value, only errors.

Instances

SuitableForCE es => CanEnsureCE es ()

Associated Types

type EnsureCE es () :: *

type EnsureNoCE es () :: *

Methods

ensureCE :: Maybe es -> () -> EnsureCE es ()

deEnsureCE :: Maybe es -> EnsureCE es () -> Either es ()

ensureNoCE :: Maybe es -> () -> Either es (EnsureNoCE es ())

noValueECE :: Maybe () -> es -> EnsureCE es ()

SuitableForCE es => CanEnsureCE es Char

Associated Types

type EnsureCE es Char :: *

type EnsureNoCE es Char :: *

Methods

ensureCE :: Maybe es -> Char -> EnsureCE es Char

deEnsureCE :: Maybe es -> EnsureCE es Char -> Either es Char

ensureNoCE :: Maybe es -> Char -> Either es (EnsureNoCE es Char)

noValueECE :: Maybe Char -> es -> EnsureCE es Char

SuitableForCE es => CanEnsureCE es Bool

Associated Types

type EnsureCE es Bool :: *

type EnsureNoCE es Bool :: *

Methods

ensureCE :: Maybe es -> Bool -> EnsureCE es Bool

deEnsureCE :: Maybe es -> EnsureCE es Bool -> Either es Bool

ensureNoCE :: Maybe es -> Bool -> Either es (EnsureNoCE es Bool)

noValueECE :: Maybe Bool -> es -> EnsureCE es Bool

SuitableForCE es => CanEnsureCE es Double

Associated Types

type EnsureCE es Double :: *

type EnsureNoCE es Double :: *

Methods

ensureCE :: Maybe es -> Double -> EnsureCE es Double

deEnsureCE :: Maybe es -> EnsureCE es Double -> Either es Double

ensureNoCE :: Maybe es -> Double -> Either es (EnsureNoCE es Double)

noValueECE :: Maybe Double -> es -> EnsureCE es Double

SuitableForCE es => CanEnsureCE es Rational

Associated Types

type EnsureCE es Rational :: *

type EnsureNoCE es Rational :: *

Methods

ensureCE :: Maybe es -> Rational -> EnsureCE es Rational

deEnsureCE :: Maybe es -> EnsureCE es Rational -> Either es Rational

ensureNoCE :: Maybe es -> Rational -> Either es (EnsureNoCE es Rational)

noValueECE :: Maybe Rational -> es -> EnsureCE es Rational

SuitableForCE es => CanEnsureCE es Integer

Associated Types

type EnsureCE es Integer :: *

type EnsureNoCE es Integer :: *

Methods

ensureCE :: Maybe es -> Integer -> EnsureCE es Integer

deEnsureCE :: Maybe es -> EnsureCE es Integer -> Either es Integer

ensureNoCE :: Maybe es -> Integer -> Either es (EnsureNoCE es Integer)

noValueECE :: Maybe Integer -> es -> EnsureCE es Integer

SuitableForCE es => CanEnsureCE es Int

Associated Types

type EnsureCE es Int :: *

type EnsureNoCE es Int :: *

Methods

ensureCE :: Maybe es -> Int -> EnsureCE es Int

deEnsureCE :: Maybe es -> EnsureCE es Int -> Either es Int

ensureNoCE :: Maybe es -> Int -> Either es (EnsureNoCE es Int)

noValueECE :: Maybe Int -> es -> EnsureCE es Int

(SuitableForCE es, CanEnsureCE es a) => CanEnsureCE es (Maybe a)

Associated Types

type EnsureCE es (Maybe a) :: *

type EnsureNoCE es (Maybe a) :: *

Methods

ensureCE :: Maybe es -> Maybe a -> EnsureCE es (Maybe a)

deEnsureCE :: Maybe es -> EnsureCE es (Maybe a) -> Either es (Maybe a)

ensureNoCE :: Maybe es -> Maybe a -> Either es (EnsureNoCE es (Maybe a))

noValueECE :: Maybe (Maybe a) -> es -> EnsureCE es (Maybe a)

SuitableForCE es => CanEnsureCE es (CollectErrors es a)

Associated Types

type EnsureCE es (CollectErrors es a) :: *

type EnsureNoCE es (CollectErrors es a) :: *

Methods

ensureCE :: Maybe es -> CollectErrors es a -> EnsureCE es (CollectErrors es a)

deEnsureCE :: Maybe es -> EnsureCE es (CollectErrors es a) -> Either es (CollectErrors es a)

ensureNoCE :: Maybe es -> CollectErrors es a -> Either es (EnsureNoCE es (CollectErrors es a))

noValueECE :: Maybe (CollectErrors es a) -> es -> EnsureCE es (CollectErrors es a)

getValueOrThrowErrorsNCE

Arguments

:: (SuitableForCE es, CanEnsureCE es v, Show v)

=> Maybe es

sample only

-> v

-> EnsureNoCE es v

An unsafe way to get a value out of an CollectErrors wrapper.

lift1CE :: (SuitableForCE es, CanEnsureCE es c) => (a -> c) -> CollectErrors es a -> EnsureCE es c

Add error collection support to an unary function whose result may already have collected errors.

lift2CE :: (SuitableForCE es, CanEnsureCE es c) => (a -> b -> c) -> CollectErrors es a -> CollectErrors es b -> EnsureCE es c

Add error collection support to a binary function whose result may already have collected errors.

lift2TCE :: (SuitableForCE es, CanEnsureCE es c) => (a -> b -> c) -> CollectErrors es a -> b -> EnsureCE es c

Add error collection support to a binary function whose result may already have collected errors. A version where the second operand is not lifted, only the first one.

lift2TLCE :: (SuitableForCE es, CanEnsureCE es c) => (a -> b -> c) -> a -> CollectErrors es b -> EnsureCE es c

Add error collection support to a binary function whose result may already have collected errors. A version where the first operand is not lifted, only the second one.