diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -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 (/!)
diff --git a/mixed-types-num.cabal b/mixed-types-num.cabal
--- a/mixed-types-num.cabal
+++ b/mixed-types-num.cabal
@@ -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
diff --git a/src/MixedTypesNumPrelude.hs b/src/MixedTypesNumPrelude.hs
--- a/src/MixedTypesNumPrelude.hs
+++ b/src/MixedTypesNumPrelude.hs
@@ -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
diff --git a/src/Numeric/MixedTypes/Complex.hs b/src/Numeric/MixedTypes/Complex.hs
--- a/src/Numeric/MixedTypes/Complex.hs
+++ b/src/Numeric/MixedTypes/Complex.hs
@@ -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)
+  |]))
diff --git a/src/Numeric/MixedTypes/Literals.hs b/src/Numeric/MixedTypes/Literals.hs
--- a/src/Numeric/MixedTypes/Literals.hs
+++ b/src/Numeric/MixedTypes/Literals.hs
@@ -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 ----}
 
diff --git a/test/Numeric/MixedTypes/AddSubSpec.hs b/test/Numeric/MixedTypes/AddSubSpec.hs
--- a/test/Numeric/MixedTypes/AddSubSpec.hs
+++ b/test/Numeric/MixedTypes/AddSubSpec.hs
@@ -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)
diff --git a/test/Numeric/MixedTypes/BoolSpec.hs b/test/Numeric/MixedTypes/BoolSpec.hs
--- a/test/Numeric/MixedTypes/BoolSpec.hs
+++ b/test/Numeric/MixedTypes/BoolSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.BoolSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec
 
diff --git a/test/Numeric/MixedTypes/EqOrdSpec.hs b/test/Numeric/MixedTypes/EqOrdSpec.hs
--- a/test/Numeric/MixedTypes/EqOrdSpec.hs
+++ b/test/Numeric/MixedTypes/EqOrdSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.EqOrdSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec
 
diff --git a/test/Numeric/MixedTypes/FieldSpec.hs b/test/Numeric/MixedTypes/FieldSpec.hs
--- a/test/Numeric/MixedTypes/FieldSpec.hs
+++ b/test/Numeric/MixedTypes/FieldSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.FieldSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec
 
diff --git a/test/Numeric/MixedTypes/LiteralsSpec.hs b/test/Numeric/MixedTypes/LiteralsSpec.hs
--- a/test/Numeric/MixedTypes/LiteralsSpec.hs
+++ b/test/Numeric/MixedTypes/LiteralsSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.LiteralsSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 import qualified Prelude as P
 
 -- import Text.Printf
diff --git a/test/Numeric/MixedTypes/MinMaxAbsSpec.hs b/test/Numeric/MixedTypes/MinMaxAbsSpec.hs
--- a/test/Numeric/MixedTypes/MinMaxAbsSpec.hs
+++ b/test/Numeric/MixedTypes/MinMaxAbsSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.MinMaxAbsSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec
 
diff --git a/test/Numeric/MixedTypes/RingSpec.hs b/test/Numeric/MixedTypes/RingSpec.hs
--- a/test/Numeric/MixedTypes/RingSpec.hs
+++ b/test/Numeric/MixedTypes/RingSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.RingSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec
 
diff --git a/test/Numeric/MixedTypes/RoundSpec.hs b/test/Numeric/MixedTypes/RoundSpec.hs
--- a/test/Numeric/MixedTypes/RoundSpec.hs
+++ b/test/Numeric/MixedTypes/RoundSpec.hs
@@ -11,7 +11,7 @@
 
 module Numeric.MixedTypes.RoundSpec (spec) where
 
-import Numeric.MixedTypes
+import MixedTypesNumPrelude
 
 import Test.Hspec