diff --git a/accelerate-fourier.cabal b/accelerate-fourier.cabal
--- a/accelerate-fourier.cabal
+++ b/accelerate-fourier.cabal
@@ -1,5 +1,5 @@
 Name:             accelerate-fourier
-Version:          0.0.1
+Version:          1.0
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -22,7 +22,7 @@
 Build-Type:       Simple
 
 Source-Repository this
-  Tag:         0.0.1
+  Tag:         1.0
   Type:        darcs
   Location:    http://hub.darcs.net/thielema/accelerate-fourier/
 
@@ -32,14 +32,14 @@
 
 Library
   Build-Depends:
-    accelerate-arithmetic >=0.1 && <0.2,
-    accelerate-utility >=0.1 && <0.2,
-    accelerate >=0.15 && <0.16,
+    accelerate-arithmetic >=1.0 && <1.1,
+    accelerate-utility >=1.0 && <1.1,
+    accelerate >=1.0 && <1.2,
     containers >=0.5 && <0.6,
     transformers >=0.3 && <0.6,
     utility-ht >=0.0.8 && <0.1,
     QuickCheck >=2.4 && <3,
-    base >=4.5 && <4.9
+    base >=4.5 && <4.11
 
   GHC-Options:      -Wall -fwarn-missing-import-lists
   Hs-Source-Dirs:   src
diff --git a/src/Data/Array/Accelerate/Convolution/Adhoc.hs b/src/Data/Array/Accelerate/Convolution/Adhoc.hs
--- a/src/Data/Array/Accelerate/Convolution/Adhoc.hs
+++ b/src/Data/Array/Accelerate/Convolution/Adhoc.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 module Data.Array.Accelerate.Convolution.Adhoc (
    Transform2,
    karatsuba,
@@ -22,16 +23,15 @@
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Exp, Acc, Array, IsNum, Elt,
-           Z(Z), (:.)((:.)), Any(Any), All(All), Slice, Shape,
-           (!), (>*), )
+          (Exp, Acc, Array,
+           Z(Z), (:.)((:.)), Any(Any), All(All), Slice, Shape, (!), )
 
 
 {- |
 Both arrays must have the same size.
 -}
 karatsuba ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Transform2 (sh :. Int) a
 karatsuba x y =
    flip A.slice (A.lift $ Any :. (0::Int) :. All)
@@ -39,7 +39,7 @@
    A.afst
    .
    A.awhile
-      (\arrs -> A.unit $ (Sliced.length $ A.asnd arrs) >* 1)
+      (\arrs -> A.unit $ (Sliced.length $ A.asnd arrs) A.> 1)
       (Acc.modify (acc, acc) $
        \(z, lens) ->
           (karatsubaGo (lens ! A.index1 0) (2*(lens ! A.index1 1)-1) z,
@@ -49,7 +49,7 @@
     \((x0,y0), lens) -> (A.zipWith (*) x0 y0, lens))
    .
    A.awhile
-      (\arrs -> A.unit $ (Sliced.length $ A.afst $ A.afst arrs) >* 1)
+      (\arrs -> A.unit $ (Sliced.length $ A.afst $ A.afst arrs) A.> 1)
       (Acc.modify ((acc, acc), acc) $
        \((x0,y0), lens) ->
           let (x1,y1) = karatsubaReorder (x0,y0)
@@ -61,7 +61,7 @@
        A.fill (A.constant $ Z:.1) (Sliced.length x))
 
 karatsubaReorder ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    (Acc (Array (sh :. Int :. Int) a),
     Acc (Array (sh :. Int :. Int) a)) ->
    (Acc (Array (sh :. Int :. Int) a),
@@ -76,7 +76,7 @@
         Sliced1.append3 yl (A.zipWith (+) yl yr) yr)
 
 karatsubaGo ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Exp Int ->
    Exp Int ->
    Transform (sh :. Int :. Int) a
@@ -99,7 +99,7 @@
 Turn an ordinary convolution into a cyclic convolution of the same length.
 -}
 cyclic ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Transform2 (sh :. Int) a ->
    Transform2 (sh :. Int) a
 cyclic conv x y =
@@ -113,7 +113,7 @@
 Can be removed when we get @instance IsNum (Complex a)@.
 -}
 complex, _complex ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Transform2 (sh :. Int) a ->
    Transform2 (sh :. Int) (Complex a)
 complex conv x y =
diff --git a/src/Data/Array/Accelerate/Convolution/Preprocessed.hs b/src/Data/Array/Accelerate/Convolution/Preprocessed.hs
--- a/src/Data/Array/Accelerate/Convolution/Preprocessed.hs
+++ b/src/Data/Array/Accelerate/Convolution/Preprocessed.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 module Data.Array.Accelerate.Convolution.Preprocessed (
    Transform2,
    karatsuba,
@@ -12,9 +13,7 @@
 import Data.Array.Accelerate.Utility.Lift.Exp (expr)
 
 import qualified Data.Array.Accelerate as A
-import Data.Array.Accelerate
-          (IsNum, Elt,
-           (:.)((:.)), Any(Any), All(All), Slice, Shape, )
+import Data.Array.Accelerate ((:.)((:.)), Any(Any), All(All), Slice, Shape, )
 
 
 {- |
@@ -24,7 +23,7 @@
 thus you should prefer 'Data.Array.Accelerate.Convolution.Adhoc.karatsuba'.
 -}
 karatsuba ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Int -> Transform2 (sh :. Int) a
 karatsuba len x y =
    if len <= 1
diff --git a/src/Data/Array/Accelerate/Convolution/Private.hs b/src/Data/Array/Accelerate/Convolution/Private.hs
--- a/src/Data/Array/Accelerate/Convolution/Private.hs
+++ b/src/Data/Array/Accelerate/Convolution/Private.hs
@@ -1,14 +1,13 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 module Data.Array.Accelerate.Convolution.Private where
 
 import qualified Data.Array.Accelerate.Utility.Sliced as Sliced
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Exp, Acc, Array, IsNum, Elt,
-           (:.)((:.)), Slice, Shape,
-           (!), (?), (&&*), (<*), (<=*), )
+          (Exp, Acc, Array, (:.)((:.)), Slice, Shape, (!), (?), )
 
 import Prelude (Int, )
 
@@ -20,8 +19,8 @@
 
 
 indexPad ::
-   (Shape sh, Slice sh, Elt a, IsNum a) =>
+   (Shape sh, Slice sh, A.Num a) =>
    Exp sh :. Exp Int ->
    Acc (Array (sh:.Int) a) -> Exp a
 indexPad (ix:.k) xs =
