diff --git a/accelerate-utility.cabal b/accelerate-utility.cabal
--- a/accelerate-utility.cabal
+++ b/accelerate-utility.cabal
@@ -1,33 +1,34 @@
 Name:             accelerate-utility
-Version:          0.1.1
+Version:          1.1
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
 Maintainer:       Henning Thielemann <haskell@henning-thielemann.de>
-Homepage:         http://hub.darcs.net/thielema/accelerate-utility/
+Homepage:         https://hub.darcs.net/thielema/accelerate-utility/
 Category:         Parallelism
 Synopsis:         Utility functions for the Accelerate framework
 Description:
   Several utility functions on top of the Accelerate framework.
   The functions simplify working with indices and lifting and unlifting.
 Tested-With:      GHC==7.8.3
-Cabal-Version:    >=1.14
+Cabal-Version:    1.14
 Build-Type:       Simple
 
 Source-Repository this
-  Tag:         0.1.1
+  Tag:         1.1
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/accelerate-utility/
+  Location:    https://hub.darcs.net/thielema/accelerate-utility/
 
 Source-Repository head
   Type:        darcs
-  Location:    http://hub.darcs.net/thielema/accelerate-utility/
+  Location:    https://hub.darcs.net/thielema/accelerate-utility/
 
 Library
   Build-Depends:
-    accelerate >=0.15 && <0.16,
+    accelerate >=1.3 && <1.5,
+    non-empty >=0.3.3 && <0.4,
     utility-ht >=0.0.8 && <0.1,
-    base >=4.5 && <4.10
+    base >=4.5 && <5
 
   GHC-Options:      -Wall -fwarn-missing-import-lists
   Hs-Source-Dirs:   src
diff --git a/src/Data/Array/Accelerate/Utility/Arrange.hs b/src/Data/Array/Accelerate/Utility/Arrange.hs
--- a/src/Data/Array/Accelerate/Utility/Arrange.hs
+++ b/src/Data/Array/Accelerate/Utility/Arrange.hs
@@ -25,7 +25,7 @@
 scatter ::
    (A.Shape ix, A.Shape ix', A.Elt ix', A.Elt a) =>
    (Exp a -> Exp a -> Exp a) ->
-   Acc (Array ix ix') -> Acc (Array ix' a) ->
+   Acc (Array ix (Maybe ix')) -> Acc (Array ix' a) ->
    Acc (Array ix a) -> Acc (Array ix' a)
 scatter f indices deflt xs =
    A.permute f deflt (indices A.!) xs
diff --git a/src/Data/Array/Accelerate/Utility/Lift/Exp.hs b/src/Data/Array/Accelerate/Utility/Lift/Exp.hs
--- a/src/Data/Array/Accelerate/Utility/Lift/Exp.hs
+++ b/src/Data/Array/Accelerate/Utility/Lift/Exp.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
 module Data.Array.Accelerate.Utility.Lift.Exp (
    Unlift,
    Unlifted,
@@ -14,6 +15,8 @@
    unliftPair,
    unliftTriple,
    unliftQuadruple,
+   unliftQuintuple,
+   accessElement,
    asExp,
    mapFst,
    mapSnd,
@@ -28,6 +31,7 @@
 import Data.Complex (Complex((:+)))
 import Data.Array.Accelerate ((:.)((:.)))
 
+import qualified Data.NonEmpty as NonEmpty
 import qualified Data.Tuple.HT as Tuple
 import Data.Tuple.HT (mapTriple)
 
@@ -165,6 +169,24 @@
    (A.Elt a, A.Elt b, A.Elt c, A.Elt d) =>
    A.Exp (a,b,c,d) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d)
 unliftQuadruple = A.unlift
+
+unliftQuintuple ::
+   (A.Elt a, A.Elt b, A.Elt c, A.Elt d, A.Elt e) =>
+   A.Exp (a,b,c,d,e) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d, A.Exp e)
+unliftQuintuple = A.unlift
+
+{- |
+Intended to access elements of a tuple.
+
+> accessElement [x,y,z] k ==
+>    A.ifThenElse (k A.== 1) y $
+>    A.ifThenElse (k A.== 2) z $
+>    x
+-}
+accessElement :: (A.Elt a) => NonEmpty.T [] (A.Exp a) -> A.Exp Int -> A.Exp a
+accessElement (NonEmpty.Cons x xs) k =
+   foldr (\(j,y) -> A.ifThenElse (k A.== fromInteger j) y) x (zip [1..] xs)
+
 
 asExp :: A.Exp a -> A.Exp a
 asExp = id
diff --git a/src/Data/Array/Accelerate/Utility/Lift/Run.hs b/src/Data/Array/Accelerate/Utility/Lift/Run.hs
--- a/src/Data/Array/Accelerate/Utility/Lift/Run.hs
+++ b/src/Data/Array/Accelerate/Utility/Lift/Run.hs
@@ -82,13 +82,13 @@
    with1 ::
       (A.Arrays a) =>
       ((Acc (Arguments a f) -> Acc (Result f)) ->
-       ((Arguments a f) -> Result f)) ->
+       (Arguments a f -> Result f)) ->
       (Acc a -> f) -> a -> Plain f
 
 with ::
    (C f) =>
    ((Acc (Arguments () f) -> Acc (Result f)) ->
-    ((Arguments () f) -> Result f)) ->
+    (Arguments () f -> Result f)) ->
    f -> Plain f
 with run f = with1 run (const f) ()
 
