diff --git a/accelerate-utility.cabal b/accelerate-utility.cabal
--- a/accelerate-utility.cabal
+++ b/accelerate-utility.cabal
@@ -1,5 +1,5 @@
 Name:             accelerate-utility
-Version:          0.0
+Version:          0.0.1
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -15,7 +15,7 @@
 Build-Type:       Simple
 
 Source-Repository this
-  Tag:         0.0
+  Tag:         0.0.1
   Type:        darcs
   Location:    http://code.haskell.org/~thielema/accelerate-utility/
 
@@ -38,3 +38,6 @@
     Data.Array.Accelerate.Utility.Lift.Run
     Data.Array.Accelerate.Utility.Loop
     Data.Array.Accelerate.Utility.Arrange
+    Data.Array.Accelerate.Utility.Sliced
+    Data.Array.Accelerate.Utility.Sliced1
+    Data.Array.Accelerate.Utility.Ord
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
@@ -23,7 +23,9 @@
    indexCons,
    ) where
 
+import qualified Data.Array.Accelerate.Data.Complex as Complex
 import qualified Data.Array.Accelerate as A
+import Data.Complex (Complex((:+)))
 import Data.Array.Accelerate (Exp, (:.)((:.)))
 
 import qualified Data.Tuple.HT as Tuple
@@ -109,6 +111,15 @@
    type Tuple (pa :. int) = Tuple pa :. Int
    unlift (pa:.pb) ab =
       (unlift pa $ A.indexTail ab) :. (unlift pb $ A.indexHead ab)
+
+
+instance (Unlift p) => Unlift (Complex p) where
+   type Unlifted (Complex p) = Complex (Unlifted p)
+   type Tuple (Complex p) = Complex (Tuple p)
+   unlift (preal:+pimag) z =
+      unlift preal (Complex.real z)
+      :+
+      unlift pimag (Complex.imag z)
 
 
 unliftPair :: (A.Elt a, A.Elt b) => Exp (a,b) -> (Exp a, Exp b)
