diff --git a/aern2-mp.cabal b/aern2-mp.cabal
--- a/aern2-mp.cabal
+++ b/aern2-mp.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           aern2-mp
-version:        0.2.6.0
+version:        0.2.7.0
 synopsis:       Multi-precision ball (interval) arithmetic
 description:    Please see the README on GitHub at <https://github.com/michalkonecny/aern2/#readme>
 category:       Math
@@ -89,7 +89,7 @@
     , deepseq
     , hspec
     , integer-logarithms
-    , mixed-types-num >=0.5.7
+    , mixed-types-num >=0.5.8
     , reflection
     , regex-tdfa
     , template-haskell
@@ -129,7 +129,7 @@
     , deepseq
     , hspec
     , integer-logarithms
-    , mixed-types-num >=0.5.7
+    , mixed-types-num >=0.5.8
     , reflection
     , regex-tdfa
     , template-haskell
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,10 @@
 # Change log for aern2-mp
 
+* v 0.2.7 2021-06-02
+  * make WithCurrentPrec p (CN MPBall) a Field
+  * simplify WithCurrentPrec, swap its parameters
+* v 0.2.6 2021-05-29
+  * adapt to new ppow operations
 * v 0.2.5 2021-05-27
   * add generic multivalued select + Kleenean instances
   * WithCurrentPrec: add MixedTypesNumPrelude class instances
diff --git a/src/AERN2/MP/Ball.hs b/src/AERN2/MP/Ball.hs
--- a/src/AERN2/MP/Ball.hs
+++ b/src/AERN2/MP/Ball.hs
@@ -57,15 +57,11 @@
 
 instance Ring MPBall
 instance Ring (CN MPBall)
-instance Field MPBall
-instance Field (CN MPBall)
 
 instance OrderedRing MPBall
 instance OrderedRing (CN MPBall)
-instance OrderedField MPBall
-instance OrderedField (CN MPBall)
 
 instance OrderedCertainlyRing MPBall
 instance OrderedCertainlyRing (CN MPBall)
-instance OrderedCertainlyField MPBall
-instance OrderedCertainlyField (CN MPBall)
+
+-- Field instances available only with the WithCurrentPrec wrapper so thta Rationals can be cleanly embedded
diff --git a/src/AERN2/MP/WithCurrentPrec.hs b/src/AERN2/MP/WithCurrentPrec.hs
--- a/src/AERN2/MP/WithCurrentPrec.hs
+++ b/src/AERN2/MP/WithCurrentPrec.hs
@@ -4,6 +4,7 @@
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE StandaloneDeriving #-}
+{-# OPTIONS_GHC -Wno-orphans #-}
 {-|
     Module      :  AERN2.MP.WithCurrentPrec
     Description :  Type wrapper setting default precision
@@ -20,21 +21,31 @@
 -}
 module AERN2.MP.WithCurrentPrec
 (
-    WithCurrentPrec(..), runWithPrec, HasCurrentPrecision(..)
+    WithCurrentPrec(..), runWithPrec
     , WithAnyPrec(..)
-    , mpBallCP
+    , cnmpBallCP
     , piCP
     -- , _example1 , _example2 , _example3
     -- , _example1P , _example2P , _example3P
 )
 where
 
--- import MixedTypesNumPrelude
+import MixedTypesNumPrelude
 -- import qualified Prelude as P
 -- import Text.Printf
 
+import GHC.TypeNats
+
 import AERN2.MP.WithCurrentPrec.Type
 import AERN2.MP.WithCurrentPrec.Comparisons ()
 import AERN2.MP.WithCurrentPrec.Field ()
 import AERN2.MP.WithCurrentPrec.Elementary (piCP)
+import AERN2.MP.WithCurrentPrec.Limit ()
 import AERN2.MP.WithCurrentPrec.PreludeInstances ()
+
+import AERN2.MP.Ball
+
+instance (KnownNat p) => Ring (WithCurrentPrec p (CN MPBall))
+instance (KnownNat p) => Field (WithCurrentPrec p (CN MPBall))
+instance (KnownNat p) => OrderedRing (WithCurrentPrec p (CN MPBall))
+instance (KnownNat p) => OrderedField (WithCurrentPrec p (CN MPBall))
diff --git a/src/AERN2/MP/WithCurrentPrec/Comparisons.hs b/src/AERN2/MP/WithCurrentPrec/Comparisons.hs
--- a/src/AERN2/MP/WithCurrentPrec/Comparisons.hs
+++ b/src/AERN2/MP/WithCurrentPrec/Comparisons.hs
@@ -34,18 +34,18 @@
 instance
     (HasEqAsymmetric t1 t2, p1 ~ p2)
     =>
-    HasEqAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) 
+    HasEqAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) 
     where