diff --git a/src/Data/Array/Accelerate/Utility/Loop.hs b/src/Data/Array/Accelerate/Utility/Loop.hs
--- a/src/Data/Array/Accelerate/Utility/Loop.hs
+++ b/src/Data/Array/Accelerate/Utility/Loop.hs
@@ -14,34 +14,24 @@
 nest n0 f x0 =
    A.asnd $
    A.awhile
-      (A.map (A.>* 0) . A.afst)
+      (A.map (A.> 0) . A.afst)
       (A.lift . (\(n, x) -> (A.map (subtract 1) n, f x)) . A.unlift)
       (A.lift (A.unit n0, x0))
 
 _nest n0 f x0 =
    A.asnd $
    A.awhile
-      (A.unit . (A.>* 0) . A.the . A.afst)
+      (A.unit . (A.> 0) . A.the . A.afst)
       (A.lift . (\(n, x) -> (A.unit $ A.the n - 1, f x)) . A.unlift)
       (A.lift (A.unit n0, x0))
 
 
-nestLog2, _nestLog2 ::
+nestLog2 ::
    (A.Arrays a) =>
    Exp Int -> (Acc a -> Acc a) -> Acc a -> Acc a
 nestLog2 n0 f x0 =
    A.asnd $
    A.awhile
-      (A.map (A.>* 1) . A.afst)
+      (A.map (A.> 1) . A.afst)
       (A.lift . (\(n, x) -> (A.map (flip div 2 . (1+)) n, f x)) . A.unlift)
       (A.lift (A.unit n0, x0))
-
-{-
-This is an infinite loop,
-because A.acond always has to generate code for both branches.
--}
-_nestLog2 n0 f x0 =
-   let go n x =
-          A.acond (n A.<=* 1) x $
-          go (div (n+1) 2) (f x)
-   in  go n0 x0
diff --git a/src/Data/Array/Accelerate/Utility/Ord.hs b/src/Data/Array/Accelerate/Utility/Ord.hs
--- a/src/Data/Array/Accelerate/Utility/Ord.hs
+++ b/src/Data/Array/Accelerate/Utility/Ord.hs
@@ -4,27 +4,26 @@
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Exp, Acc, Array, Elt, Slice, Shape, IsScalar, Scalar,
-           (?), (<=*), )
+          (Exp, Acc, Array, Elt, Slice, Shape, Scalar, (?), )
 
 
 argmin ::
-   (Elt a, Elt b, IsScalar a) =>
+   (Elt a, Elt b, A.Ord a) =>
    Exp (a, b) -> Exp (a, b) -> Exp (a, b)
-argmin x y  =  A.fst x <=* A.fst y ? (x,y)
+argmin x y  =  A.fst x A.<= A.fst y ? (x,y)
 
 argminimum ::
