mixed-types-num 0.2 → 0.2.0.1

raw patch · 13 files changed

+152/−270 lines, 13 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• changelog.md +5/−1
• mixed-types-num.cabal +6/−2
• src/MixedTypesNumPrelude.hs +43/−40
• src/Numeric/MixedTypes/Complex.hs +75/−215
• src/Numeric/MixedTypes/Literals.hs +10/−4
• test/Numeric/MixedTypes/AddSubSpec.hs +6/−1
• test/Numeric/MixedTypes/BoolSpec.hs +1/−1
• test/Numeric/MixedTypes/EqOrdSpec.hs +1/−1
• test/Numeric/MixedTypes/FieldSpec.hs +1/−1
• test/Numeric/MixedTypes/LiteralsSpec.hs +1/−1
• test/Numeric/MixedTypes/MinMaxAbsSpec.hs +1/−1
• test/Numeric/MixedTypes/RingSpec.hs +1/−1
• test/Numeric/MixedTypes/RoundSpec.hs +1/−1

@@ -6,4 +6,8 @@   * CN, specialisation of CollectErrors to NumErrors   * numerical partial operators (eg division) return a CN type   * instances for Data.Complex-  ++* v 0.2.0.1+  * fix compilation bug in test suite+  * minor doc improvements+  * fix Complex instances of error-throwing division (/!)

@@ -1,5 +1,5 @@ name:           mixed-types-num-version:        0.2+version:        0.2.0.1 cabal-version:  >= 1.9.2 build-type:     Simple homepage:       https://github.com/michalkonecny/mixed-types-num@@ -16,9 +16,13 @@ Description:     This package provides a version of Prelude where     unary and binary operations such as @not@, @+@, @==@-    have their result type derived from the parameter type(s).+    have their result type derived from the parameter type(s)+    and thus supports mixed-type arithmetic and comparisons.     .     See module "MixedTypesNumPrelude" for further documentation.+    .+    /Ghci 8.0.* fails when loading this package/ due to ghc bug <https://ghc.haskell.org/trac/ghc/ticket/13385#ticket 13385>.+    This bug does not affect ghci 7.10.3 and ghci 8.2.1.  source-repository head   type:     git