-   0 <=* k &&* k <* Sliced.length xs ? (xs ! A.lift (ix:.k), 0)
+   0 A.<= k A.&& k A.< Sliced.length xs ? (xs ! A.lift (ix:.k), 0)
diff --git a/src/Data/Array/Accelerate/Fourier/Adhoc.hs b/src/Data/Array/Accelerate/Fourier/Adhoc.hs
--- a/src/Data/Array/Accelerate/Fourier/Adhoc.hs
+++ b/src/Data/Array/Accelerate/Fourier/Adhoc.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 {- |
 The implementations in this module work entirely in the 'A.Acc' domain.
 This means that they can be applied to any array
@@ -53,14 +54,12 @@
 import Data.Array.Accelerate.Data.Complex (Complex, )
 
 import qualified Data.Array.Accelerate as A
-import Data.Array.Accelerate
-          (Slice, Shape, DIM1, Z(Z), (:.)((:.)),
-           Exp, Elt, IsFloating, (<=*), (>*), (==*), )
+import Data.Array.Accelerate.Data.Bits ((.&.))
+import Data.Array.Accelerate (Slice, Shape, DIM1, Z(Z), (:.)((:.)), Exp, )
 
-import Data.Bits ((.&.))
 
 
-forward, inverse :: (Elt a, A.IsNum a) => Exp (Sign a)
+forward, inverse :: (A.Num a) => Exp (Sign a)
 forward = Sign.forwardExp
 inverse = Sign.inverseExp
 
@@ -72,12 +71,12 @@
 "Data.Array.Accelerate.Fourier.Planned".
 -}
 transform ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int) (Complex a)
 transform sign arr =
    let len = Sliced.length arr
-   in  A.acond (len <=* 1) arr $
+   in  A.acond (len A.<= 1) arr $
           let (pow2, smooth5) = is2or5smooth len
           in  A.acond pow2 (ditSplitRadixLoop sign arr) $
               A.acond smooth5 (dit235 sign arr) $
@@ -87,35 +86,35 @@
 is2or5smooth len =
    let maxPowerOfTwo = len .&. negate len
        lenOdd = div len maxPowerOfTwo
-   in  (lenOdd ==* 1,
-        (divideMaxPower 5 $ divideMaxPower 3 lenOdd) ==* 1)
+   in  (lenOdd A.== 1,
+        (divideMaxPower 5 $ divideMaxPower 3 lenOdd) A.== 1)
 
 divideMaxPower :: Exp Int -> Exp Int -> Exp Int
 divideMaxPower fac =
-   A.while (\n -> mod n fac ==* 0) (flip div fac)
+   A.while (\n -> mod n fac A.== 0) (flip div fac)
 
 
 {- |
 Split-Radix for power-of-two sizes.
 -}
 ditSplitRadix ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int) (Complex a)
 ditSplitRadix sign arr =
    A.acond
-      (Sliced.length arr <=* 1)
+      (Sliced.length arr A.<= 1)
       arr (ditSplitRadixLoop sign arr)
 
 ditSplitRadixLoop ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int) (Complex a)
 ditSplitRadixLoop sign =
    Fourier.finishSplitRadix . A.afst
    .
    A.awhile
-      (\x -> A.unit $ (Sliced1.length $ A.asnd x) >* 0)
+      (\x -> A.unit $ (Sliced1.length $ A.asnd x) A.> 0)
       (Acc.modify (acc, acc) $
        \(arr2, arr1) ->
          Fourier.ditSplitRadixStep
@@ -126,7 +125,7 @@
    Acc.modify (acc, acc) Fourier.ditSplitRadixBase
    .
    A.awhile
-      (\x -> A.unit $ (Sliced.length $ A.asnd x) >* 1)
+      (\x -> A.unit $ (Sliced.length $ A.asnd x) A.> 1)
       (Acc.modify (acc, acc) Fourier.ditSplitRadixReorder)
    .
    A.lift . Fourier.initSplitRadix
@@ -136,24 +135,24 @@
 Decimation in time for power-of-two sizes.
 -}
 dit2 ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int) (Complex a)
 dit2 sign =
    flip A.slice (A.lift $ A.Any :. (0::Int) :. A.All)
    .
    A.awhile
-      (\x -> A.unit $ Sliced1.length x >* 1)
+      (\x -> A.unit $ Sliced1.length x A.> 1)
       (ditStep sign)
    .
    A.awhile
-      (\x -> A.unit $ Sliced.length x >* 1)
+      (\x -> A.unit $ Sliced.length x A.> 1)
       (twist 2)
    .
    A.replicate (A.lift $ A.Any :. (1::Int) :. A.All)
 
 ditStep ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int:.Int) (Complex a)
 ditStep sign x =
@@ -169,7 +168,7 @@
 <http://oeis.org/A051037>.
 -}
 dit235 ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Transform (sh:.Int) (Complex a)
 dit235 sign =
@@ -178,17 +177,17 @@
    A.afst
    .
    A.awhile
-      (\x -> A.unit $ (A.length $ A.asnd x) >* 0)
+      (\x -> A.unit $ (A.length $ A.asnd x) A.> 0)
       (Acc.modify (acc,acc) $
        \(arr,factors) ->
          let fac = factors A.! A.index1 0
          in  (dit235Step sign fac arr, Sliced.tail factors))
    .
    A.awhile
-      (\x -> A.unit $ (Sliced.length $ A.afst x) >* 1)
+      (\x -> A.unit $ (Sliced.length $ A.afst x) A.> 1)
       (Acc.modify (acc,acc) $
        \(arr,factors) ->
-         let divides k n = mod n k ==* 0
+         let divides k n = mod n k A.== 0
              caseFactor k = (divides k, k)
              len = Sliced.length arr
              factor =
@@ -204,7 +203,7 @@
    A.replicate (A.lift $ A.Any :. (1::Int) :. A.All)
 
 dit235Step ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Exp Int ->
    Transform (sh:.Int:.Int) (Complex a)
@@ -217,9 +216,9 @@
           $
           x
    in  Fourier.merge $
-       A.acond (fac ==* 5) (Fourier.transform5 (Fourier.cache5 sign) twiddled) $
-       A.acond (fac ==* 4) (Fourier.transform4 (Fourier.cache4 sign) twiddled) $
-       A.acond (fac ==* 3) (Fourier.transform3 (Fourier.cache3 sign) twiddled) $
+       A.acond (fac A.== 5) (Fourier.transform5 (Fourier.cache5 sign) twiddled) $
+       A.acond (fac A.== 4) (Fourier.transform4 (Fourier.cache4 sign) twiddled) $
+       A.acond (fac A.== 3) (Fourier.transform3 (Fourier.cache3 sign) twiddled) $
        Fourier.transform2 (Fourier.cache2 sign) twiddled
 
 
@@ -234,7 +233,7 @@
    (A.fromIntegral n :: Exp Double)
 
 ceiling5SmoothFloat ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp a -> Exp (a, (Int, Int, Int))
 ceiling5SmoothFloat n =
    let d3 = ceilingLogBase 3 n
@@ -252,7 +251,7 @@
 but sometimes misses optimal results due to rounding errors.
 -}
 _ceiling5SmoothLog ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp a -> Exp (a, (Int, Int, Int))
 _ceiling5SmoothLog n =
    let log3 = logBase 2 3
@@ -269,7 +268,7 @@
           in  (logP53 + A.fromIntegral e2, (e2, e3, e5))
 
 _ceiling5SmoothFloat ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp a -> Exp (a, (Int, Int, Int))
 _ceiling5SmoothFloat n =
    let powers base =
@@ -285,7 +284,7 @@
        LinAlg.outer (powers 5) (powers 3)
 
 ceilingLogBase ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp Int -> Exp a -> Exp Int
 ceilingLogBase base x =
    A.ceiling $ logBase (A.fromIntegral base) x