-   (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>
+   (Slice sh, Shape sh, Elt a, Elt b, A.Ord a) =>
    Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
 argminimum = A.fold1All argmin
 
 
 argmax ::
-   (Elt a, Elt b, IsScalar a) =>
+   (Elt a, Elt b, A.Ord a) =>
    Exp (a, b) -> Exp (a, b) -> Exp (a, b)
-argmax x y  =  A.fst x <=* A.fst y ? (y,x)
+argmax x y  =  A.fst x A.<= A.fst y ? (y,x)
 
 argmaximum ::
-   (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>
+   (Slice sh, Shape sh, Elt a, Elt b, A.Ord a) =>
    Acc (Array sh (a, b)) -> Acc (A.Scalar (a, b))
 argmaximum = A.fold1All argmax
diff --git a/src/Data/Array/Accelerate/Utility/Sliced.hs b/src/Data/Array/Accelerate/Utility/Sliced.hs
--- a/src/Data/Array/Accelerate/Utility/Sliced.hs
+++ b/src/Data/Array/Accelerate/Utility/Sliced.hs
@@ -6,14 +6,15 @@
 module Data.Array.Accelerate.Utility.Sliced where
 
 import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp
-import Data.Array.Accelerate.Utility.Lift.Exp (expr)
+import Data.Array.Accelerate.Utility.Lift.Exp (expr, accessElement)
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)),
-           (!), (?), (>*), (==*), )
+          (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)), (!), (?), )
 
+import Data.NonEmpty ((!:))
 
+
 length ::
    (Shape sh, Slice sh, Elt a) =>
    Acc (Array (sh:.Int) a) ->
@@ -49,7 +50,7 @@
           (\(sh :. n) -> sh :. n+1)
           (A.shape xs))
       (Exp.modify (expr:.expr) $
-       \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))
+       \(ix:.k) -> k A.== 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))
 
 consExp ::
    (Shape sh, Slice sh, Elt a) =>
@@ -62,7 +63,7 @@
           (\(z :. n) -> z :. n+1)
           (A.shape xs))
       (Exp.modify (expr:.expr) $
-       \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))
+       \(ix:.k) -> k A.== 0 ? (x, xs ! A.lift (ix :. k-1)))
 
 
 append3 ::
@@ -88,11 +89,8 @@
          (A.shape x))
       (Exp.modify (expr :. expr :. expr) $
        \(globalIx :. k :. j) ->
-          let ix = A.lift $ globalIx :. j
-          in  flip (A.caseof k) (x ! ix) $
-                 ((==* 1), (y ! ix)) :
-                 ((==* 2), (z ! ix)) :
-                 [])
+         let ix = A.lift $ globalIx :. j
+         in accessElement (x!ix !: y!ix : z!ix : []) k)
 
 
 take, drop ::
@@ -120,7 +118,7 @@
    let sh:.m = Exp.unlift (expr:.expr) $ A.shape arr
    in  A.generate
           (A.lift $ sh:.n)
-          (\ix -> m >* A.indexHead ix ? (arr!ix, x))
+          (\ix -> m A.> A.indexHead ix ? (arr!ix, x))
 
 
 {- |
diff --git a/src/Data/Array/Accelerate/Utility/Sliced1.hs b/src/Data/Array/Accelerate/Utility/Sliced1.hs
--- a/src/Data/Array/Accelerate/Utility/Sliced1.hs
+++ b/src/Data/Array/Accelerate/Utility/Sliced1.hs
@@ -6,14 +6,15 @@
 module Data.Array.Accelerate.Utility.Sliced1 where
 
 import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp
-import Data.Array.Accelerate.Utility.Lift.Exp (expr)
+import Data.Array.Accelerate.Utility.Lift.Exp (expr, accessElement)
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
-          (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape,
-           (!), (?), (>*), (==*), )
+          (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape, (!), (?), )
 
+import Data.NonEmpty ((!:))
 
+
 length ::
    (Shape sh, Slice sh, Elt a) =>
    Acc (Array (sh:.Int:.Int) a) ->
@@ -50,7 +51,7 @@
           (A.shape xs))
       (Exp.modify (expr:.expr:.expr) $
        \(ix:.k:.j) ->
-          k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))
+          k A.== 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))
 
 {- |
 The outer and innermost dimensions must match.
@@ -66,7 +67,7 @@
        (_shy:.ny:.leny) = Exp.unlift (expr:.expr:.expr) $ A.shape y
    in  A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $
        Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) ->
-          nx >* k ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))
+          nx A.> k ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))
 
 append3 ::
    (Shape sh, Slice sh, Elt a) =>
@@ -91,11 +92,8 @@
          (A.shape x))
       (Exp.modify (expr :. expr :. expr :. expr) $
        \(globalIx :. k :. j :. i) ->
-          let ix = A.lift $ globalIx :. j :. i
-          in  flip (A.caseof k) (x ! ix) $
-                 ((==* 1), (y ! ix)) :
-                 ((==* 2), (z ! ix)) :
-                 [])
+         let ix = A.lift $ globalIx :. j :. i
+         in accessElement (x!ix !: y!ix : z!ix : []) k)
 
 
 take, drop ::