-    type EqCompareType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = EqCompareType t1 t2
+    type EqCompareType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = EqCompareType t1 t2
     equalTo = lift2P equalTo
     notEqualTo = lift2P notEqualTo
 
 instance
     (HasOrderAsymmetric t1 t2, p1 ~ p2)
     =>
-    HasOrderAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) 
+    HasOrderAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) 
     where
-    type OrderCompareType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = OrderCompareType t1 t2
+    type OrderCompareType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = OrderCompareType t1 t2
     greaterThan = lift2P greaterThan
     lessThan = lift2P lessThan
     geq = lift2P geq
@@ -54,17 +54,17 @@
 instance
     (CanAbs t)
     =>
-    CanAbs (WithCurrentPrec t p)
+    CanAbs (WithCurrentPrec p t)
     where
-    type AbsType (WithCurrentPrec t p) = WithCurrentPrec (AbsType t) p
+    type AbsType (WithCurrentPrec p t) = WithCurrentPrec p (AbsType t)
     abs = lift1 abs
 
 instance
     (CanMinMaxAsymmetric t1 t2, p1 ~ p2)
     =>
-    CanMinMaxAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) 
+    CanMinMaxAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) 
     where
-    type MinMaxType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (MinMaxType t1 t2) p1
+    type MinMaxType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (MinMaxType t1 t2)
     min = lift2 min
     max = lift2 max
 
@@ -79,36 +79,36 @@
     instance
       (CanMinMaxAsymmetric a $t)
       => 
-      CanMinMaxAsymmetric (WithCurrentPrec a p) $t
+      CanMinMaxAsymmetric (WithCurrentPrec p a) $t
       where
-      type MinMaxType (WithCurrentPrec a p) $t = WithCurrentPrec (MinMaxType a $t) p
+      type MinMaxType (WithCurrentPrec p a) $t = WithCurrentPrec p (MinMaxType a $t)
       min = lift1T min
       max = lift1T max
 
     instance
       (CanMinMaxAsymmetric a (CN $t))
       => 
-      CanMinMaxAsymmetric (WithCurrentPrec a p) (CN $t)
+      CanMinMaxAsymmetric (WithCurrentPrec p a) (CN $t)
       where
-      type MinMaxType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (MinMaxType a (CN $t)) p
+      type MinMaxType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (MinMaxType a (CN $t))
       min = lift1T min
       max = lift1T max
 
     instance
       (CanMinMaxAsymmetric $t a)
       => 
-      CanMinMaxAsymmetric $t (WithCurrentPrec a p)
+      CanMinMaxAsymmetric $t (WithCurrentPrec p a)
       where
-      type MinMaxType $t (WithCurrentPrec a p) = WithCurrentPrec (MinMaxType $t a) p
+      type MinMaxType $t (WithCurrentPrec p a) = WithCurrentPrec p (MinMaxType $t a)
       min = liftT1 min
       max = liftT1 max
 
     instance
       (CanMinMaxAsymmetric (CN $t) a)
       => 
-      CanMinMaxAsymmetric (CN $t) (WithCurrentPrec a p)
+      CanMinMaxAsymmetric (CN $t) (WithCurrentPrec p a)
       where
-      type MinMaxType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (MinMaxType (CN $t) a) p
+      type MinMaxType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (MinMaxType (CN $t) a)
       min = liftT1 min
       max = liftT1 max
 
@@ -117,36 +117,36 @@
     instance
       (HasEqAsymmetric a $t)
       => 
-      HasEqAsymmetric (WithCurrentPrec a p) $t
+      HasEqAsymmetric (WithCurrentPrec p a) $t
       where
-      type EqCompareType (WithCurrentPrec a p) $t = EqCompareType a $t
+      type EqCompareType (WithCurrentPrec p a) $t = EqCompareType a $t
       equalTo = lift1TP (==)
       notEqualTo = lift1TP (/=)
 
     instance
       (HasEqAsymmetric a (CN $t))
       => 
-      HasEqAsymmetric (WithCurrentPrec a p) (CN $t)
+      HasEqAsymmetric (WithCurrentPrec p a) (CN $t)
       where