@@ -295,7 +294,7 @@
 
 
 _transformChirp ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Exp Int ->
    (Transform DIM1 (Complex a),
@@ -305,7 +304,7 @@
 _transformChirp sign padLen (analysis1,analysis,synthesis) arr =
    let len = Sliced.length arr
        chirp = Fourier.chirp sign padLen $ A.fromIntegral len
-   in  A.acond (len<=*1) arr $
+   in  A.acond (len A.<= 1) arr $
        Sliced.take len $ scaleDown $
        LinAlg.zipExtrudedVectorWith (*) chirp $ synthesis $
        LinAlg.zipExtrudedVectorWith (*)
@@ -314,7 +313,7 @@
            LinAlg.zipExtrudedVectorWith (*) chirp arr)
 
 transformChirp ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Exp Int ->
    SubTransformPair (Complex a) ->
@@ -329,7 +328,7 @@
              (A.reshape (A.lift $ A.index1 (A.shapeSize sh) :. padLen) $
               Sliced.pad 0 padLen $
               LinAlg.zipExtrudedVectorWith (*) chirp arr)
-   in  A.acond (len<=*1) arr $
+   in  A.acond (len A.<= 1) arr $
        Sliced.take len $ scaleDown $
        LinAlg.zipExtrudedVectorWith (*) chirp $ synthesis $
        LinAlg.zipExtrudedVectorWith (*)
@@ -340,7 +339,7 @@
 Transformation of arbitrary length based on Bluestein on a power-of-two size.
 -}
 transformChirp2 ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Transform (sh:.Int) (Complex a)
 transformChirp2 sign arr =
    transformChirp sign
@@ -353,7 +352,7 @@
 Transformation of arbitrary length based on Bluestein on a 5-smooth size.
 -}
 transformChirp235 ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Transform (sh:.Int) (Complex a)
 transformChirp235 sign arr =
    transformChirp sign
@@ -363,7 +362,7 @@
 
 
 transform2d ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    SubTransform (Complex a) ->
    Transform (sh:.Int:.Int) (Complex a)
 transform2d (SubTransform trans) =
@@ -371,7 +370,7 @@
    LinAlg.transpose . trans
 
 transform3d ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    SubTransform (Complex a) ->
    Transform (sh:.Int:.Int:.Int) (Complex a)
 transform3d (SubTransform trans) =
diff --git a/src/Data/Array/Accelerate/Fourier/Planned.hs b/src/Data/Array/Accelerate/Fourier/Planned.hs
--- a/src/Data/Array/Accelerate/Fourier/Planned.hs
+++ b/src/Data/Array/Accelerate/Fourier/Planned.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 {- |
 Like "Data.Array.Accelerate.Fourier.Preprocessed"
 this module allows to factor out some preprocessing.
@@ -73,8 +74,7 @@
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate.Data.Complex (Complex, conjugate, )
 import Data.Array.Accelerate
-          (Exp, Acc, Array, DIM1, DIM2, IsFloating, Elt,
-           (:.)((:.)), Slice, Shape, )
+          (Exp, Acc, Array, DIM1, DIM2, (:.)((:.)), Elt, Slice, Shape, )
 
 import qualified Control.Monad.Trans.State as State
 import Control.Monad (liftM2, )
@@ -99,7 +99,7 @@
 is equal to the extent of the inner dimension of every transformed array.
 -}
 transform ::
-   (Slice sh, Shape sh, RealFloat a, Elt a, IsFloating a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    Sign a -> Int -> Transform (sh:.Int) (Complex a)
 transform sign len = transformWithCache $ cache sign len
 
@@ -110,14 +110,14 @@
 This is more for testing and benchmarking than for real use.
 -}
 transformDecompose ::
-   (Slice sh, Shape sh, Elt a, IsFloating a, RealFloat a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    Sign a -> Int ->
    Transform (sh :. Int) (Complex a)
 transformDecompose =
    transformWithPlanner planDecomposeWithMapUpdate
 
 transformWithPlanner ::
-   (Slice sh, Shape sh, Elt a, IsFloating a, RealFloat a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    (Integer -> State.State PlanMap Plan) ->
    Sign a -> Int ->
    Transform (sh :. Int) (Complex a)
@@ -133,7 +133,7 @@
 that the cache was generated for.
 -}
 transformWithCache ::
-   (Slice sh, Shape sh, Elt a, IsFloating a) =>
+   (Slice sh, Shape sh, A.RealFloat a) =>
    Cache (Complex a) -> Transform (sh:.Int) (Complex a)
 transformWithCache ch =
    case ch of
@@ -165,12 +165,11 @@
          subTransformPairWithCache subCaches
 
 subTransformWithCache ::
-   (Elt a, IsFloating a) =>
-   Cache (Complex a) -> SubTransform (Complex a)
+   (A.RealFloat a) => Cache (Complex a) -> SubTransform (Complex a)
 subTransformWithCache ch = SubTransform (transformWithCache ch)
 
 subTransformPairWithCache ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a) =>
    (Cache (Complex a), Cache (Complex a)) -> SubTransformPair (Complex a)
 subTransformPairWithCache (ch0,ch1) =
    SubTransformPair (transformWithCache ch0) (transformWithCache ch1)
@@ -319,7 +318,7 @@
 You can use this cache in 'transformWithCache'.
 -}
 cache ::
-   (RealFloat a, Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    Sign a -> Int -> Cache (Complex a)
 cache sign len =
    cacheFromPlan
@@ -332,7 +331,7 @@
 but 'cacheDuplex' shares common data of both caches.
 -}
 cacheDuplex ::
-   (a ~ Complex b, RealFloat b, Elt b, IsFloating b) =>
+   (a ~ Complex b, A.RealFloat b, A.FromIntegral Int b, Num b) =>
    Int -> (Cache a, Cache a)
 cacheDuplex len =
    let p = plan $ fromIntegral len
@@ -347,7 +346,7 @@
 type CacheMap a = Map.Map (Integer,Direction) (Cache a)
 
 cacheFromPlan ::
-   (a ~ Complex b, RealFloat b, Elt b, IsFloating b) =>
+   (a ~ Complex b, A.RealFloat b, A.FromIntegral Int b, Num b) =>
    Plan -> (Direction, Sign b) -> Cache a
 cacheFromPlan p z =
    State.evalState (cacheFromPlanWithMapUpdate p z) Map.empty
@@ -357,7 +356,7 @@
 Detect and re-use common sub-caches.
 -}
 cacheFromPlanWithMap ::
-   (a ~ Complex b, RealFloat b, Elt b, IsFloating b) =>
+   (a ~ Complex b, A.RealFloat b, Num b, A.FromIntegral Int b) =>
    Plan -> (Direction, Sign b) ->
    State.State (CacheMap a) (Cache a)
 cacheFromPlanWithMap (Plan len struct) dsign@(_d,sign) =
@@ -417,7 +416,7 @@
             (directionModes $ fromInteger padlen)
 
 cacheFromPlanWithMapUpdate ::
-   (a ~ Complex b, RealFloat b, Elt b, IsFloating b) =>
+   (a ~ Complex b, A.RealFloat b, A.FromIntegral Int b, Num b) =>
    Plan -> (Direction, Sign b) ->
    State.State (CacheMap a) (Cache a)
 cacheFromPlanWithMapUpdate p@(Plan len _) z = do
@@ -431,7 +430,7 @@
          return m
 
 cacheFromPlanWithMapUpdate2 ::
-   (a ~ Complex b, RealFloat b, Elt b, IsFloating b) =>
+   (a ~ Complex b, A.RealFloat b, A.FromIntegral Int b, Num b) =>
    (Plan, Plan) -> ((Direction, Sign b), (Direction, Sign b)) ->
    State.State (CacheMap a) (Cache a, Cache a)
 cacheFromPlanWithMapUpdate2 (p0,p1) (dm0,dm1) =
