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.1
+Version:          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.1
+  Tag:         0.1
   Type:        darcs
   Location:    http://code.haskell.org/~thielema/accelerate-utility/
 
diff --git a/src/Data/Array/Accelerate/Utility/Lift/Acc.hs b/src/Data/Array/Accelerate/Utility/Lift/Acc.hs
--- a/src/Data/Array/Accelerate/Utility/Lift/Acc.hs
+++ b/src/Data/Array/Accelerate/Utility/Lift/Acc.hs
@@ -22,12 +22,24 @@
    the,
    ) where
 
+import Data.Array.Accelerate.Utility.Lift.Exp (Exp(Exp), expr)
 import qualified Data.Array.Accelerate as A
 
 import qualified Data.Tuple.HT as Tuple
 import Data.Tuple.HT (mapTriple)
 
 
+{- |
+This class is like 'Data.Array.Accelerate.Utility.Lift.Exp.Unlift'
+but for the 'Acc' environment.
+It allows you to unlift an 'Acc' of nested tuples
+into tuples of 'Exp' and 'Acc' values.
+It can be quite handy when working with 'A.acond' and 'A.awhile'.
+It can also be useful in connection with running an @accelerate@ algorithm
+at a certain backend,
+like 'Data.Array.Accelerate.Interpreter.run1'.
+But in this case you might prefer "Data.Array.Accelerate.Utility.Lift.Run".
+-}
 class (A.Arrays (Tuple pattern)) => Unlift pattern where
    type Unlifted pattern
    type Tuple pattern
@@ -89,11 +101,6 @@
    type Unlifted (Exp a) = A.Exp a
    type Tuple (Exp a) = A.Scalar a
    unlift _ = A.the
-
-data Exp e = Exp
-
-expr :: Exp e
-expr = Exp
 
 
 -- | like 'A.unit' in the 'Acc' environment
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
@@ -10,7 +10,7 @@
    modify2,
    modify3,
    modify4,
-   Atom(Atom), atom,
+   Exp(Exp), expr, atom,
    unliftPair,
    unliftTriple,
    unliftQuadruple,
@@ -26,47 +26,74 @@
 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 Data.Array.Accelerate ((:.)((:.)))
 
 import qualified Data.Tuple.HT as Tuple
 import Data.Tuple.HT (mapTriple)
 
 
+{- |
+This class simplifies untupling of expressions.
+If you have a function
+
+> g :: ((Exp a, Exp b), Exp (c,d)) -> (Exp e, Exp f)
+
+you cannot apply it to an array @arr :: Array sh ((a,b),(c,d))@ using 'A.map'.
+Here, the 'modify' function helps:
+
+> modify ((expr,expr),expr) g :: Exp ((a,b),(c,d)) -> Exp (e,f)
+
+The 'expr'-pattern tells, how deep the tuple shall be unlifted.
+This way you can write:
+
+> A.map
+>    (Exp.modify ((expr,expr),expr) $ \((a,b), cd) -> g ((a,b), cd))
+>    arr
+
+'modify' is based on 'unlift'.
+In contrast to 'A.unlift' it does not only unlift one level of tupels,
+but is guided by an 'expr'-pattern.
+In the example I have demonstrated,
+how the pair @(a,b)@ is unlifted, but the pair @(c,d)@ is not.
+For the result tuple, 'modify' simply calls 'A.lift'.
+In contrast to 'A.unlift',
+'A.lift' lifts over all tupel levels until it obtains a single 'Exp'.
+-}
 class
    (A.Elt (Tuple pattern), A.Plain (Unlifted pattern) ~ Tuple pattern) =>
       Unlift pattern where
    type Unlifted pattern
    type Tuple pattern
-   unlift :: pattern -> Exp (Tuple pattern) -> Unlifted pattern
+   unlift :: pattern -> A.Exp (Tuple pattern) -> Unlifted pattern
 
 modify ::
-   (A.Lift Exp a, Unlift pattern) =>
+   (A.Lift A.Exp a, Unlift pattern) =>
    pattern ->
    (Unlifted pattern -> a) ->
-   Exp (Tuple pattern) -> Exp (A.Plain a)
+   A.Exp (Tuple pattern) -> A.Exp (A.Plain a)
 modify p f = A.lift . f . unlift p
 
 modify2 ::