-      type EqCompareType (WithCurrentPrec a p) (CN $t) = EqCompareType a (CN $t)
+      type EqCompareType (WithCurrentPrec p a) (CN $t) = EqCompareType a (CN $t)
       equalTo = lift1TP (==)
       notEqualTo = lift1TP (/=)
 
     instance
       (HasEqAsymmetric $t a)
       =>
-      HasEqAsymmetric $t (WithCurrentPrec a p)
+      HasEqAsymmetric $t (WithCurrentPrec p a)
       where
-      type EqCompareType $t (WithCurrentPrec a p) = EqCompareType $t a
+      type EqCompareType $t (WithCurrentPrec p a) = EqCompareType $t a
       equalTo = liftT1P (==)
       notEqualTo = liftT1P (/=)
 
     instance
       (HasEqAsymmetric (CN $t) a)
       =>
-      HasEqAsymmetric (CN $t) (WithCurrentPrec a p)
+      HasEqAsymmetric (CN $t) (WithCurrentPrec p a)
       where
-      type EqCompareType (CN $t) (WithCurrentPrec a p) = EqCompareType (CN $t) a
+      type EqCompareType (CN $t) (WithCurrentPrec p a) = EqCompareType (CN $t) a
       equalTo = liftT1P (==)
       notEqualTo = liftT1P (/=)
 
@@ -155,9 +155,9 @@
     instance
       (HasOrderAsymmetric a $t)
       => 
-      HasOrderAsymmetric (WithCurrentPrec a p) $t
+      HasOrderAsymmetric (WithCurrentPrec p a) $t
       where
-      type OrderCompareType (WithCurrentPrec a p) $t = OrderCompareType a $t
+      type OrderCompareType (WithCurrentPrec p a) $t = OrderCompareType a $t
       lessThan = lift1TP lessThan
       greaterThan = lift1TP greaterThan
       leq = lift1TP leq
@@ -166,9 +166,9 @@
     instance
       (HasOrderAsymmetric a (CN $t))
       => 
-      HasOrderAsymmetric (WithCurrentPrec a p) (CN $t)
+      HasOrderAsymmetric (WithCurrentPrec p a) (CN $t)
       where
-      type OrderCompareType (WithCurrentPrec a p) (CN $t) = OrderCompareType a (CN $t)
+      type OrderCompareType (WithCurrentPrec p a) (CN $t) = OrderCompareType a (CN $t)
       lessThan = lift1TP lessThan
       greaterThan = lift1TP greaterThan
       leq = lift1TP leq
@@ -177,9 +177,9 @@
     instance
       (HasOrderAsymmetric $t a)
       =>
-      HasOrderAsymmetric $t (WithCurrentPrec a p)
+      HasOrderAsymmetric $t (WithCurrentPrec p a)
       where
-      type OrderCompareType $t (WithCurrentPrec a p) = OrderCompareType $t a
+      type OrderCompareType $t (WithCurrentPrec p a) = OrderCompareType $t a
       lessThan = liftT1P lessThan
       greaterThan = liftT1P greaterThan
       leq = liftT1P leq
@@ -188,9 +188,9 @@
     instance
       (HasOrderAsymmetric (CN $t) a)
       =>
-      HasOrderAsymmetric (CN $t) (WithCurrentPrec a p)
+      HasOrderAsymmetric (CN $t) (WithCurrentPrec p a)
       where
-      type OrderCompareType (CN $t) (WithCurrentPrec a p) = OrderCompareType (CN $t) a
+      type OrderCompareType (CN $t) (WithCurrentPrec p a) = OrderCompareType (CN $t) a
       lessThan = liftT1P lessThan
       greaterThan = liftT1P greaterThan
       leq = liftT1P leq
diff --git a/src/AERN2/MP/WithCurrentPrec/Elementary.hs b/src/AERN2/MP/WithCurrentPrec/Elementary.hs
--- a/src/AERN2/MP/WithCurrentPrec/Elementary.hs
+++ b/src/AERN2/MP/WithCurrentPrec/Elementary.hs
@@ -38,7 +38,7 @@
 
 import AERN2.MP.WithCurrentPrec.Field ()
 
-piCP :: (KnownNat p) => WithCurrentPrec (CN MPBall) p
+piCP :: (KnownNat p) => WithCurrentPrec p (CN MPBall)
 piCP = r 
     where
     r = WithCurrentPrec $ cn $ piBallP (getCurrentPrecision r)