@@ -470,14 +469,14 @@
    deriving (Show)
 
 levelCacheRadix2 ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Integer -> Sign a -> LevelCacheRadix2 (Complex a)
 levelCacheRadix2 n2 sign =
    LevelCacheRadix2 $
    Fourier.twiddleFactors2 (A.constant sign) (expInteger n2)
 
 transformRadix2InterleavedTime ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCacheRadix2 a ->
    SubTransform a ->
    Transform (sh:.Int) a
@@ -491,14 +490,14 @@
    deriving (Show)
 
 levelCacheSplitRadix ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, Num a, A.FromIntegral Int a) =>
    Integer -> Sign a -> LevelCacheSplitRadix (Complex a)
 levelCacheSplitRadix n2 sign =
    LevelCacheSplitRadix (Fourier.imagSplitRadixPlain sign) $
    Fourier.twiddleFactorsSRPair (A.constant sign) (expInteger (div n2 2))
 
 transformSplitRadixInterleavedTime ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCacheSplitRadix a ->
    SubPairTransform a ->
    PairTransform (sh:.Int:.Int) a
@@ -509,7 +508,7 @@
    Fourier.ditSplitRadixReorder
 
 transformSplitRadixInterleavedTimeChain ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    CacheSplitRadixChain a ->
    PairTransform (sh:.Int:.Int) a
 transformSplitRadixInterleavedTimeChain chain =
@@ -526,7 +525,7 @@
    deriving (Show)
 
 levelCacheComposite ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    (Integer, Integer) -> Sign a -> LevelCacheComposite (Complex a)
 levelCacheComposite (n,m) sign =
    LevelCacheComposite $
@@ -540,7 +539,7 @@
 Cooley-Tukey-algorithm
 -}
 transformComposite ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCacheComposite a ->
    SubTransformPair a ->
    Transform (sh:.Int) a
@@ -581,7 +580,7 @@
 Good-Thomas algorithm
 -}
 transformCoprime ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCacheCoprime ->
    SubTransformPair a ->
    Transform (sh:.Int) a
@@ -647,7 +646,7 @@
       deriving (Show)
 
 levelCachePrime ::
-   (RealFloat a, IsFloating a, Elt a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Integer ->
    Maybe (SubTransform (Complex a)) ->
    Sign a -> LevelCachePrime (Complex a)
@@ -666,7 +665,7 @@
 Rader's algorithm for prime length signals.
 -}
 transformPrime ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCachePrime a ->
    Maybe (SubTransformPair a) ->
    Transform (sh:.Int) a
@@ -701,7 +700,7 @@
 and nicer factors in <http://oeis.org/A061303>.
 -}
 transformChirp2 ::
-   (Slice sh, Shape sh, Elt a, IsFloating a, RealFloat a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    Sign a -> Int ->
    Transform (sh :. Int) (Complex a)
 transformChirp2 = transformChirpComplete NumberTheory.ceilingPowerOfTwo
@@ -713,14 +712,14 @@
 (5-smooth = all prime factors are at most 5)
 -}
 transformChirp235 ::
-   (Slice sh, Shape sh, Elt a, IsFloating a, RealFloat a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    Sign a -> Int ->
    Transform (sh :. Int) (Complex a)
 transformChirp235 = transformChirpComplete NumberTheory.ceiling5Smooth
 
 
 transformChirpComplete ::
-   (Slice sh, Shape sh, Elt a, IsFloating a, RealFloat a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a, Num a, Ord a) =>
    (Integer -> Integer) ->
    Sign a -> Int ->
    Transform (sh :. Int) (Complex a)
@@ -741,7 +740,7 @@
       deriving (Show)
 
 levelCacheChirp ::
-   (RealFloat a, IsFloating a, Elt a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Integer -> Integer ->
    SubTransform (Complex a) ->
    Sign a -> LevelCacheChirp (Complex a)
@@ -757,7 +756,7 @@
 and possibly slightly generalised basis vectors.
 -}
 transformChirp ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    LevelCacheChirp a ->
    SubTransformPair a ->
    Transform (sh:.Int) a
@@ -776,7 +775,8 @@
 Signals must have equal size and must not be empty.
 -}
 convolveCyclic ::
-   (Shape sh, Slice sh, a ~ Complex b, Elt b, IsFloating b, RealFloat b) =>
+   (Shape sh, Slice sh, a ~ Complex b,
+    A.RealFloat b, A.FromIntegral Int b, Num b) =>
    Int ->
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int) a) ->
@@ -790,7 +790,7 @@
            cacheFromPlan (plan len) zInv)
 
 convolveCyclicCache ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b, A.FromIntegral Int b) =>
    SubTransformPair a ->
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int) a) ->
@@ -799,7 +799,7 @@
    convolveSpectrumCyclicCache transs $ scaleDown $ trans x
 
 convolveSingleSpectrumCyclicCache ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    SubTransformPair a ->
    Acc (Array DIM1 a) -> Transform (sh:.Int) a
 convolveSingleSpectrumCyclicCache caches x y =
@@ -812,12 +812,12 @@
 if you want a plain convolution.
 -}
 convolveSpectrumCyclicCache ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    SubTransformPair a ->
    Acc (Array (sh:.Int) a) -> Transform (sh:.Int) a
 convolveSpectrumCyclicCache (SubTransformPair trans transInv) x y =
    transInv $ A.zipWith (*) x (trans y)
 
 
-expInteger :: (Elt a, Num a) => Integer -> Exp a
-expInteger = A.constant . fromInteger
+expInteger :: (A.Num a) => Integer -> Exp a
+expInteger = A.fromInteger
diff --git a/src/Data/Array/Accelerate/Fourier/Preprocessed.hs b/src/Data/Array/Accelerate/Fourier/Preprocessed.hs
--- a/src/Data/Array/Accelerate/Fourier/Preprocessed.hs
+++ b/src/Data/Array/Accelerate/Fourier/Preprocessed.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 {- |
 The implementations in this module require
 that you know the transformation data set size on the Haskell side.
@@ -43,8 +44,7 @@
 import qualified Data.Array.Accelerate.Utility.Sliced as Sliced
 
 import qualified Data.Array.Accelerate as A
-import Data.Array.Accelerate
-          (Slice, Shape, (:.), Exp, Elt, IsFloating, )
+import Data.Array.Accelerate (Slice, Shape, (:.), Exp, )
 
 
 {- |
@@ -52,7 +52,7 @@
 Should be faster than 'dit2'.
 -}
 ditSplitRadix ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Sign a ->
    Int ->
    Transform (sh:.Int) (Complex a)
@@ -78,7 +78,7 @@
 and then work with @sh = Z@.
 -}
 ditSplitRadixGo ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) ->
    Int ->
    PairTransform (sh:.Int:.Int) (Complex a)
@@ -98,7 +98,7 @@
 Decimation in time for power-of-two sizes.
 -}
 dit2 ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Sign a ->
    Int ->
    Transform (sh:.Int) (Complex a)
@@ -116,7 +116,7 @@
 Decimation in frequency for power-of-two sizes.
 -}
 dif2 ::