-   (A.Lift Exp a, Unlift patternA, Unlift patternB) =>
+   (A.Lift A.Exp a, Unlift patternA, Unlift patternB) =>
    patternA ->
    patternB ->
    (Unlifted patternA -> Unlifted patternB -> a) ->
-   Exp (Tuple patternA) -> Exp (Tuple patternB) -> Exp (A.Plain a)
+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) -> A.Exp (A.Plain a)
 modify2 pa pb f a b = A.lift $ f (unlift pa a) (unlift pb b)
 
 modify3 ::
-   (A.Lift Exp a, Unlift patternA, Unlift patternB, Unlift patternC) =>
+   (A.Lift A.Exp a, Unlift patternA, Unlift patternB, Unlift patternC) =>
    patternA ->
    patternB ->
    patternC ->
    (Unlifted patternA -> Unlifted patternB -> Unlifted patternC -> a) ->
-   Exp (Tuple patternA) -> Exp (Tuple patternB) ->
-   Exp (Tuple patternC) -> Exp (A.Plain a)
+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) ->
+   A.Exp (Tuple patternC) -> A.Exp (A.Plain a)
 modify3 pa pb pc f a b c =
    A.lift $ f (unlift pa a) (unlift pb b) (unlift pc c)
 
 modify4 ::