@@ -46,41 +46,41 @@
 instance
     (CanSinCos t)
     =>
-    CanSinCos (WithCurrentPrec t p)
+    CanSinCos (WithCurrentPrec p t)
     where
-    type SinCosType (WithCurrentPrec t p) = WithCurrentPrec (SinCosType t) p
+    type SinCosType (WithCurrentPrec p t) = WithCurrentPrec p (SinCosType t)
     sin = lift1 sin
     cos = lift1 cos
 
 instance
     (CanSqrt t)
     =>
-    CanSqrt (WithCurrentPrec t p)
+    CanSqrt (WithCurrentPrec p t)
     where
-    type SqrtType (WithCurrentPrec t p) = WithCurrentPrec (SqrtType t) p
+    type SqrtType (WithCurrentPrec p t) = WithCurrentPrec p (SqrtType t)
     sqrt = lift1 sqrt
 
 instance
     (CanExp t)
     =>
-    CanExp (WithCurrentPrec t p)
+    CanExp (WithCurrentPrec p t)
     where
-    type ExpType (WithCurrentPrec t p) = WithCurrentPrec (ExpType t) p
+    type ExpType (WithCurrentPrec p t) = WithCurrentPrec p (ExpType t)
     exp = lift1 exp
 
 instance
     (CanLog t)
     =>
-    CanLog (WithCurrentPrec t p)
+    CanLog (WithCurrentPrec p t)
     where
-    type LogType (WithCurrentPrec t p) = WithCurrentPrec (LogType t) p
+    type LogType (WithCurrentPrec p t) = WithCurrentPrec p (LogType t)
     log = lift1 log
 
 instance
     (CanPow t1 t2, p1~p2)
     =>
-    (CanPow (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where
-    type PowType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (PowType t1 t2) p1
+    (CanPow (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where
+    type PowType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (PowType t1 t2)
     pow = lift2 pow
 
 $(declForTypes
@@ -90,9 +90,9 @@
   instance 
     (CanPow b $e)
     =>
-    CanPow (WithCurrentPrec b p) $e 
+    CanPow (WithCurrentPrec p b) $e 
     where
-    type PowType (WithCurrentPrec b p) $e = WithCurrentPrec (PowType b $e) p
+    type PowType (WithCurrentPrec p b) $e = WithCurrentPrec p (PowType b $e)
     pow = lift1T pow
 
   |]))
@@ -104,9 +104,9 @@
   instance 
     (CanPow $b e, HasOrderCertainly e Integer, CanTestInteger e)
     =>
-    CanPow $b (WithCurrentPrec e p) 
+    CanPow $b (WithCurrentPrec p e) 
     where
-    type PowType $b (WithCurrentPrec e p) = WithCurrentPrec (PowType $b e) p
+    type PowType $b (WithCurrentPrec p e) = WithCurrentPrec p (PowType $b e)
     pow = liftT1 pow
   |]))
 
@@ -117,4 +117,4 @@
 _example2 = runWithPrec (prec 1000) $ piCP - piCP
 
 _example3 :: CN MPBall
-_example3 = runWithPrec (prec 1000) $ sqrt (mpBallCP 2)
+_example3 = runWithPrec (prec 1000) $ sqrt (cnmpBallCP 2)
diff --git a/src/AERN2/MP/WithCurrentPrec/Field.hs b/src/AERN2/MP/WithCurrentPrec/Field.hs
--- a/src/AERN2/MP/WithCurrentPrec/Field.hs
+++ b/src/AERN2/MP/WithCurrentPrec/Field.hs
@@ -32,31 +32,39 @@
 import AERN2.MP.WithCurrentPrec.Type
 
 instance
+    (CanNeg t)
+    =>
+    CanNeg (WithCurrentPrec p t)
+    where
+    type NegType (WithCurrentPrec p t) = WithCurrentPrec p (NegType t)
+    negate = lift1 negate
+
+instance
     (CanAddAsymmetric t1 t2, p1~p2)
     =>