-   (Slice sh, Shape sh, IsFloating a, Elt a) =>
+   (Slice sh, Shape sh, A.RealFloat a, A.FromIntegral Int a) =>
    Sign a ->
    Int ->
    Transform (sh:.Int) (Complex a)
@@ -141,7 +141,7 @@
 are ordered from least-significant to most-significant dimension.
 -}
 transform2d ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    SubTransformPair (Complex a) ->
    Transform (sh:.Int:.Int) (Complex a)
 transform2d (SubTransformPair transform0 transform1) =
@@ -153,7 +153,7 @@
 are ordered from least-significant to most-significant dimension.
 -}
 transform3d ::
-   (Shape sh, Slice sh, IsFloating a, Elt a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    SubTransformTriple (Complex a) ->
    Transform (sh:.Int:.Int:.Int) (Complex a)
 transform3d (SubTransformTriple transform0 transform1 transform2) =
diff --git a/src/Data/Array/Accelerate/Fourier/Private.hs b/src/Data/Array/Accelerate/Fourier/Private.hs
--- a/src/Data/Array/Accelerate/Fourier/Private.hs
+++ b/src/Data/Array/Accelerate/Fourier/Private.hs
@@ -1,11 +1,12 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE FlexibleContexts #-}
 module Data.Array.Accelerate.Fourier.Private where
 
 import qualified Data.Array.Accelerate.Fourier.Sign as Sign
 import qualified Data.Array.Accelerate.Convolution.Small as Cyclic
-import Data.Array.Accelerate.Fourier.Sign (Sign, )
+import Data.Array.Accelerate.Fourier.Sign (Sign(Sign), )
 
 import qualified Data.Array.Accelerate.Utility.Sliced as Sliced
 import qualified Data.Array.Accelerate.Utility.Sliced1 as Sliced1
@@ -17,10 +18,10 @@
 import Data.Array.Accelerate.Utility.Lift.Exp (expr)
 
 import qualified Data.Array.Accelerate as A
-import Data.Array.Accelerate.Data.Complex (Complex((:+)), )
 import Data.Array.Accelerate
-          (Exp, Acc, Array, DIM1, DIM2, IsNum, IsFloating, Elt,
-           Z(Z), (:.)((:.)), Slice, Shape, (!), (?), (==*), (>*), )
+          (Exp, Acc, Array, DIM1, DIM2, Elt,
+           Z(Z), (:.)((:.)), Slice, Shape, (!), (?), )
+import Data.Complex (Complex((:+)), )
 
 
 type Transform sh a = Acc (Array sh a) -> Acc (Array sh a)
@@ -50,13 +51,15 @@
            (forall sh. (Shape sh, Slice sh) => PairTransform (sh:.Int:.Int) a)
 
 
-cache2 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), Elt b, IsFloating b) =>
+cache2 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), A.RealFloat b) =>
    sign -> a
-cache3 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), Elt b, IsFloating b) =>
+cache3 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), A.RealFloat b) =>
    sign -> (a,a)
-cache4 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), Elt b, IsFloating b) =>
+cache4 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), A.RealFloat b) =>
    sign -> (a,a,a)
-cache5 :: (sign ~ Exp (Sign b), a ~ Exp (Complex b), Elt b, IsFloating b) =>
+cache5 ::
+   (sign ~ Exp (Sign b), a ~ Exp (Complex b),
+    A.RealFloat b, A.FromIntegral Int b) =>
    sign -> (a,a,a,a)
 
 cache2 _sign = -1
@@ -85,10 +88,10 @@
    A.generate
       (Exp.indexCons (A.shape x) (A.constant 2))
       (Exp.modify (expr :. expr) $
-       \(ix :. k)  ->  let xi = x ! ix in k ==* 0 ? (A.fst xi, A.snd xi))
+       \(ix :. k)  ->  let xi = x ! ix in k A.== 0 ? (A.fst xi, A.snd xi))
 
 transform2 ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    Exp a -> Transform (sh:.Int) a
 transform2 z arr =
    flatten2 $
@@ -108,12 +111,12 @@
        \(ix :. k)  ->
           let (x0,x1,x2) = A.unlift $ x ! ix
           in  flip (A.caseof k) x0 $
-                 ((==*1), x1) :
-                 ((==*2), x2) :
+                 ((A.==1), x1) :
+                 ((A.==2), x2) :
                  [])
 
 transform3 ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    (Exp a, Exp a) -> Transform (sh:.Int) a
 transform3 (z,z2) arr =
    flatten3 $
@@ -137,13 +140,13 @@
        \(ix :. k)  ->
           let (x0,x1,x2,x3) = A.unlift $ x ! ix
           in  flip (A.caseof k) x0 $
-                 ((==*1), x1) :
-                 ((==*2), x2) :
-                 ((==*3), x3) :
+                 ((A.==1), x1) :
+                 ((A.==2), x2) :
+                 ((A.==3), x3) :
                  [])
 
 transform4 ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    (Exp a, Exp a, Exp a) -> Transform (sh:.Int) a
 transform4 (z,z2,z3) arr =
    flatten4 $
@@ -170,10 +173,10 @@
        \(ix :. k)  ->
           let (x0,x1,x2,x3,x4) = A.unlift $ x ! ix
           in  flip (A.caseof k) x0 $
-                 ((==*1), x1) :
-                 ((==*2), x2) :
-                 ((==*3), x3) :
-                 ((==*4), x4) :
+                 ((A.==1), x1) :
+                 ((A.==2), x2) :
+                 ((A.==3), x3) :
+                 ((A.==4), x4) :
                  [])
 
 
@@ -197,7 +200,7 @@
 0 3 1 2 4
 -}
 transform5 ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    (Exp a, Exp a, Exp a, Exp a) -> Transform (sh:.Int) a
 transform5 (z1,z2,z3,z4) arr =
    flatten5 $
@@ -250,20 +253,20 @@
       (Exp.modify (expr :. expr :. expr) $
        \(globalIx :. evenOdd :. k) ->
           let ix = A.lift $ globalIx :. k
-          in  evenOdd ==* 0 ? (x ! ix, y ! ix))
+          in  evenOdd A.== 0 ? (x ! ix, y ! ix))
 
 
 {- |
 twiddle factors for radix-2 Cooley-Tukey transforms
 -}
 twiddleFactors2 ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Acc (A.Vector (Complex a))
 twiddleFactors2 sign len2 =
    A.generate (A.lift $ Z:.len2) $ twiddle2 sign len2 . A.indexHead
 
 twiddle2 ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Exp (Complex a)
 twiddle2 sign n2i ki =
    let n2 = A.fromIntegral n2i
@@ -272,7 +275,7 @@
 
 
 twiddleFactors ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Acc (Array DIM2 (Complex a))
 twiddleFactors sign lenk lenj =
    A.generate (A.lift $ Z:.lenk:.lenj) $
@@ -280,14 +283,14 @@
    \(_z :. k :. j) -> twiddle sign (lenk*lenj) k j
 
 twiddle ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Exp Int -> Exp (Complex a)
 twiddle sign n k j =
    Sign.cisRat sign n $ mod (k*j) n
 
 
 transformRadix2InterleavedTime ::
-   (Shape sh, Slice sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Shape sh, Slice sh, a ~ Complex b, A.RealFloat b) =>
    Acc (Array DIM1 a) ->
    Transform (sh:.Int:.Int) a ->
    Transform (sh:.Int) a
@@ -309,7 +312,7 @@
 
 
 initSplitRadix ::