@@ -18,17 +18,17 @@       * Dividing an integer by an integer, giving a rational, wrapped in the CN (ie Collecting NumErrors) monad:        >>> :t let n = 1 :: Integer in n/(n+1)-      CN Rational+      ...CN Rational        >>> :t 1/2-      CN Rational+      ...CN Rational        (Integer literals are always of type @Integer@, not @Num t => t@.)        * Adding an integer and a rational, giving a rational: -      >>> :t (length [x])+1/3-      CN Rational+      >>> :t (length [])+1/3+      ...CN Rational        The @CN@ monad is required because integer division can, in general, fail as it is a partial operation: @@ -40,52 +40,57 @@        When one is certain the division is well defined, one can remove @CN@ in several ways: -      >>> :t (1%2)  -- using Data.Ratio.(%), works only for integers-      Rational+      >>> :t (1%2)+      ...Rational -      >>> :t (1/!2)  -- this works for non-integer division too-      Rational+      Above we use (re-exported) Data.Ratio.(%), which means this trick works only for Integers. -      >>> :t (~!) (1/2) -- ~! removes CN from any type-      Rational+      >>> :t (1/!2)+      ...Rational +      This works also for non-integer division.++      >>> :t (~!) (1/2)+      ...Rational++      The (~!) operator removes CN from any type, throwing an exception if there are collected errors.+       The operator (/!) stands for division which throws an exception is the       denominator is 0.  It "propagates" any potential errors-      from the sub-expressions:+      from the sub-expressions.  For example:        >>> :t 1/!(1 - 1/n)-      CN Rational+      ...CN Rational -      The last example will throw an error exception when evaluated with @n=1@-      but it will not thrown any excetion when @n=0@+      The above expression will throw an error exception when evaluated with @n=1@+      but when @n=0@, it will not throw an excetion but return an error value.        * taking natural, integer and fractional power using the same operator:        >>> :t 2^2-      CN Integer+      ...CN Integer        >>> :t 2.0^(-2)-      CN Rational+      ...CN Rational        >>> :t (double 2)^(1/!2)-      Double+      ...Double -      The following examples require package <https://github.com/michalkonecny/aern2/aern2-real aern2-real>:+      The following examples require package <https://github.com/michalkonecny/aern2 aern2-real>:        >>> :t 2^(1/2)-      CauchyRealCN+      ...CauchyRealCN        >>> :t pi-      CauchyReal+      ...CauchyReal        >>> :t sqrt 2-      CauchyRealCN+      ...CauchyRealCN -      * comparing an integer with an (exact) real number, giving a seqeunce of @Maybe Bool@:+      * comparing an integer with an (exact) real number, giving a sequence of @Maybe Bool@: -      @-      if x < 0 then -x else x-      @+      >>> let abs2 x = if x < 0 then -x else x in (abs2 (pi - pi)) ? (bitsS 100)+      [0 ± <2^(-102)]        In the last example, @if@ is overloaded so that it works for conditions       of other types than @Bool@.  Here the condition has the type @Sequence (Maybe Bool)@.@@ -98,9 +103,7 @@     and the result type is given by associated     type families. For example: -    @-    (+) :: (CanAddAsymmetric t1 t2) => t1 -> t2 -> AddType t1 t2-    @+    > (+) :: (CanAddAsymmetric t1 t2) => t1 -> t2 -> AddType t1 t2      The type constraint @CanAdd t1 t2@ implies both     @CanAddAsymmetric t1 t2@ and @CanAddAsymmetric t2 t1@.@@ -123,15 +126,13 @@      * Inferred types can be very large. Eg for @f a b c = sqrt (a + b * c + 1)@ the inferred type is: -      @-      f: (CanMulAsymmetric t1 t2, CanAddAsymmetric t4 (MulType t1 t2),-          CanAddAsymmetric (AddType t4 (MulType t1 t2)) Integer,-          CanSqrt (AddType (AddType t4 (MulType t1 t2)) Integer)) =>-         t4-         -> t1-         -> t2-         -> SqrtType (AddType (AddType t4 (MulType t1 t2)) Integer)-      @+    >  f: (CanMulAsymmetric t1 t2, CanAddAsymmetric t4 (MulType t1 t2),+    >      CanAddAsymmetric (AddType t4 (MulType t1 t2)) Integer,+    >      CanSqrt (AddType (AddType t4 (MulType t1 t2)) Integer)) =>+    >     t4+    >     -> t1+    >     -> t2+    >     -> SqrtType (AddType (AddType t4 (MulType t1 t2)) Integer)      * Due to limitations of some versions of ghc, type inferrence sometimes fails.       Eg @add1 = (+ 1)@ fails (eg with ghc 8.0.2) unless we explicitly declare the type@@ -163,10 +164,12 @@   module Numeric.MixedTypes.Round,   module Numeric.MixedTypes.Ring,   module Numeric.MixedTypes.Field,-  (%),   module Numeric.MixedTypes.Elementary,+  module Numeric.MixedTypes.Complex,   module Numeric.CollectErrors,-  module Utils.TH.DeclForTypes+  module Utils.TH.DeclForTypes,+  -- * Re-export for convenient Rational literals+  (%) ) where @@ -184,4 +187,4 @@ import Numeric.MixedTypes.Ring import Numeric.MixedTypes.Field import Numeric.MixedTypes.Elementary-import Numeric.MixedTypes.Complex ()+import Numeric.MixedTypes.Complex