-    (CanAddAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where
-    type AddType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (AddType t1 t2) p1
+    (CanAddAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where
+    type AddType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (AddType t1 t2)
     add = lift2 add
 
 instance
     (CanSub t1 t2, p1~p2)
     =>
-    (CanSub (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where
-    type SubType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (SubType t1 t2) p1
+    (CanSub (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where
+    type SubType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (SubType t1 t2)
     sub = lift2 sub
 
 instance
     (CanMulAsymmetric t1 t2, p1~p2)
     =>
-    (CanMulAsymmetric (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where
-    type MulType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (MulType t1 t2) p1
+    (CanMulAsymmetric (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where
+    type MulType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (MulType t1 t2)
     mul = lift2 mul
 
 instance
     (CanDiv t1 t2, p1~p2)
     =>
-    (CanDiv (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2)) where
-    type DivType (WithCurrentPrec t1 p1) (WithCurrentPrec t2 p2) = WithCurrentPrec (DivType t1 t2) p1
+    (CanDiv (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2)) where
+    type DivType (WithCurrentPrec p1 t1) (WithCurrentPrec p2 t2) = WithCurrentPrec p1 (DivType t1 t2)
     divide = lift2 divide
 
 
@@ -73,129 +81,129 @@
     instance
       (CanAddAsymmetric a $t)
       => 
-      CanAddAsymmetric (WithCurrentPrec a p) $t
+      CanAddAsymmetric (WithCurrentPrec p a) $t
       where
-      type AddType (WithCurrentPrec a p) $t = WithCurrentPrec (AddType a $t) p
+      type AddType (WithCurrentPrec p a) $t = WithCurrentPrec p (AddType a $t)
       add = lift1T add
 
     instance
       (CanAddAsymmetric a (CN $t))
       => 
-      CanAddAsymmetric (WithCurrentPrec a p) (CN $t)
+      CanAddAsymmetric (WithCurrentPrec p a) (CN $t)
       where
-      type AddType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (AddType a (CN $t)) p
+      type AddType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (AddType a (CN $t))
       add = lift1T add
 
     instance
       (CanAddAsymmetric $t a)
       => 
-      CanAddAsymmetric $t (WithCurrentPrec a p)
+      CanAddAsymmetric $t (WithCurrentPrec p a)
       where
-      type AddType $t (WithCurrentPrec a p) = WithCurrentPrec (AddType $t a) p
+      type AddType $t (WithCurrentPrec p a) = WithCurrentPrec p (AddType $t a)
       add = liftT1 add
 
     instance
       (CanAddAsymmetric (CN $t) a)
       => 
-      CanAddAsymmetric (CN $t) (WithCurrentPrec a p)
+      CanAddAsymmetric (CN $t) (WithCurrentPrec p a)
       where
-      type AddType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (AddType (CN $t) a) p
+      type AddType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (AddType (CN $t) a)
       add = liftT1 add
 
     instance
       (CanSub a $t)
       => 
-      CanSub (WithCurrentPrec a p) $t
+      CanSub (WithCurrentPrec p a) $t
       where
-      type SubType (WithCurrentPrec a p) $t = WithCurrentPrec (SubType a $t) p
+      type SubType (WithCurrentPrec p a) $t = WithCurrentPrec p (SubType a $t)
       sub = lift1T sub
 
     instance
       (CanSub a (CN $t))
       => 
-      CanSub (WithCurrentPrec a p) (CN $t)
+      CanSub (WithCurrentPrec p a) (CN $t)
       where
-      type SubType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (SubType a (CN $t)) p
+      type SubType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (SubType a (CN $t))
       sub = lift1T sub
 
     instance
       (CanSub $t a)
       => 
-      CanSub $t (WithCurrentPrec a p)
+      CanSub $t (WithCurrentPrec p a)
       where
-      type SubType $t (WithCurrentPrec a p) = WithCurrentPrec (SubType $t a) p
+      type SubType $t (WithCurrentPrec p a) = WithCurrentPrec p (SubType $t a)
       sub = liftT1 sub
 
     instance
       (CanSub (CN $t) a)
       => 
-      CanSub (CN $t) (WithCurrentPrec a p)
+      CanSub (CN $t) (WithCurrentPrec p a)
       where
-      type SubType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (SubType (CN $t) a) p
+      type SubType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (SubType (CN $t) a)
       sub = liftT1 sub
 
     instance
       (CanMulAsymmetric a $t)
       => 
-      CanMulAsymmetric (WithCurrentPrec a p) $t
+      CanMulAsymmetric (WithCurrentPrec p a) $t
       where
-      type MulType (WithCurrentPrec a p) $t = WithCurrentPrec (MulType a $t) p
+      type MulType (WithCurrentPrec p a) $t = WithCurrentPrec p (MulType a $t)
       mul = lift1T mul
 
     instance
       (CanMulAsymmetric a (CN $t))
       => 
-      CanMulAsymmetric (WithCurrentPrec a p) (CN $t)
+      CanMulAsymmetric (WithCurrentPrec p a) (CN $t)
       where
-      type MulType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (MulType a (CN $t)) p
+      type MulType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (MulType a (CN $t))
       mul = lift1T mul
 
     instance
       (CanMulAsymmetric $t a)
       => 
-      CanMulAsymmetric $t (WithCurrentPrec a p)
+      CanMulAsymmetric $t (WithCurrentPrec p a)
       where
-      type MulType $t (WithCurrentPrec a p) = WithCurrentPrec (MulType $t a) p
+      type MulType $t (WithCurrentPrec p a) = WithCurrentPrec p (MulType $t a)
       mul = liftT1 mul
 
     instance
       (CanMulAsymmetric (CN $t) a)
       => 
-      CanMulAsymmetric (CN $t) (WithCurrentPrec a p)
+      CanMulAsymmetric (CN $t) (WithCurrentPrec p a)
       where
-      type MulType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (MulType (CN $t) a) p
+      type MulType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (MulType (CN $t) a)
       mul = liftT1 mul
 
     instance
       (CanDiv a $t)
       => 
-      CanDiv (WithCurrentPrec a p) $t
+      CanDiv (WithCurrentPrec p a) $t
       where
-      type DivType (WithCurrentPrec a p) $t = WithCurrentPrec (DivType a $t) p
+      type DivType (WithCurrentPrec p a) $t = WithCurrentPrec p (DivType a $t)
       divide = lift1T divide
 
     instance
       (CanDiv a (CN $t))
       => 
-      CanDiv (WithCurrentPrec a p) (CN $t)
+      CanDiv (WithCurrentPrec p a) (CN $t)
       where
-      type DivType (WithCurrentPrec a p) (CN $t) = WithCurrentPrec (DivType a (CN $t)) p
+      type DivType (WithCurrentPrec p a) (CN $t) = WithCurrentPrec p (DivType a (CN $t))
       divide = lift1T divide
 
     instance
       (CanDiv $t a)
       => 
-      CanDiv $t (WithCurrentPrec a p)
+      CanDiv $t (WithCurrentPrec p a)
       where
-      type DivType $t (WithCurrentPrec a p) = WithCurrentPrec (DivType $t a) p
+      type DivType $t (WithCurrentPrec p a) = WithCurrentPrec p (DivType $t a)
       divide = liftT1 divide
 
     instance
       (CanDiv (CN $t) a)
       => 
-      CanDiv (CN $t) (WithCurrentPrec a p)
+      CanDiv (CN $t) (WithCurrentPrec p a)
       where
-      type DivType (CN $t) (WithCurrentPrec a p) = WithCurrentPrec (DivType (CN $t) a) p
+      type DivType (CN $t) (WithCurrentPrec p a) = WithCurrentPrec p (DivType (CN $t) a)
       divide = liftT1 divide
 
   |]))
diff --git a/src/AERN2/MP/WithCurrentPrec/Limit.hs b/src/AERN2/MP/WithCurrentPrec/Limit.hs
--- a/src/AERN2/MP/WithCurrentPrec/Limit.hs
+++ b/src/AERN2/MP/WithCurrentPrec/Limit.hs
@@ -26,6 +26,8 @@
 
 -- import qualified Numeric.CollectErrors as CN
 
+import GHC.TypeLits
+
 import AERN2.MP.Ball
 
 import AERN2.Limit
@@ -35,17 +37,17 @@
 instance 
     (HasLimits ix (CN MPBall -> CN MPBall)
     , LimitType ix (CN MPBall -> CN MPBall) ~ (CN MPBall -> CN MPBall)
-    ,HasCurrentPrecision p)
+    , KnownNat p)
     => 
-    HasLimits ix (WithCurrentPrec (CN MPBall) p) 
+    HasLimits ix (WithCurrentPrec p (CN MPBall)) 
     where
-    type LimitType ix (WithCurrentPrec (CN MPBall) p) = WithCurrentPrec (CN MPBall) p
-    limit (s :: ix -> (WithCurrentPrec (CN MPBall) p)) = 
+    type LimitType ix (WithCurrentPrec p (CN MPBall)) = WithCurrentPrec p (CN MPBall)
+    limit (s :: ix -> (WithCurrentPrec p (CN MPBall))) = 
         WithCurrentPrec $ limit (snop) $ sample
         where
         sample :: CN MPBall
         sample = setPrecision (getCurrentPrecision sampleP) (cn $ mpBall 0)
-        sampleP :: WithCurrentPrec MPBall p
+        sampleP :: WithCurrentPrec p MPBall
         sampleP = error "sampleP is not defined, it is only a type proxy"
         snop :: ix -> (CN MPBall -> CN MPBall)
         snop ix _sample = unWithCurrentPrec $ s ix
diff --git a/src/AERN2/MP/WithCurrentPrec/PreludeInstances.hs b/src/AERN2/MP/WithCurrentPrec/PreludeInstances.hs
--- a/src/AERN2/MP/WithCurrentPrec/PreludeInstances.hs
+++ b/src/AERN2/MP/WithCurrentPrec/PreludeInstances.hs
@@ -27,6 +27,8 @@
 
 import Numeric.CollectErrors (cn, CN)
 
+import GHC.TypeLits
+
 import AERN2.MP.Precision
 import AERN2.MP.Ball
 
@@ -38,15 +40,15 @@
 ********************************
 -}
 
-instance Eq t => Eq (WithCurrentPrec t p) where
+instance Eq t => Eq (WithCurrentPrec p t) where
     (==) = lift2P (==)
-instance Ord t => Ord (WithCurrentPrec t p) where
+instance Ord t => Ord (WithCurrentPrec p t) where
     compare = lift2P compare
 
 instance 
-    (HasCurrentPrecision p, Num t, ConvertibleWithPrecision Integer t) 
+    (KnownNat p, Num t, ConvertibleWithPrecision Integer t) 
     => 
-    Num (WithCurrentPrec t p) 
+    Num (WithCurrentPrec p t) 
     where
     fromInteger n = r
         where   
@@ -58,10 +60,10 @@
     signum = lift1 signum
 
 instance 
-    (HasCurrentPrecision p, Fractional t
+    (KnownNat p, Fractional t
     , ConvertibleWithPrecision Integer t, ConvertibleWithPrecision Rational t) 
     => 
-    Fractional (WithCurrentPrec t p) 
+    Fractional (WithCurrentPrec p t) 
     where
     fromRational q = r
         where   
@@ -69,7 +71,7 @@
     recip = lift1 recip
     (/) = lift2 (/)
 
-instance (HasCurrentPrecision p) => Floating (WithCurrentPrec (CN MPBall) p) where
+instance (KnownNat p) => Floating (WithCurrentPrec p (CN MPBall)) where
     pi = r 
         where
         r = WithCurrentPrec $ cn $ piBallP (getCurrentPrecision r)
diff --git a/src/AERN2/MP/WithCurrentPrec/Type.hs b/src/AERN2/MP/WithCurrentPrec/Type.hs
--- a/src/AERN2/MP/WithCurrentPrec/Type.hs
+++ b/src/AERN2/MP/WithCurrentPrec/Type.hs
@@ -32,12 +32,16 @@
 
 import AERN2.MP
 
-class HasCurrentPrecision p where
-    getCurrentPrecision :: proxy p -> Precision
+newtype WithCurrentPrec p t = WithCurrentPrec { unWithCurrentPrec :: t }
+    deriving (Show)
 
-instance KnownNat n => HasCurrentPrecision n where
-    getCurrentPrecision p = max (prec 2) . min maximumPrecision $ prec (natVal p)
+deriving instance (CanTakeErrors NumErrors t) => (CanTakeErrors NumErrors (WithCurrentPrec p t))
+deriving instance (CanTestIsIntegerType t) => (CanTestIsIntegerType (WithCurrentPrec p t))
 
+getCurrentPrecision :: (KnownNat p) => WithCurrentPrec p t -> Precision
+getCurrentPrecision (_ :: (WithCurrentPrec p t)) =
+    max (prec 2) . min maximumPrecision $ prec (natVal (undefined :: Proxy p))
+
 {-|
 
 An existential type wrapper for convenient conversions, eg using aern2-real:
@@ -49,49 +53,48 @@
 > _r_x = creal $ WithAnyPrec _x
 
 -}
-newtype WithAnyPrec t = WithAnyPrec (forall p. (KnownNat p) => WithCurrentPrec t p)
-
--- data PrecAdd10 (p :: *)
+newtype WithAnyPrec t = WithAnyPrec (forall p. (KnownNat p) => WithCurrentPrec p t)
 
--- instance (HasCurrentPrecision p) => HasCurrentPrecision (PrecAdd10 p) where
---     isPrecision (_ :: proxy _) = 10 + isPrecision (undefined :: proxy p)
+{-| 
+    Run a WithCurrentPrec computation with a specific precision.
+-}
+runWithPrec :: Precision -> (forall p. (KnownNat p) => WithCurrentPrec p t) -> t
+runWithPrec p (wfp :: (forall p. (KnownNat p) => WithCurrentPrec p t)) = 
+    reifyNat (integer p) withNat
+    where
+    withNat :: KnownNat p => Proxy p -> t
+    withNat (_ :: Proxy p) = 
+        unWithCurrentPrec (wfp :: WithCurrentPrec p t)
 
-newtype WithCurrentPrec t p = WithCurrentPrec { unWithCurrentPrec :: t }
-    deriving (Show)
+instance (ConvertibleWithPrecision t1 t2, KnownNat p) => ConvertibleExactly t1 (WithCurrentPrec p t2) where
+    safeConvertExactly v = Right r
+        where
+        r = WithCurrentPrec $ convertP (getCurrentPrecision r) v
 
-deriving instance (CanTakeErrors NumErrors t) => (CanTakeErrors NumErrors (WithCurrentPrec t p))
-deriving instance (CanTestIsIntegerType t) => (CanTestIsIntegerType (WithCurrentPrec t p))
+-- mpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec p MPBall
+-- mpBallCP = convertExactly 
 
-runWithPrec :: Precision -> (forall n. (KnownNat n) => WithCurrentPrec t n) -> t
-runWithPrec p (wfp :: (forall n. (KnownNat n) => WithCurrentPrec t n)) = 
-    reifyNat (integer p) withNat
-    where
-    withNat :: KnownNat n => Proxy n -> t
-    withNat (_ :: Proxy n) = 
-        unWithCurrentPrec (wfp :: WithCurrentPrec t n)
+cnmpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec p (CN MPBall)
+cnmpBallCP = lift1 cn . convertExactly 
 
-lift1 :: (t1 -> t2) -> (WithCurrentPrec t1 p) -> (WithCurrentPrec t2 p)
+lift1 :: (t1 -> t2) -> (WithCurrentPrec p t1) -> (WithCurrentPrec p t2)
 lift1 f (WithCurrentPrec v1) = WithCurrentPrec (f v1)
 
-lift2 :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> (WithCurrentPrec t2 p2) -> (WithCurrentPrec t3 p1)
+lift2 :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> (WithCurrentPrec p2 t2) -> (WithCurrentPrec p1 t3)
 lift2 f (WithCurrentPrec v1) (WithCurrentPrec v2) = WithCurrentPrec (f v1 v2)
 
-lift2P :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> (WithCurrentPrec t2 p2) -> t3
+lift2P :: (p1 ~ p2) => (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> (WithCurrentPrec p2 t2) -> t3
 lift2P f (WithCurrentPrec v1) (WithCurrentPrec v2) = f v1 v2
 
-lift1T :: (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> t2 -> (WithCurrentPrec t3 p1)
+lift1T :: (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> t2 -> (WithCurrentPrec p1 t3)
 lift1T f (WithCurrentPrec v1) v2 = WithCurrentPrec (f v1 v2)
 
-lift1TP :: (t1 -> t2 -> t3) -> (WithCurrentPrec t1 p1) -> t2 -> t3
+lift1TP :: (t1 -> t2 -> t3) -> (WithCurrentPrec p1 t1) -> t2 -> t3
 lift1TP f (WithCurrentPrec v1) v2 = f v1 v2
 
-liftT1 :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec t2 p2) -> (WithCurrentPrec t3 p1)
+liftT1 :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec p2 t2) -> (WithCurrentPrec p1 t3)
 liftT1 f v1 (WithCurrentPrec v2) = WithCurrentPrec (f v1 v2)
 
-liftT1P :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec t2 p2) -> t3
+liftT1P :: (t1 -> t2 -> t3) -> t1 -> (WithCurrentPrec p2 t2) -> t3
 liftT1P f v1 (WithCurrentPrec v2) = f v1 v2
 
-mpBallCP :: (CanBeMPBallP t, KnownNat p) => t -> WithCurrentPrec (CN MPBall) p
-mpBallCP v = r 
-    where
-    r = WithCurrentPrec $ cn $ mpBallP (getCurrentPrecision r) v