-   (Slice sh, Shape sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Slice sh, Shape sh, a ~ Complex b, A.RealFloat b) =>
    Acc (Array (sh:.Int) a) ->
    (Acc (Array (sh:.Int:.Int) a), Acc (Array (sh:.Int:.Int) a))
 initSplitRadix arr =
@@ -318,14 +321,14 @@
         A.fill (A.lift $ sh:.(0::Int):.div len 2) 0)
 
 finishSplitRadix ::
-   (Slice sh, Shape sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Slice sh, Shape sh, a ~ Complex b, A.RealFloat b) =>
    Acc (Array (sh:.Int:.Int) a) -> Acc (Array (sh:.Int) a)
 finishSplitRadix =
    flip A.slice (A.lift $ A.Any :. (0::Int) :. A.All)
 
 
 initSplitRadixFlat ::
-   (Slice sh, Shape sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Slice sh, Shape sh, a ~ Complex b, A.RealFloat b) =>
    Acc (Array (sh:.Int) a) ->
    (Acc (Array DIM2 a), Acc (Array DIM2 a))
 initSplitRadixFlat arr =
@@ -334,18 +337,18 @@
         A.fill (A.lift $ Z:.(0::Int):.div len 2) 0)
 
 finishSplitRadixFlat ::
-   (Slice sh, Shape sh, a ~ Complex b, IsFloating b, Elt b) =>
+   (Slice sh, Shape sh, a ~ Complex b, A.RealFloat b) =>
    Exp (sh:.Int) -> Acc (Array DIM2 a) -> Acc (Array (sh:.Int) a)
 finishSplitRadixFlat = A.reshape
 
 
 imagSplitRadixPlain ::
-   (Elt a, IsNum a) =>
+   (Num a) =>
    Sign a -> Complex a
 imagSplitRadixPlain sign = 0 :+ Sign.getSign sign
 
 imagSplitRadix ::
-   (Elt a, IsNum a) =>
+   (A.Num a) =>
    Exp (Sign a) -> Exp (Complex a)
 imagSplitRadix sign =
    A.lift (0 :+ Sign.toSign sign)
@@ -359,12 +362,12 @@
    in  (Sliced1.append evens arr1, twist 2 odds)
 
 ditSplitRadixBase ::
-   (Slice sh, Shape sh, Elt a, IsFloating a) =>
+   (Slice sh, Shape sh, A.RealFloat a) =>
    PairTransform (sh:.Int:.Int) (Complex a)
 ditSplitRadixBase (arr2, arr1) = (transform2 (-1) arr2, arr1)
 
 ditSplitRadixStep ::
-   (Slice sh, Shape sh, a ~ Complex b, Elt b, IsFloating b) =>
+   (Slice sh, Shape sh, a ~ Complex b, A.RealFloat b) =>
    Exp a ->
    (Acc (Array DIM1 a), Acc (Array DIM1 a)) ->
    PairTransform (sh:.Int:.Int) a
@@ -383,7 +386,7 @@
 
 
 twiddleSR ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Exp Int -> Exp (Complex a)
 twiddleSR sign n4i ki ji =
    let n4 = A.fromIntegral n4i
@@ -392,13 +395,13 @@
    in  Sign.cis sign $ pi*(k*j)/(2*n4)
 
 twiddleFactorsSR ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Acc (Array DIM1 (Complex a))
 twiddleFactorsSR sign len4 k =
    A.generate (A.lift $ Z:.len4) $ twiddleSR sign len4 k . A.indexHead
 
 twiddleFactorsSRPair ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int ->
    (Acc (Array DIM1 (Complex a)), Acc (Array DIM1 (Complex a)))
 twiddleFactorsSRPair sign len4 =
@@ -421,11 +424,11 @@
 
 
 chirp ::
-   (Elt a, IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp a -> A.Acc (A.Array DIM1 (Complex a))
 chirp sign padLen lenFloat =
    A.generate (A.index1 padLen) $
    \ix ->
       let k = A.unindex1 ix
-          sk = A.fromIntegral (padLen >* 2*k ? (k, k-padLen))
+          sk = A.fromIntegral (padLen A.> 2*k ? (k, k-padLen))
       in  Sign.cis sign (pi*sk*sk/lenFloat)
diff --git a/src/Data/Array/Accelerate/Fourier/Real.hs b/src/Data/Array/Accelerate/Fourier/Real.hs
--- a/src/Data/Array/Accelerate/Fourier/Real.hs
+++ b/src/Data/Array/Accelerate/Fourier/Real.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 {- |
 Compute transforms on real data based on complex-valued transforms.
 -}
@@ -35,8 +36,7 @@
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Acc, Array, Exp, Elt, IsFloating, Slice, Shape, (:.)((:.)),
-           (!), (?), (==*), )
+          (Acc, Array, Exp, Slice, Shape, (:.)((:.)), (!), (?), )
 
 
 {- |
@@ -46,7 +46,7 @@
 Result has the same size as the input, i.e. it is not halved.
 -}
 toSpectrum ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Fourier.Transform (sh:.Int) (Complex a) ->
    Acc (Array (sh:.Int) a) -> Acc (Array (sh:.Int) (Complex a))
 toSpectrum subTrans arr =
@@ -69,7 +69,7 @@
        A.zipWith (+) evens odds
 
 complexDeinterleave ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int) a) -> Acc (Array (sh:.Int) (Complex a))
 complexDeinterleave arr =
    let (sh:.len) = Exp.unlift (expr:.expr) $ A.shape arr
@@ -89,7 +89,7 @@
 Result has the same size as the input, i.e. it is not doubled.
 -}
 fromSpectrum ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Fourier.Transform (sh:.Int) (Complex a) ->
    Acc (Array (sh:.Int) (Complex a)) -> Acc (Array (sh:.Int) a)
 fromSpectrum subTrans spec =
@@ -106,7 +106,7 @@
    in  complexInterleave $ subTrans $ A.zipWith (+) fe fo
 
 complexInterleave ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int) (Complex a)) -> Acc (Array (sh:.Int) a)
 complexInterleave arr =
    let (sh:.len) = Exp.unlift (expr:.expr) $ A.shape arr
@@ -117,7 +117,7 @@
              let k = div j 2
                  r = mod j 2
                  x = arr ! A.lift (ix:.k)
-             in  r==*0 ? (Complex.real x, Complex.imag x))
+             in  r A.== 0 ? (Complex.real x, Complex.imag x))
 
 
 {- |
@@ -126,7 +126,7 @@
 Input can have arbitrary size.
 -}
 twoToSpectrum ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Fourier.Transform (sh:.Int) (Complex a) ->
    Acc (Array (sh:.Int) (a,a)) ->
    Acc (Array (sh:.Int) (Complex a, Complex a))
@@ -135,7 +135,7 @@
    A.map (Exp.modify (expr,expr) $ uncurry (:+))
 
 twoToSpectrum2d ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Fourier.Transform (sh:.Int:.Int) (Complex a) ->
    Acc (Array (sh:.Int:.Int) (a,a)) ->
    Acc (Array (sh:.Int:.Int) (Complex a, Complex a))