@@ -1,3 +1,4 @@+{-# LANGUAGE TemplateHaskell #-} {-|     Module      :  Numeric.MixedType.Complex     Description :  Instances for Data.Complex@@ -13,6 +14,7 @@  module Numeric.MixedTypes.Complex (+  tComplex ) where @@ -20,6 +22,8 @@ -- import qualified Prelude as P -- import Text.Printf +import Utils.TH.DeclForTypes+ import Data.Complex  import Numeric.MixedTypes.Literals@@ -31,6 +35,9 @@ import Numeric.MixedTypes.Field import Numeric.MixedTypes.Elementary +tComplex :: T t -> T (Complex t)+tComplex (T tName) = T ("(Complex " ++ tName ++ ")")+ instance (ConvertibleExactly Integer t) => (ConvertibleExactly Integer (Complex t))   where   safeConvertExactly n =@@ -67,38 +74,6 @@   type EqCompareType (Complex a) (Complex b) = EqCompareType a b   equalTo (a1 :+ i1) (a2 :+ i2) = (a1 == a2) && (i1 == i2) -instance (HasEqAsymmetric Integer b) => HasEqAsymmetric Integer (Complex b) where-  type EqCompareType Integer (Complex b) = EqCompareType Integer b-  equalTo n (a2 :+ i2) = (n == a2) && (0 == i2)--instance (HasEqAsymmetric a Integer) => HasEqAsymmetric (Complex a) Integer where-  type EqCompareType (Complex a) Integer = EqCompareType a Integer-  equalTo (a1 :+ i1) n = (a1 == n) && (i1 == 0)--instance (HasEqAsymmetric Rational b) => HasEqAsymmetric Rational (Complex b) where-  type EqCompareType Rational (Complex b) = EqCompareType Rational b-  equalTo n (a2 :+ i2) = (n == a2) && (0.0 == i2)--instance (HasEqAsymmetric a Rational) => HasEqAsymmetric (Complex a) Rational where-  type EqCompareType (Complex a) Rational = EqCompareType a Rational-  equalTo (a1 :+ i1) n = (a1 == n) && (i1 == 0.0)--instance (HasEqAsymmetric Int b) => HasEqAsymmetric Int (Complex b) where-  type EqCompareType Int (Complex b) = EqCompareType Int b-  equalTo n (a2 :+ i2) = (n == a2) && ((int 0) == i2)--instance (HasEqAsymmetric a Int) => HasEqAsymmetric (Complex a) Int where-  type EqCompareType (Complex a) Int = EqCompareType a Int-  equalTo (a1 :+ i1) n = (a1 == n) && (i1 == (int 0))--instance (HasEqAsymmetric Double b) => HasEqAsymmetric Double (Complex b) where-  type EqCompareType Double (Complex b) = EqCompareType Double b-  equalTo n (a2 :+ i2) = (n == a2) && ((double 0) == i2)--instance (HasEqAsymmetric a Double) => HasEqAsymmetric (Complex a) Double where-  type EqCompareType (Complex a) Double = EqCompareType a Double-  equalTo (a1 :+ i1) n = (a1 == n) && (i1 == (double 0))- instance (CanTestInteger t, CanTestZero t) => CanTestInteger (Complex t) where   certainlyNotInteger (a :+ i) =     certainlyNotInteger a || isCertainlyNonZero i@@ -115,74 +90,10 @@   type AddType (Complex a) (Complex b) = Complex (AddType a b)   add (a1 :+ i1) (a2 :+ i2) = (a1 + a2) :+ (i1 + i2) -instance (CanAddAsymmetric Integer b) => CanAddAsymmetric Integer (Complex b) where-  type AddType Integer (Complex b) = Complex (AddType Integer b)-  add n (a2 :+ i2) = (n + a2) :+ (0 + i2)--instance (CanAddAsymmetric a Integer) => CanAddAsymmetric (Complex a) Integer where-  type AddType (Complex a) Integer = Complex (AddType a Integer)-  add (a1 :+ i1) n = (a1 + n) :+ (i1 + 0)--instance (CanAddAsymmetric Rational b) => CanAddAsymmetric Rational (Complex b) where-  type AddType Rational (Complex b) = Complex (AddType Rational b)-  add n (a2 :+ i2) = (n + a2) :+ (0.0 + i2)--instance (CanAddAsymmetric a Rational) => CanAddAsymmetric (Complex a) Rational where-  type AddType (Complex a) Rational = Complex (AddType a Rational)-  add (a1 :+ i1) n = (a1 + n) :+ (i1 + 0.0)--instance (CanAddAsymmetric Int b) => CanAddAsymmetric Int (Complex b) where-  type AddType Int (Complex b) = Complex (AddType Int b)-  add n (a2 :+ i2) = (n + a2) :+ ((int 0) + i2)--instance (CanAddAsymmetric a Int) => CanAddAsymmetric (Complex a) Int where-  type AddType (Complex a) Int = Complex (AddType a Int)-  add (a1 :+ i1) n = (a1 + n) :+ (i1 + (int 0))--instance (CanAddAsymmetric Double b) => CanAddAsymmetric Double (Complex b) where-  type AddType Double (Complex b) = Complex (AddType Double b)-  add n (a2 :+ i2) = (n + a2) :+ ((double 0) + i2)--instance (CanAddAsymmetric a Double) => CanAddAsymmetric (Complex a) Double where-  type AddType (Complex a) Double = Complex (AddType a Double)-  add (a1 :+ i1) n = (a1 + n) :+ (i1 + (double 0))- instance (CanSub a b) => CanSub (Complex a) (Complex b) where   type SubType (Complex a) (Complex b) = Complex (SubType a b)   sub (a1 :+ i1) (a2 :+ i2) = (a1 - a2) :+ (i1 - i2) -instance (CanSub Integer b) => CanSub Integer (Complex b) where-  type SubType Integer (Complex b) = Complex (SubType Integer b)-  sub n (a2 :+ i2) = (n - a2) :+ (0 - i2)--instance (CanSub a Integer) => CanSub (Complex a) Integer where-  type SubType (Complex a) Integer = Complex (SubType a Integer)-  sub (a1 :+ i1) n = (a1 - n) :+ (i1 - 0)--instance (CanSub Rational b) => CanSub Rational (Complex b) where-  type SubType Rational (Complex b) = Complex (SubType Rational b)-  sub n (a2 :+ i2) = (n - a2) :+ (0.0 - i2)--instance (CanSub a Rational) => CanSub (Complex a) Rational where-  type SubType (Complex a) Rational = Complex (SubType a Rational)-  sub (a1 :+ i1) n = (a1 - n) :+ (i1 - 0.0)--instance (CanSub Int b) => CanSub Int (Complex b) where-  type SubType Int (Complex b) = Complex (SubType Int b)-  sub n (a2 :+ i2) = (n - a2) :+ ((int 0) - i2)--instance (CanSub a Int) => CanSub (Complex a) Int where-  type SubType (Complex a) Int = Complex (SubType a Int)-  sub (a1 :+ i1) n = (a1 - n) :+ (i1 - (int 0))--instance (CanSub Double b) => CanSub Double (Complex b) where-  type SubType Double (Complex b) = Complex (SubType Double b)-  sub n (a2 :+ i2) = (n - a2) :+ ((double 0) - i2)--instance (CanSub a Double) => CanSub (Complex a) Double where-  type SubType (Complex a) Double = Complex (SubType a Double)-  sub (a1 :+ i1) n = (a1 - n) :+ (i1 - (double 0))- instance   (CanMulAsymmetric a b   , CanAddSameType (MulType a b), CanSubSameType (MulType a b))@@ -194,54 +105,6 @@     (a1*a2 - i1*i2) :+ (a1*i2 + i1*a2)  instance-  (CanMulAsymmetric Integer b) => CanMulAsymmetric Integer (Complex b)-  where-  type MulType Integer (Complex b) = Complex (MulType Integer b)-  mul n (a2 :+ i2) = (n*a2) :+ (n*i2)--instance-  (CanMulAsymmetric a Integer) => CanMulAsymmetric (Complex a) Integer-  where-  type MulType (Complex a) Integer = Complex (MulType a Integer)-  mul (a1 :+ i1) n = (a1*n) :+ (i1*n)--instance-  (CanMulAsymmetric Int b) => CanMulAsymmetric Int (Complex b)-  where-  type MulType Int (Complex b) = Complex (MulType Int b)-  mul n (a2 :+ i2) = (n*a2) :+ (n*i2)--instance-  (CanMulAsymmetric a Int) => CanMulAsymmetric (Complex a) Int-  where-  type MulType (Complex a) Int = Complex (MulType a Int)-  mul (a1 :+ i1) n = (a1*n) :+ (i1*n)--instance-  (CanMulAsymmetric Rational b) => CanMulAsymmetric Rational (Complex b)-  where-  type MulType Rational (Complex b) = Complex (MulType Rational b)-  mul n (a2 :+ i2) = (n*a2) :+ (n*i2)--instance-  (CanMulAsymmetric a Rational) => CanMulAsymmetric (Complex a) Rational-  where-  type MulType (Complex a) Rational = Complex (MulType a Rational)-  mul (a1 :+ i1) n = (a1*n) :+ (i1*n)--instance-  (CanMulAsymmetric Double b) => CanMulAsymmetric Double (Complex b)-  where-  type MulType Double (Complex b) = Complex (MulType Double b)-  mul n (a2 :+ i2) = (n*a2) :+ (n*i2)--instance-  (CanMulAsymmetric a Double) => CanMulAsymmetric (Complex a) Double-  where-  type MulType (Complex a) Double = Complex (MulType a Double)-  mul (a1 :+ i1) n = (a1*n) :+ (i1*n)--instance   (CanMulAsymmetric a b   , CanAddSameType (MulType a b), CanSubSameType (MulType a b)   , CanMulAsymmetric b b, CanAddSameType (MulType b b)@@ -253,78 +116,10 @@   divide (a1 :+ i1) (a2 :+ i2) =     let d = a2*a2 + i2*i2 in     ((a1*a2 + i1*i2)/d) :+ ((i1*a2-a1*i2)/d)--instance-  (CanMulAsymmetric Integer b-  , CanMulAsymmetric b b, CanAddSameType (MulType b b)-  , CanDiv (MulType Integer b) (MulType b b))-  =>-  CanDiv Integer (Complex b)-  where-  type DivType Integer (Complex b) = Complex (DivType (MulType Integer b) (MulType b b))-  divide n (a2 :+ i2) =-    let d = a2*a2 + i2*i2 in-    ((n*a2)/d) :+ (((-n)*i2)/d)--instance-  (CanMulAsymmetric Rational b-  , CanMulAsymmetric b b, CanAddSameType (MulType b b)-  , CanDiv (MulType Rational b) (MulType b b))-  =>-  CanDiv Rational (Complex b)-  where-  type DivType Rational (Complex b) = Complex (DivType (MulType Rational b) (MulType b b))-  divide n (a2 :+ i2) =-    let d = a2*a2 + i2*i2 in-    ((n*a2)/d) :+ (((-n)*i2)/d)--instance-  (CanMulAsymmetric Int b-  , CanMulAsymmetric b b, CanAddSameType (MulType b b)-  , CanDiv (MulType Int b) (MulType b b))-  =>-  CanDiv Int (Complex b)-  where-  type DivType Int (Complex b) = Complex (DivType (MulType Int b) (MulType b b))-  divide n (a2 :+ i2) =-    let d = a2*a2 + i2*i2 in-    ((n*a2)/d) :+ (((-n)*i2)/d)--instance-  (CanMulAsymmetric Double b-  , CanMulAsymmetric b b, CanAddSameType (MulType b b)-  , CanDiv (MulType Double b) (MulType b b))-  =>-  CanDiv Double (Complex b)-  where-  type DivType Double (Complex b) = Complex (DivType (MulType Double b) (MulType b b))-  divide n (a2 :+ i2) =+  type DivTypeNoCN (Complex a) (Complex b) = Complex (DivTypeNoCN (MulType a b) (MulType b b))+  divideNoCN (a1 :+ i1) (a2 :+ i2) =     let d = a2*a2 + i2*i2 in-    ((n*a2)/d) :+ (((-n)*i2)/d)--instance-  (CanDiv a Integer) => CanDiv (Complex a) Integer-  where-  type DivType (Complex a) Integer = Complex (DivType a Integer)-  divide (a1 :+ i1) n = (a1/n) :+ (i1/n)--instance-  (CanDiv a Int) => CanDiv (Complex a) Int-  where-  type DivType (Complex a) Int = Complex (DivType a Int)-  divide (a1 :+ i1) n = (a1/n) :+ (i1/n)--instance-  (CanDiv a Rational) => CanDiv (Complex a) Rational-  where-  type DivType (Complex a) Rational = Complex (DivType a Rational)-  divide (a1 :+ i1) n = (a1/n) :+ (i1/n)--instance-  (CanDiv a Double) => CanDiv (Complex a) Double-  where-  type DivType (Complex a) Double = Complex (DivType a Double)-  divide (a1 :+ i1) n = (a1/n) :+ (i1/n)+    ((a1*a2 + i1*i2)/!d) :+ ((i1*a2-a1*i2)/!d)  instance   (CanMulAsymmetric t t@@ -347,3 +142,68 @@   exp (a :+ i) =     let ea = exp a in     (ea * cos i) :+ (ea * sin i)++$(declForTypes+  [[t| Integer |], [t| Int |], [t| Rational |], [t| Double |]]+  (\ t -> [d|++    instance (HasEqAsymmetric $t b) => HasEqAsymmetric $t (Complex b) where+      type EqCompareType $t (Complex b) = EqCompareType $t b+      equalTo n (a2 :+ i2) = (n == a2) && (convertExactlyTargetSample n 0 == i2)++    instance (HasEqAsymmetric a $t) => HasEqAsymmetric (Complex a) $t where+      type EqCompareType (Complex a) $t = EqCompareType a $t+      equalTo (a1 :+ i1) n = (a1 == n) && (i1 == convertExactlyTargetSample n 0)++    instance (CanAddAsymmetric $t b) => CanAddAsymmetric $t (Complex b) where+      type AddType $t (Complex b) = Complex (AddType $t b)+      add n (a2 :+ i2) = (n + a2) :+ (convertExactlyTargetSample n 0 + i2)++    instance (CanAddAsymmetric a $t) => CanAddAsymmetric (Complex a) $t where+      type AddType (Complex a) $t = Complex (AddType a $t)+      add (a1 :+ i1) n = (a1 + n) :+ (i1 + (convertExactlyTargetSample n 0))++    instance (CanSub $t b) => CanSub $t (Complex b) where+      type SubType $t (Complex b) = Complex (SubType $t b)+      sub n (a2 :+ i2) = (n - a2) :+ (convertExactlyTargetSample n 0 - i2)++    instance (CanSub a $t) => CanSub (Complex a) $t where+      type SubType (Complex a) $t = Complex (SubType a $t)+      sub (a1 :+ i1) n = (a1 - n) :+ (i1 - (convertExactlyTargetSample n 0))++    instance+      (CanMulAsymmetric $t b) => CanMulAsymmetric $t (Complex b)+      where+      type MulType $t (Complex b) = Complex (MulType $t b)+      mul n (a2 :+ i2) = (n*a2) :+ (n*i2)++    instance+      (CanMulAsymmetric a $t) => CanMulAsymmetric (Complex a) $t+      where+      type MulType (Complex a) $t = Complex (MulType a $t)+      mul (a1 :+ i1) n = (a1*n) :+ (i1*n)++    instance+      (CanMulAsymmetric $t b+      , CanMulAsymmetric b b, CanAddSameType (MulType b b)+      , CanDiv (MulType $t b) (MulType b b))+      =>+      CanDiv $t (Complex b)+      where+      type DivType $t (Complex b) = Complex (DivType (MulType $t b) (MulType b b))+      divide n (a2 :+ i2) =+        let d = a2*a2 + i2*i2 in+        ((n*a2)/d) :+ (((-n)*i2)/d)+      type DivTypeNoCN $t (Complex b) = Complex (DivTypeNoCN (MulType $t b) (MulType b b))+      divideNoCN n (a2 :+ i2) =+        let d = a2*a2 + i2*i2 in+        ((n*a2)/!d) :+ (((-n)*i2)/!d)++    instance+      (CanDiv a $t) => CanDiv (Complex a) $t+      where+      type DivType (Complex a) $t = Complex (DivType a $t)+      divide (a1 :+ i1) n = (a1/n) :+ (i1/n)+      type DivTypeNoCN (Complex a) $t = Complex (DivTypeNoCN a $t)+      divideNoCN (a1 :+ i1) n = (a1/!n) :+ (i1/!n)+  |]))

@@ -44,13 +44,13 @@   , CanBeInt, int, ints   , CanBeRational, rational, rationals, HasRationals, fromRational_   , CanBeDouble, double, doubles-  , ConvertibleExactly(..), convertExactly+  , ConvertibleExactly(..), convertExactly, convertExactlyTargetSample   , ConvertResult, ConvertError, convError   -- * Generic list index   , (!!), specCanBeInteger, printArgsIfFails2   -- * Testing support functions   , T(..), tInt, tInteger, tRational, tDouble-  , tBool, tMaybeBool, tMaybeMaybeBool+  , tBool, tMaybe, tMaybeBool, tMaybeMaybeBool   -- * Helper functions   , convertFirst, convertSecond   , convertFirstUsing, convertSecondUsing@@ -177,6 +177,9 @@     Right v -> v     Left err -> error (show err) +convertExactlyTargetSample :: (ConvertibleExactly t1 t2) => t2 -> t1 -> t2+convertExactlyTargetSample _sample = convertExactly+ instance ConvertibleExactly Integer Integer -- use CVT instance by default instance ConvertibleExactly Int Integer @@ -233,11 +236,14 @@ tBool :: T Bool tBool = T "Bool" +tMaybe :: T t -> T (Maybe t)+tMaybe (T tName) = T ("(Maybe " ++ tName ++ ")")+ tMaybeBool :: T (Maybe Bool)-tMaybeBool = T "(Maybe Bool)"+tMaybeBool = tMaybe tBool  tMaybeMaybeBool :: T (Maybe (Maybe Bool))-tMaybeMaybeBool = T "(Maybe (Maybe Bool))"+tMaybeMaybeBool = tMaybe tMaybeBool  {---- Auxiliary functions ----} 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.AddSubSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec @@ -20,13 +20,18 @@   specCanAddNotMixed tInt   specCanAddNotMixed tInteger   specCanAddNotMixed tRational+  -- specCanAddNotMixed (tComplex tRational)   specCanAdd tInt tInteger tRational   specCanAdd tInteger tRational tInt+  -- specCanAdd tInteger tRational (tComplex tRational)   specCanAddSameType tInteger   specCanAddSameType tRational+  -- specCanAddSameType (tComplex tRational)   specCanSubNotMixed tInt   specCanSubNotMixed tInteger   specCanSubNotMixed tRational+  -- specCanSubNotMixed (tComplex tRational)   specCanSub tInt tInteger   specCanSub tInt tRational   specCanSub tInteger tRational+  -- specCanSub tInteger (tComplex tRational)

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.BoolSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.EqOrdSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.FieldSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.LiteralsSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude import qualified Prelude as P  -- import Text.Printf

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.MinMaxAbsSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.RingSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec 

@@ -11,7 +11,7 @@  module Numeric.MixedTypes.RoundSpec (spec) where -import Numeric.MixedTypes+import MixedTypesNumPrelude  import Test.Hspec