diff --git a/src/Data/Array/Accelerate/Utility/Ord.hs b/src/Data/Array/Accelerate/Utility/Ord.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Array/Accelerate/Utility/Ord.hs
@@ -0,0 +1,30 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+module Data.Array.Accelerate.Utility.Ord where
+
+import qualified Data.Array.Accelerate as A
+import Data.Array.Accelerate
+          (Exp, Acc, Array, Elt, Slice, Shape, IsScalar, Scalar,
+           (?), (<=*), )
+
+
+argmin ::
+   (Elt a, Elt b, IsScalar a) =>
+   Exp (a, b) -> Exp (a, b) -> Exp (a, b)
+argmin x y  =  A.fst x <=* A.fst y ? (x,y)
+
+argminimum ::
+   (Slice sh, Shape sh, Elt a, Elt b, IsScalar a) =>
+   Acc (Array sh (a, b)) -> Acc (Scalar (a, b))
+argminimum = A.fold1All argmin
+
+
+argmax ::
+   (Elt a, Elt b, IsScalar a) =>
+   Exp (a, b) -> Exp (a, b) -> Exp (a, b)
+argmax x y  =  A.fst x <=* A.fst y ? (y,x)
+
+argmaximum ::
+   (Slice sh, Shape sh, Elt a, Elt b, IsScalar 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
new file mode 100644
--- /dev/null
+++ b/src/Data/Array/Accelerate/Utility/Sliced.hs
@@ -0,0 +1,155 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{- |
+List-like functions on the inner dimension.
+-}
+module Data.Array.Accelerate.Utility.Sliced where
+
+import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp
+import Data.Array.Accelerate.Utility.Lift.Exp (atom)
+
+import qualified Data.Array.Accelerate as A
+import Data.Array.Accelerate
+          (Exp, Acc, Array, Elt, Slice, Shape, DIM2, (:.)((:.)),
+           (!), (?), (==*), (<*), )
+
+
+length ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Exp Int
+length = A.indexHead . A.shape
+
+head ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array sh a)
+head xs = A.slice xs (A.constant $ A.Any:.(0::Int))
+
+tail ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+tail xs =
+   A.backpermute
+      (Exp.modify (atom:.atom)
+          (\(sh :. n) -> sh :. n-1)
+          (A.shape xs))
+      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k+1)
+      xs
+
+cons ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array sh a) ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+cons x xs =
+   A.generate
+      (Exp.modify (atom:.atom)
+          (\(sh :. n) -> sh :. n+1)
+          (A.shape xs))
+      (Exp.modify (atom:.atom) $
+       \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))
+
+consExp ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp a ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+consExp x xs =
+   A.generate
+      (Exp.modify (atom:.atom)
+          (\(z :. n) -> z :. n+1)
+          (A.shape xs))
+      (Exp.modify (atom:.atom) $
+       \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))
+
+
+append3 ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+append3 x y z =
+   let (sh :. n) = Exp.unlift (atom :. atom) $ A.shape x
+   in  A.reshape (A.lift $ sh :. 3*n) $ stack3 x y z
+
+stack3 ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+stack3 x y z =
+   A.generate
+      (Exp.modify (atom :. atom)
+         (\(sh :. n) -> sh :. (3::Int) :. n)
+         (A.shape x))
+      (Exp.modify (atom :. atom :. atom) $
+       \(globalIx :. k :. j) ->
+          let ix = A.lift $ globalIx :. j
+          in  flip (A.caseof k) (x ! ix) $
+                 ((==* 1), (y ! ix)) :
+                 ((==* 2), (z ! ix)) :
+                 [])
+
+
+take, drop ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp Int ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+take n arr =
+   A.backpermute
+      (Exp.modify (atom:.atom) (\(sh:._) -> sh:.n) $ A.shape arr)
+      id arr
+
+drop d arr =
+   A.backpermute
+      (Exp.modify (atom:.atom) (\(sh:.n) -> sh :. n - d) $ A.shape arr)
+      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k + d)
+      arr
+
+pad ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp a -> Exp Int ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+pad x n arr =
+   let sh:.m = Exp.unlift (atom:.atom) $ A.shape arr
+   in  A.generate
+          (A.lift $ sh:.n)
+          (\ix -> A.indexHead ix <* m ? (arr!ix, x))
+
+
+{- |
+@sliceVertical@ would be a simple 'A.reshape'.
+-}
+sliceHorizontal ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp DIM2 ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+sliceHorizontal nm arr =
+   let _z:.n:.m = Exp.unlift (atom:.atom:.atom) nm
+       sh = A.indexTail $ A.shape arr
+   in  A.backpermute
+          (A.lift $ sh :. n :. m)
+          (Exp.modify (atom :. atom :. atom) $
+           \(ix :. k :. j) -> ix :. n*j+k)
+          arr
+
+sieve ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp Int ->
+   Exp Int ->
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+sieve m start arr =
+   let sh:.n = Exp.unlift (atom:.atom) $ A.shape arr
+   in  A.backpermute
+          (A.lift $ sh :. div n m)
+          (Exp.modify (atom :. atom) $
+           \(ix :. j) -> ix :. m*j + start)
+          arr
diff --git a/src/Data/Array/Accelerate/Utility/Sliced1.hs b/src/Data/Array/Accelerate/Utility/Sliced1.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Array/Accelerate/Utility/Sliced1.hs
@@ -0,0 +1,131 @@
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{- |
+List-like functions on the next-to-innermost dimension.
+-}
+module Data.Array.Accelerate.Utility.Sliced1 where
+
+import qualified Data.Array.Accelerate.Utility.Lift.Exp as Exp
+import Data.Array.Accelerate.Utility.Lift.Exp (atom)
+
+import qualified Data.Array.Accelerate as A
+import Data.Array.Accelerate
+          (Exp, Acc, Array, Elt, (:.)((:.)), Slice, Shape,
+           (!), (?), (<*), (==*), )
+
+
+length ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Exp Int
+length = A.indexHead . A.indexTail . A.shape
+
+head ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int) a)
+head xs = A.slice xs (A.constant $ A.Any:.(0::Int):.A.All)
+
+tail ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+tail xs =
+   A.backpermute
+      (Exp.modify (atom:.atom:.atom)
+          (\(sh :. n :. m) -> sh :. n-1 :. m)
+          (A.shape xs))
+      (Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) -> ix :. k+1 :. j)
+      xs
+
+cons ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+cons x xs =
+   A.generate
+      (Exp.modify (atom:.atom:.atom)
+          (\(sh :. n :. m) -> sh :. n+1 :. m)
+          (A.shape xs))
+      (Exp.modify (atom:.atom:.atom) $
+       \(ix:.k:.j) ->
+          k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))
+
+{- |
+The outer and innermost dimensions must match.
+Otherwise you may or may not get out-of-bound errors.
+-}
+append ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+append x y =
+   let ( shx:.nx:.lenx) = Exp.unlift (atom:.atom:.atom) $ A.shape x
+       (_shy:.ny:.leny) = Exp.unlift (atom:.atom:.atom) $ A.shape y
+   in  A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $
+       Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) ->
+          k<*nx ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))
+
+append3 ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+append3 x y z =
+   let (sh :. n :. m) = Exp.unlift (atom :. atom :. atom) $ A.shape x
+   in  A.reshape (A.lift $ sh :. 3*n :. m) $ stack3 x y z
+
+stack3 ::
+   (Shape sh, Slice sh, Elt a) =>
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int:.Int) a)
+stack3 x y z =
+   A.generate
+      (Exp.modify (atom :. atom :. atom)
+         (\(sh :. n :. m) -> sh :. (3::Int) :. n :. m)
+         (A.shape x))
+      (Exp.modify (atom :. atom :. atom :. atom) $
+       \(globalIx :. k :. j :. i) ->
+          let ix = A.lift $ globalIx :. j :. i
+          in  flip (A.caseof k) (x ! ix) $
+                 ((==* 1), (y ! ix)) :
+                 ((==* 2), (z ! ix)) :
+                 [])
+
+
+take, drop ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp Int ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+take n arr =
+   A.backpermute
+      (Exp.modify (atom:.atom:.atom) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)
+      id arr
+
+drop d arr =
+   A.backpermute
+      (Exp.modify (atom:.atom:.atom)
+         (\(sh:.n:.m) -> sh :. n - d :. m) $ A.shape arr)
+      (Exp.modify (atom:.atom:.atom) $
+       \(ix:.k:.j) -> ix :. k + d :. j)
+      arr
+
+sieve ::
+   (Shape sh, Slice sh, Elt a) =>
+   Exp Int ->
+   Exp Int ->
+   Acc (Array (sh:.Int:.Int) a) ->
+   Acc (Array (sh:.Int:.Int) a)
+sieve fac start arr =
+   let sh:.n:.m = Exp.unlift (atom:.atom:.atom) $ A.shape arr
+   in  A.backpermute
+          (A.lift $ sh :. div n fac :. m)
+          (Exp.modify (atom :. atom :. atom) $
+           \(ix :. k :. j) -> ix :. fac*k+start :. j)
+          arr