@@ -165,21 +165,21 @@
   -> this swaps role of f and g in the proof above
 -}
 untangleSpectra ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int) (Complex a)) ->
    Acc (Array (sh:.Int) (Complex a, Complex a))
 untangleSpectra spec =
    A.zipWith untangleCoefficient spec (Cyclic.reverse spec)
 
 untangleSpectra2d ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int:.Int) (Complex a)) ->
    Acc (Array (sh:.Int:.Int) (Complex a, Complex a))
 untangleSpectra2d spec =
    A.zipWith untangleCoefficient spec (Cyclic.reverse2d spec)
 
 untangleCoefficient ::
-   (IsFloating a, Elt a) =>
+   (A.RealFloat a) =>
    Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a, Complex a)
 untangleCoefficient a b =
    let bc = Complex.conjugate b
@@ -187,7 +187,7 @@
 
 
 twoFromSpectrum ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Fourier.Transform (sh:.Int) (Complex a) ->
    Acc (Array (sh:.Int) (Complex a, Complex a)) ->
    Acc (Array (sh:.Int) (a,a))
@@ -196,7 +196,7 @@
    subTrans . entangleSpectra
 
 twoFromSpectrum2d ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Fourier.Transform (sh:.Int:.Int) (Complex a) ->
    Acc (Array (sh:.Int:.Int) (Complex a, Complex a)) ->
    Acc (Array (sh:.Int:.Int) (a,a))
@@ -205,19 +205,19 @@
    subTrans . entangleSpectra2d
 
 entangleSpectra ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int) (Complex a, Complex a)) ->
    Acc (Array (sh:.Int) (Complex a))
 entangleSpectra = entangleSpectraGen
 
 entangleSpectra2d ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array (sh:.Int:.Int) (Complex a, Complex a)) ->
    Acc (Array (sh:.Int:.Int) (Complex a))
 entangleSpectra2d = entangleSpectraGen
 
 entangleSpectraGen ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a) =>
    Acc (Array sh (Complex a, Complex a)) ->
    Acc (Array sh (Complex a))
 entangleSpectraGen = A.map (A.fst . A.uncurry entangleCoefficient)
@@ -228,12 +228,16 @@
 2i*d = a - bc     bc = c - i*d
 -}
 entangleCoefficient ::
-   (IsFloating a, Elt a) =>
+   (A.RealFloat a) =>
    Exp (Complex a) -> Exp (Complex a) -> Exp (Complex a, Complex a)
 entangleCoefficient c d =
    let di = d * imagUnit
    in  A.lift (c + di, Complex.conjugate (c - di))
 
 
-imagUnit :: (A.Elt a, A.IsNum a) => Exp (Complex a)
-imagUnit = A.constant $ 0 :+ 1
+imagUnit :: (A.Num a) => Exp (Complex a)
+imagUnit = A.lift $ zero :+ one
+
+zero, one :: (A.Num a) => Exp a
+zero = 0
+one = 1
diff --git a/src/Data/Array/Accelerate/Fourier/Sign.hs b/src/Data/Array/Accelerate/Fourier/Sign.hs
--- a/src/Data/Array/Accelerate/Fourier/Sign.hs
+++ b/src/Data/Array/Accelerate/Fourier/Sign.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 module Data.Array.Accelerate.Fourier.Sign where
 
@@ -9,13 +10,14 @@
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate (Lift(lift), Unlift(unlift), Plain, )
-import Data.Array.Accelerate.Smart (Exp(Exp), PreExp(Tuple, Prj), )
-import Data.Array.Accelerate.Tuple
-          (IsTuple(TupleRepr, fromTuple, toTuple),
-           Tuple(NilTup, SnocTup), TupleIdx(ZeroTupIdx), )
+import Data.Array.Accelerate.Product
+         (IsProduct(ProdRepr, fromProd, toProd, prod),
+          ProdR(ProdRsnoc, ProdRunit),
+          TupleIdx(ZeroTupIdx), )
 import Data.Array.Accelerate.Array.Sugar