-   (A.Lift Exp a,
+   (A.Lift A.Exp a,
     Unlift patternA, Unlift patternB, Unlift patternC, Unlift patternD) =>
    patternA ->
    patternB ->
@@ -74,23 +101,28 @@
    patternD ->
    (Unlifted patternA -> Unlifted patternB ->
     Unlifted patternC -> Unlifted patternD -> a) ->
-   Exp (Tuple patternA) -> Exp (Tuple patternB) ->
-   Exp (Tuple patternC) -> Exp (Tuple patternD) -> Exp (A.Plain a)
+   A.Exp (Tuple patternA) -> A.Exp (Tuple patternB) ->
+   A.Exp (Tuple patternC) -> A.Exp (Tuple patternD) -> A.Exp (A.Plain a)
 modify4 pa pb pc pd f a b c d =
    A.lift $ f (unlift pa a) (unlift pb b) (unlift pc c) (unlift pd d)
 
 
-instance (A.Elt a) => Unlift (Atom a) where
-   type Unlifted (Atom a) = Exp a
-   type Tuple (Atom a) = a
+instance (A.Elt a) => Unlift (Exp a) where
+   type Unlifted (Exp a) = A.Exp a
+   type Tuple (Exp a) = a
    unlift _ = id
 
-data Atom a = Atom
+data Exp e = Exp
 
-atom :: Atom a
-atom = Atom
+expr :: Exp e
+expr = Exp
 
+{-# DEPRECATED atom "use expr instead" #-}
+-- | for compatibility with accelerate-utility-0.0
+atom :: Exp e
+atom = expr
 
+
 instance (Unlift pa, Unlift pb) => Unlift (pa,pb) where
    type Unlifted (pa,pb) = (Unlifted pa, Unlifted pb)
    type Tuple (pa,pb) = (Tuple pa, Tuple pb)
@@ -106,8 +138,8 @@
       mapTriple (unlift pa, unlift pb, unlift pc) . A.unlift
 
 
-instance (Unlift pa, A.Slice (Tuple pa), int ~ Atom Int) => Unlift (pa :. int) where
-   type Unlifted (pa :. int) = Unlifted pa :. Exp Int
+instance (Unlift pa, A.Slice (Tuple pa), int ~ Exp Int) => Unlift (pa :. int) where
+   type Unlifted (pa :. int) = Unlifted pa :. A.Exp Int
    type Tuple (pa :. int) = Tuple pa :. Int
    unlift (pa:.pb) ab =
       (unlift pa $ A.indexTail ab) :. (unlift pb $ A.indexHead ab)
@@ -122,49 +154,49 @@
       unlift pimag (Complex.imag z)
 
 
-unliftPair :: (A.Elt a, A.Elt b) => Exp (a,b) -> (Exp a, Exp b)
+unliftPair :: (A.Elt a, A.Elt b) => A.Exp (a,b) -> (A.Exp a, A.Exp b)
 unliftPair = A.unlift
 
 unliftTriple ::
-   (A.Elt a, A.Elt b, A.Elt c) => Exp (a,b,c) -> (Exp a, Exp b, Exp c)
+   (A.Elt a, A.Elt b, A.Elt c) => A.Exp (a,b,c) -> (A.Exp a, A.Exp b, A.Exp c)
 unliftTriple = A.unlift
 
 unliftQuadruple ::
    (A.Elt a, A.Elt b, A.Elt c, A.Elt d) =>
-   Exp (a,b,c,d) -> (Exp a, Exp b, Exp c, Exp d)
+   A.Exp (a,b,c,d) -> (A.Exp a, A.Exp b, A.Exp c, A.Exp d)
 unliftQuadruple = A.unlift
 
-asExp :: Exp a -> Exp a
+asExp :: A.Exp a -> A.Exp a
 asExp = id
 
 mapFst ::
    (A.Elt a, A.Elt b, A.Elt c) =>
-   (Exp a -> Exp b) -> Exp (a,c) -> Exp (b,c)
-mapFst f = modify (atom,atom) $ \(a,c) -> (f a, c)
+   (A.Exp a -> A.Exp b) -> A.Exp (a,c) -> A.Exp (b,c)
+mapFst f = modify (expr,expr) $ \(a,c) -> (f a, c)
 
 mapSnd ::
    (A.Elt a, A.Elt b, A.Elt c) =>
-   (Exp b -> Exp c) -> Exp (a,b) -> Exp (a,c)
-mapSnd f = modify (atom,atom) $ \(a,b) -> (a, f b)
+   (A.Exp b -> A.Exp c) -> A.Exp (a,b) -> A.Exp (a,c)
+mapSnd f = modify (expr,expr) $ \(a,b) -> (a, f b)
 
 
 fst3 ::
    (A.Elt a, A.Elt b, A.Elt c) =>
-   Exp (a,b,c) -> Exp a
-fst3 = modify (atom,atom,atom) Tuple.fst3
+   A.Exp (a,b,c) -> A.Exp a
+fst3 = modify (expr,expr,expr) Tuple.fst3
 
 snd3 ::
    (A.Elt a, A.Elt b, A.Elt c) =>
-   Exp (a,b,c) -> Exp b
-snd3 = modify (atom,atom,atom) Tuple.snd3
+   A.Exp (a,b,c) -> A.Exp b
+snd3 = modify (expr,expr,expr) Tuple.snd3
 
 thd3 ::
    (A.Elt a, A.Elt b, A.Elt c) =>
-   Exp (a,b,c) -> Exp c
-thd3 = modify (atom,atom,atom) Tuple.thd3
+   A.Exp (a,b,c) -> A.Exp c
+thd3 = modify (expr,expr,expr) Tuple.thd3
 
 
 
 indexCons ::
-   (A.Slice ix) => Exp ix -> Exp Int -> Exp (ix :. Int)
+   (A.Slice ix) => A.Exp ix -> A.Exp Int -> A.Exp (ix :. Int)
 indexCons ix n = A.lift $ ix:.n
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
@@ -58,6 +58,18 @@
 
 
 
+{- |
+If you have a function:
+
+> f :: Exp a -> (Acc b, Acc c) -> (Acc d, Acc e)
+
+you cannot run this immediately using 'Data.Array.Accelerate.Interpreter.run1',
+since @run1@ expects a function
+with a single 'Acc' parameter and a single 'Acc' result.
+Using the 'with' function you can just run @f@ as is:
+
+> with run1 f :: a -> (b,c) -> (d,e)
+-}
 {-
 (Acc ((a,b),c)) -> Acc d) -> (((a,b),c) -> d)
 (Acc (a,b) -> Acc c -> Acc d) -> ((a,b) -> c -> d)
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,7 +6,7 @@
 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 Data.Array.Accelerate.Utility.Lift.Exp (expr)
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
@@ -32,10 +32,10 @@
    Acc (Array (sh:.Int) a)
 tail xs =
    A.backpermute
-      (Exp.modify (atom:.atom)
+      (Exp.modify (expr:.expr)
           (\(sh :. n) -> sh :. n-1)
           (A.shape xs))
-      (Exp.modify (atom:.atom) $ \(ix:.k) -> ix :. k+1)
+      (Exp.modify (expr:.expr) $ \(ix:.k) -> ix :. k+1)
       xs
 
 cons ::
@@ -45,10 +45,10 @@
    Acc (Array (sh:.Int) a)
 cons x xs =
    A.generate
-      (Exp.modify (atom:.atom)
+      (Exp.modify (expr:.expr)
           (\(sh :. n) -> sh :. n+1)
           (A.shape xs))
-      (Exp.modify (atom:.atom) $
+      (Exp.modify (expr:.expr) $
        \(ix:.k) -> k ==* 0 ? (x ! ix, xs ! A.lift (ix :. k-1)))
 
 consExp ::
@@ -58,10 +58,10 @@
    Acc (Array (sh:.Int) a)
 consExp x xs =
    A.generate
-      (Exp.modify (atom:.atom)
+      (Exp.modify (expr:.expr)
           (\(z :. n) -> z :. n+1)
           (A.shape xs))
-      (Exp.modify (atom:.atom) $
+      (Exp.modify (expr:.expr) $
        \(ix:.k) -> k ==* 0 ? (x, xs ! A.lift (ix :. k-1)))
 
 
@@ -72,7 +72,7 @@
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int) a)
 append3 x y z =
-   let (sh :. n) = Exp.unlift (atom :. atom) $ A.shape x
+   let (sh :. n) = Exp.unlift (expr :. expr) $ A.shape x
    in  A.reshape (A.lift $ sh :. 3*n) $ stack3 x y z
 
 stack3 ::
@@ -83,10 +83,10 @@
    Acc (Array (sh:.Int:.Int) a)
 stack3 x y z =
    A.generate
-      (Exp.modify (atom :. atom)
+      (Exp.modify (expr :. expr)
          (\(sh :. n) -> sh :. (3::Int) :. n)
          (A.shape x))
-      (Exp.modify (atom :. atom :. atom) $
+      (Exp.modify (expr :. expr :. expr) $
        \(globalIx :. k :. j) ->
           let ix = A.lift $ globalIx :. j
           in  flip (A.caseof k) (x ! ix) $
@@ -102,13 +102,13 @@
    Acc (Array (sh:.Int) a)
 take n arr =
    A.backpermute
-      (Exp.modify (atom:.atom) (\(sh:._) -> sh:.n) $ A.shape arr)
+      (Exp.modify (expr:.expr) (\(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)
+      (Exp.modify (expr:.expr) (\(sh:.n) -> sh :. n - d) $ A.shape arr)
+      (Exp.modify (expr:.expr) $ \(ix:.k) -> ix :. k + d)
       arr
 
 pad ::
@@ -117,7 +117,7 @@
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int) a)
 pad x n arr =
-   let sh:.m = Exp.unlift (atom:.atom) $ A.shape arr
+   let sh:.m = Exp.unlift (expr:.expr) $ A.shape arr
    in  A.generate
           (A.lift $ sh:.n)
           (\ix -> A.indexHead ix <* m ? (arr!ix, x))
@@ -132,11 +132,11 @@
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int:.Int) a)
 sliceHorizontal nm arr =
-   let _z:.n:.m = Exp.unlift (atom:.atom:.atom) nm
+   let _z:.n:.m = Exp.unlift (expr:.expr:.expr) nm
        sh = A.indexTail $ A.shape arr
    in  A.backpermute
           (A.lift $ sh :. n :. m)
-          (Exp.modify (atom :. atom :. atom) $
+          (Exp.modify (expr :. expr :. expr) $
            \(ix :. k :. j) -> ix :. n*j+k)
           arr
 
@@ -147,9 +147,9 @@
    Acc (Array (sh:.Int) a) ->
    Acc (Array (sh:.Int) a)
 sieve m start arr =
-   let sh:.n = Exp.unlift (atom:.atom) $ A.shape arr
+   let sh:.n = Exp.unlift (expr:.expr) $ A.shape arr
    in  A.backpermute
           (A.lift $ sh :. div n m)
-          (Exp.modify (atom :. atom) $
+          (Exp.modify (expr :. expr) $
            \(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
--- a/src/Data/Array/Accelerate/Utility/Sliced1.hs
+++ b/src/Data/Array/Accelerate/Utility/Sliced1.hs
@@ -6,7 +6,7 @@
 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 Data.Array.Accelerate.Utility.Lift.Exp (expr)
 
 import qualified Data.Array.Accelerate as A
 import Data.Array.Accelerate
@@ -32,10 +32,10 @@
    Acc (Array (sh:.Int:.Int) a)
 tail xs =
    A.backpermute
-      (Exp.modify (atom:.atom:.atom)
+      (Exp.modify (expr:.expr:.expr)
           (\(sh :. n :. m) -> sh :. n-1 :. m)
           (A.shape xs))
-      (Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) -> ix :. k+1 :. j)
+      (Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) -> ix :. k+1 :. j)
       xs
 
 cons ::
@@ -45,10 +45,10 @@
    Acc (Array (sh:.Int:.Int) a)
 cons x xs =
    A.generate
-      (Exp.modify (atom:.atom:.atom)
+      (Exp.modify (expr:.expr:.expr)
           (\(sh :. n :. m) -> sh :. n+1 :. m)
           (A.shape xs))
-      (Exp.modify (atom:.atom:.atom) $
+      (Exp.modify (expr:.expr:.expr) $
        \(ix:.k:.j) ->
           k ==* 0 ? (x ! A.lift (ix:.j), xs ! A.lift (ix :. k-1 :. j)))
 
@@ -62,10 +62,10 @@
    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
+   let ( shx:.nx:.lenx) = Exp.unlift (expr:.expr:.expr) $ A.shape x
+       (_shy:.ny:.leny) = Exp.unlift (expr:.expr:.expr) $ A.shape y
    in  A.generate (A.lift $ shx :. nx+ny :. max lenx leny) $
-       Exp.modify (atom:.atom:.atom) $ \(ix:.k:.j) ->
+       Exp.modify (expr:.expr:.expr) $ \(ix:.k:.j) ->
           k<*nx ? (x ! A.lift (ix:.k:.j), y ! A.lift (ix:.k-nx:.j))
 
 append3 ::
@@ -75,7 +75,7 @@
    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
+   let (sh :. n :. m) = Exp.unlift (expr :. expr :. expr) $ A.shape x
    in  A.reshape (A.lift $ sh :. 3*n :. m) $ stack3 x y z
 
 stack3 ::
@@ -86,10 +86,10 @@
    Acc (Array (sh:.Int:.Int:.Int) a)
 stack3 x y z =
    A.generate
-      (Exp.modify (atom :. atom :. atom)
+      (Exp.modify (expr :. expr :. expr)
          (\(sh :. n :. m) -> sh :. (3::Int) :. n :. m)
          (A.shape x))
-      (Exp.modify (atom :. atom :. atom :. atom) $
+      (Exp.modify (expr :. expr :. expr :. expr) $
        \(globalIx :. k :. j :. i) ->
           let ix = A.lift $ globalIx :. j :. i
           in  flip (A.caseof k) (x ! ix) $
@@ -105,14 +105,14 @@
    Acc (Array (sh:.Int:.Int) a)
 take n arr =
    A.backpermute
-      (Exp.modify (atom:.atom:.atom) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)
+      (Exp.modify (expr:.expr:.expr) (\(sh:._:.m) -> sh:.n:.m) $ A.shape arr)
       id arr
 
 drop d arr =
    A.backpermute
-      (Exp.modify (atom:.atom:.atom)
+      (Exp.modify (expr:.expr:.expr)
          (\(sh:.n:.m) -> sh :. n - d :. m) $ A.shape arr)
-      (Exp.modify (atom:.atom:.atom) $
+      (Exp.modify (expr:.expr:.expr) $
        \(ix:.k:.j) -> ix :. k + d :. j)
       arr
 
@@ -123,9 +123,9 @@
    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
+   let sh:.n:.m = Exp.unlift (expr:.expr:.expr) $ A.shape arr
    in  A.backpermute
           (A.lift $ sh :. div n fac :. m)
-          (Exp.modify (atom :. atom :. atom) $
+          (Exp.modify (expr :. expr :. expr) $
            \(ix :. k :. j) -> ix :. fac*k+start :. j)
           arr