-          (Elt(eltType, toElt, fromElt, eltType', toElt', fromElt'),
-           EltRepr, EltRepr', )
+         (Tuple(NilTup, SnocTup),
+          EltRepr, Elt(eltType, toElt, fromElt), )
+import Data.Array.Accelerate.Smart (Exp(Exp), PreExp(Tuple, Prj), )
 
 import Data.Typeable (Typeable, )
 
@@ -25,22 +27,18 @@
 newtype Sign a = Sign {getSign :: a}
    deriving (Eq, Show, Typeable)
 
-type instance EltRepr  (Sign a) = EltRepr  a
-type instance EltRepr' (Sign a) = EltRepr' a
+type instance EltRepr (Sign a) = EltRepr a
 
 instance Elt a => Elt (Sign a) where
    eltType = eltType . getSign
    toElt   = Sign . toElt
    fromElt = fromElt . getSign
 
-   eltType' = eltType' . getSign
-   toElt'   = Sign . toElt'
-   fromElt' = fromElt' . getSign
-
-instance IsTuple (Sign a) where
-   type TupleRepr (Sign a) = ((), a)
-   fromTuple (Sign a) = ((), a)
-   toTuple ((), a)    = Sign a
+instance (cst a) => IsProduct cst (Sign a) where
+   type ProdRepr (Sign a) = ((), a)
+   fromProd _ (Sign a) = ((), a)
+   toProd _ ((), a) = Sign a
+   prod _ (Sign _) = ProdRsnoc ProdRunit
 
 instance (Lift Exp a, Elt (Plain a)) => Lift Exp (Sign a) where
    type Plain (Sign a) = Sign (Plain a)
@@ -54,20 +52,20 @@
 forward = Sign (-1)
 inverse = Sign 1
 
-forwardExp, inverseExp :: (Elt a, A.IsNum a) => Exp (Sign a)
-forwardExp = lift $ Sign $ A.fromIntegral (-1 :: Exp Int)
-inverseExp = lift $ Sign $ A.fromIntegral ( 1 :: Exp Int)
+forwardExp, inverseExp :: (A.Num a) => Exp (Sign a)
+forwardExp = lift $ Sign (-1 :: (A.Num a) => Exp a)
+inverseExp = lift $ Sign ( 1 :: (A.Num a) => Exp a)
 
 toSign :: (Elt a) => Exp (Sign a) -> Exp a
 toSign = getSign . unlift
 
 cis ::
-   (Elt a, A.IsFloating a) =>
+   (A.RealFloat a) =>
    Exp (Sign a) -> Exp a -> Exp (Complex a)
 cis sign w  =  A.lift $ cos w :+ toSign sign * sin w
 
 cisRat ::
-   (Elt a, A.IsFloating a) =>
+   (A.RealFloat a, A.FromIntegral Int a) =>
    Exp (Sign a) -> Exp Int -> Exp Int -> Exp (Complex a)
 cisRat sign denom numer =
    cis sign $ 2*pi * A.fromIntegral numer / A.fromIntegral denom
diff --git a/src/Data/Array/Accelerate/Fourier/Utility.hs b/src/Data/Array/Accelerate/Fourier/Utility.hs
--- a/src/Data/Array/Accelerate/Fourier/Utility.hs
+++ b/src/Data/Array/Accelerate/Fourier/Utility.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE FlexibleContexts #-}
 module Data.Array.Accelerate.Fourier.Utility (
    scaleDown,
    ) where
@@ -10,19 +11,16 @@
 
 import qualified Data.Array.Accelerate.Utility.Sliced as Sliced
 import qualified Data.Array.Accelerate as A
-import Data.Array.Accelerate
-          (Exp, Elt, IsNum, IsFloating, Slice, Shape, (:.), )
+import Data.Array.Accelerate (Exp, Slice, Shape, (:.), )
 
 
 scaleDown ::
-   (Shape sh, Slice sh, Elt a, IsFloating a) =>
+   (Shape sh, Slice sh, A.RealFloat a, A.FromIntegral Int a) =>
    Transform (sh:.Int) (Complex a)
 scaleDown zs =
    A.map (cscale (recip $ A.fromIntegral $ Sliced.length zs)) zs
 
-cscale ::
-   (IsNum a, Elt a) =>
-   Exp a -> Exp (Complex a) -> Exp (Complex a)
+cscale :: (A.Num a) => Exp a -> Exp (Complex a) -> Exp (Complex a)
 cscale x z =
    case A.unlift z of
       r :+ i -> A.lift (x*r :+ x*i)
diff --git a/test/Test/Data/Array/Accelerate/Fourier.hs b/test/Test/Data/Array/Accelerate/Fourier.hs
--- a/test/Test/Data/Array/Accelerate/Fourier.hs
+++ b/test/Test/Data/Array/Accelerate/Fourier.hs
@@ -14,8 +14,7 @@
 import Data.Array.Accelerate.Fourier.Planned (Transform, )
 import Data.Array.Accelerate.Fourier.Utility (scaleDown, )
 import Data.Array.Accelerate
-          (Acc, Exp, Array, DIM1, DIM2, DIM3, Z(Z), (:.)((:.)),
-           (<=*), (==*),(&&*), )
+          (Acc, Exp, Array, DIM1, DIM2, DIM3, Z(Z), (:.)((:.)), )
 
 import qualified Data.Array.Accelerate.LinearAlgebra as LinAlg
 import qualified Data.Array.Accelerate.Utility.Sliced as Sliced
@@ -36,16 +35,16 @@
 tolerance = 1e-10
 
 approxEqualAbs ::
-   (A.Elt a, A.IsFloating a) =>
+   (A.RealFloat a) =>
    Exp a -> Exp a -> Exp a -> Exp Bool
 approxEqualAbs eps x y =
-   abs (x-y) <=* eps
+   abs (x-y) A.<= eps
 
 approxEqualComplexAbs ::
-   (A.Elt a, A.IsFloating a) =>
+   (A.RealFloat a) =>
    Exp a -> Exp (Complex a) -> Exp (Complex a) -> Exp Bool
 approxEqualComplexAbs eps x y =
-   Complex.magnitude (x-y) <=* eps
+   Complex.magnitude (x-y) A.<= eps
 
 
 genComplex :: QC.Gen (Complex Double)
@@ -258,9 +257,14 @@
 (<+>) = A.zipWith (+)
 
 
+quickCheckWithSign ::
+   (Arbitrary normed, Show normed) =>
+   (Planned.Sign Double -> normed -> Bool) -> IO ()
+quickCheckWithSign = quickCheck
 
+
 {-
-should be replaced by (==*) in future
+should be replaced by (A.==) in future
 -}
 class (A.Shape sh, A.Slice sh) => EqShape sh where
    eqShape :: Exp sh -> Exp sh -> Exp Bool
@@ -272,7 +276,7 @@
    eqShape =
       Exp.modify2 (expr:.expr) (expr:.expr) $
       \(sh0:.n0) (sh1:.n1) ->
-         n0 ==* n1  &&*  eqShape sh0 sh1
+         n0 A.== n1  A.&&  eqShape sh0 sh1
 
 
 infix 4 =~=
@@ -283,8 +287,8 @@
    Acc (Array sh (Complex Double)) ->
    Acc (A.Scalar Bool)
 (=~=) xs ys =
-   A.map (eqShape (A.shape xs) (A.shape ys)  &&*) $
-   A.and $ A.zipWith (approxEqualComplexAbs (A.constant tolerance)) xs ys
+   A.map (eqShape (A.shape xs) (A.shape ys)  A.&&) $ A.and $ A.flatten $
+   A.zipWith (approxEqualComplexAbs (A.constant tolerance)) xs ys
 
 
 run :: Acc (A.Scalar Bool) -> Bool
@@ -498,7 +502,7 @@
              (specr,speci) =
                 A.unzip $ FourierReal.untangleSpectra $
                 Planned.transform Planned.forward len x
-         in  A.zipWith (&&*)
+         in  A.zipWith (A.&&)
                 (FourierReal.toSpectrum transform xr =~= specr)
                 (FourierReal.toSpectrum transform xi =~= speci)) :
    ("double real to spectrum, arbitrary",
@@ -508,7 +512,7 @@
              transform = Planned.transform Planned.forward len
              (specr,speci) =
                 A.unzip $ FourierReal.untangleSpectra $ transform x
-         in  A.zipWith (&&*)
+         in  A.zipWith (A.&&)
                 (transform xr =~= specr)
                 (transform xi =~= speci)) :
    ("entangle and untangle spectrum of real data",
@@ -517,7 +521,7 @@
                 A.unzip $
                 A.map (A.uncurry FourierReal.untangleCoefficient) $
                 A.zipWith FourierReal.entangleCoefficient x y
-         in  A.zipWith (&&*) (x =~= xt) (y =~= yt)) :
+         in  A.zipWith (A.&&) (x =~= xt) (y =~= yt)) :
    ("double real from spectrum",
       quickCheck $ \(Normed1 len x) -> run $
          let imagUnit = A.constant (0:+1)
@@ -527,11 +531,11 @@
              (xSignal,ySignal) =
                 A.unzip $ FourierReal.twoFromSpectrum transform $
                 A.zip xSelfAdjoint ySelfAdjoint
-         in  A.zipWith (&&*)
+         in  A.zipWith (A.&&)
                 (transform xSelfAdjoint =~= A.map (A.lift . (:+0)) xSignal)
                 (transform ySelfAdjoint =~= A.map (A.lift . (:+0)) ySignal)) :
    ("transform2d vs. transposition, preprocessed",
-      quickCheck $ \sign (Normed2 width height x) -> run $
+      quickCheckWithSign $ \sign (Normed2 width height x) -> run $
          let transformH =
                 Prep.transform2d
                    (Prep.SubTransformPair
@@ -546,7 +550,7 @@
              =~=
              transformV (LinAlg.transpose x)) :
    ("transform2d vs. transposition, adhoc",
-      quickCheck $ \sign (Normed2 _width _height x) -> run $
+      quickCheckWithSign $ \sign (Normed2 _width _height x) -> run $
          let transform =
                 Adhoc.transform2d
                    (Adhoc.SubTransform
@@ -555,7 +559,7 @@
              =~=
              transform (LinAlg.transpose x)) :
    ("transform3d vs. transposition, preprocessed",
-      quickCheck $ \sign (Normed3 width height depth x) -> run $
+      quickCheckWithSign $ \sign (Normed3 width height depth x) -> run $
          let transformH =
                 Prep.transform3d
                    (Prep.SubTransformTriple
@@ -572,7 +576,7 @@
              =~=
              transformV (cycleDim3 x)) :
    ("transform2d vs. transposition, adhoc",
-      quickCheck $ \sign (Normed3 _width _height _depth x) -> run $
+      quickCheckWithSign $ \sign (Normed3 _width _height _depth x) -> run $
          let transform =
                 Adhoc.transform2d
                    (Adhoc.SubTransform