diff --git a/event-list.cabal b/event-list.cabal
--- a/event-list.cabal
+++ b/event-list.cabal
@@ -1,5 +1,5 @@
 Name:             event-list
-Version:          0.1.1.1
+Version:          0.1.1.2
 License:          GPL
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -26,7 +26,7 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/~thielema/event-list/
-  tag:      0.1.1.1
+  tag:      0.1.1.2
 
 Flag splitBase
   description: Choose the new smaller, split-up base package.
diff --git a/src/Data/AlternatingList/List/Disparate.hs b/src/Data/AlternatingList/List/Disparate.hs
--- a/src/Data/AlternatingList/List/Disparate.hs
+++ b/src/Data/AlternatingList/List/Disparate.hs
@@ -41,10 +41,14 @@
 
 import Test.QuickCheck (Arbitrary(arbitrary, shrink))
 
-import Prelude hiding
-   (null, foldr, foldl, map, concat, cycle, length,
-    take, drop, splitAt, reverse,
-    sequence, sequence_, )
+import Text.Show (Show, ShowS, showsPrec, showParen, showString, )
+import Data.Function (id, flip, (.), ($), )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
+import Data.List (zipWith, (++), )
+import Data.Tuple (curry, uncurry, )
+import Data.Ord (Ord, (>=), )
+import Prelude (Integral, Int, String, Bool, Eq, )
 
 
 data Pair a b =
diff --git a/src/Data/AlternatingList/List/Uniform.hs b/src/Data/AlternatingList/List/Uniform.hs
--- a/src/Data/AlternatingList/List/Uniform.hs
+++ b/src/Data/AlternatingList/List/Uniform.hs
@@ -42,18 +42,17 @@
 
 import Test.QuickCheck (Arbitrary(arbitrary, shrink))
 
+import Text.Show (Show, ShowS, showsPrec, showParen, showString, )
+import Data.Function (id, flip, (.), ($), )
 import Data.Tuple.HT (mapFst, mapSnd, mapPair, )
 import Data.Maybe.HT (toMaybe, )
-{- this way we cannot access (:) in Hugs
-import Data.Maybe (Maybe, maybe)
-import Text.Show (Show, ShowS, showsPrec, showParen, showString)
-import Prelude
-   (Bool, Int, (.), ($), id, undefined, flip, error,
-    pred, fst, snd,
-    Eq, Ord, Show, (>))
--}
-import Prelude hiding
-   (null, foldr, foldl, map, concat, length, reverse, sequence, sequence_, )
+import Data.Functor (fmap, )
+import Data.Either (Either(Left, Right), either, )
+import Data.Maybe (Maybe, maybe, )
+import Data.Tuple (uncurry, )
+import Data.Ord (Ord, (>=), )
+{- this way we cannot access (:) in Hugs -}
+import Prelude (Integral, Int, String, Bool, error, Eq, )
 
 
 {- |
diff --git a/src/Data/EventList/Absolute/TimeBody.hs b/src/Data/EventList/Absolute/TimeBody.hs
--- a/src/Data/EventList/Absolute/TimeBody.hs
+++ b/src/Data/EventList/Absolute/TimeBody.hs
@@ -51,8 +51,17 @@
 import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )
 
 import Control.Monad.Trans.State (state, evalState)
+import Control.Monad (Monad, (>>), )
 
-import Prelude hiding (mapM, mapM_, null, foldr, filter, concat, cycle)
+import Data.Function (id, flip, (.), ($), )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
+import Data.Tuple (uncurry, fst, snd, )
+import Data.Ord (Ord, compare, (<), (>=), )
+import Data.Eq (Eq, (==), (/=), )
+import Prelude
+   (Num, Integral, RealFrac, round, subtract, (*), (-),
+    Bool, error, )
 
 
 empty :: T time body
@@ -293,7 +302,7 @@
 isNormalized :: (Ord time, Num time, Ord body) =>
    T time body -> Bool
 isNormalized =
-   all isAscending . getBodies . collectCoincident
+   List.all isAscending . getBodies . collectCoincident
 
 
 {- |
diff --git a/src/Data/EventList/Absolute/TimeTime.hs b/src/Data/EventList/Absolute/TimeTime.hs
--- a/src/Data/EventList/Absolute/TimeTime.hs
+++ b/src/Data/EventList/Absolute/TimeTime.hs
@@ -47,12 +47,19 @@
 import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )
 
 import Control.Monad.Trans.State (state, evalState)
+import Control.Monad (Monad, (>>), )
 
 import Data.Monoid (Monoid, )
-import Data.Maybe (fromMaybe)
 
-import Prelude hiding
-   (null, foldr, map, filter, concat, cycle, sequence, sequence_, mapM, mapM_)
+import Data.Function (flip, (.), ($), )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe(Just), fromMaybe, )
+import Data.Tuple (uncurry, fst, snd, )
+import Data.Ord (Ord, max, (<), (>=), )
+import Data.Eq (Eq, (/=), )
+import Prelude
+   (Num, Integral, RealFrac, round, subtract, (*), (+), (-),
+    Bool, error, )
 
 
 
@@ -234,7 +241,7 @@
 isNormalized :: (Ord time, Num time, Ord body) =>
    T time body -> Bool
 isNormalized =
-   all isAscending . getBodies . collectCoincident
+   List.all isAscending . getBodies . collectCoincident
 
 
 
@@ -292,14 +299,14 @@
 concat :: (Ord time, Num time) =>
    [T time body] -> T time body
 concat xs =
-   let ts0 = scanl (+) 0 (List.map duration xs)
+   let ts0 = List.scanl (+) 0 (List.map duration xs)
        (ts,dur) =
           fromMaybe
              (error "list of accumulated times is always non-empty")
              (ListHT.viewR ts0)
    in  snocTime
           (TimeBodyPriv.Cons $ Disp.concat $ List.map TimeBodyPriv.decons $
-           zipWith TimeBodyList.delay ts (List.map (fst . viewTimeR) xs))
+           List.zipWith TimeBodyList.delay ts (List.map (fst . viewTimeR) xs))
           dur
 
 cycle :: (Ord time, Num time) =>
diff --git a/src/Data/EventList/Relative/BodyBody.hs b/src/Data/EventList/Relative/BodyBody.hs
--- a/src/Data/EventList/Relative/BodyBody.hs
+++ b/src/Data/EventList/Relative/BodyBody.hs
@@ -19,10 +19,12 @@
 -- import qualified Data.AlternatingList.List.Disparate as Disp
 import qualified Data.AlternatingList.List.Uniform as Uniform
 
+import Control.Monad (Monad, )
 import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), liftA, )
 import Data.Monoid (Monoid, )
 
-import Prelude hiding (mapM)
+import Data.Function ((.), )
+import Prelude ()
 
 
 concatMapMonoid :: Monoid m =>
diff --git a/src/Data/EventList/Relative/BodyTime.hs b/src/Data/EventList/Relative/BodyTime.hs
--- a/src/Data/EventList/Relative/BodyTime.hs
+++ b/src/Data/EventList/Relative/BodyTime.hs
@@ -28,14 +28,17 @@
 import qualified Data.AlternatingList.List.Disparate as Disp
 -- import qualified Data.AlternatingList.List.Uniform as Uniform
 
+import Control.Monad (Monad, )
 import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )
 import Data.Monoid (Monoid, mempty, )
 
 import Data.Tuple.HT (mapFst, mapSnd, mapPair, )
 import qualified Data.List as List
 
-import Prelude hiding
-   (mapM, mapM_, foldr, span, null, )
+import Data.Function ((.), ($), )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe, )
+import Prelude (Num, (+), Bool, )
 
 
 fromPairList :: [(body, time)] -> T time body
@@ -51,7 +54,7 @@
 getTimes = Disp.getSeconds . decons
 
 duration :: Num time => T time body -> time
-duration = sum . getTimes
+duration = List.sum . getTimes
 
 durationR :: Num time => T time body -> time
 durationR = List.foldr (+) 0 . getTimes
diff --git a/src/Data/EventList/Relative/TimeBody.hs b/src/Data/EventList/Relative/TimeBody.hs
--- a/src/Data/EventList/Relative/TimeBody.hs
+++ b/src/Data/EventList/Relative/TimeBody.hs
@@ -64,9 +64,16 @@
 import Data.Maybe.HT (toMaybe, )
 import Data.List.HT (isAscending, )
 import Control.Monad.Trans.State (evalState, modify, get, put, )
+import Control.Monad (Monad, return, (>>), )
 
-import Prelude hiding
-          (mapM, mapM_, unzip, null, foldr, filter, concat, cycle, span, )
+import Data.Function (flip, const, (.), ($), )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
+import Data.Bool (Bool, not, (||), (&&), )
+import Data.Tuple (uncurry, fst, snd, )
+import Data.Ord (Ord, (<), )
+import Data.Eq (Eq, (/=), )
+import Prelude (Num, Integral, RealFrac, (*), (+), (-), error, )
 
 
 
@@ -357,7 +364,7 @@
 isNormalized :: (NonNeg.C time, Ord body) =>
    T time body -> Bool
 isNormalized =
-   all isAscending . getBodies . collectCoincident
+   List.all isAscending . getBodies . collectCoincident
 
 
 
@@ -482,7 +489,7 @@
 append xs = lift (Disp.append $~* xs)
 
 concat :: [T time body] -> T time body
-concat = Cons . Disp.concat . map decons
+concat = Cons . Disp.concat . List.map decons
 
 cycle :: T time body -> T time body
 cycle = lift Disp.cycle
diff --git a/src/Data/EventList/Relative/TimeTime.hs b/src/Data/EventList/Relative/TimeTime.hs
--- a/src/Data/EventList/Relative/TimeTime.hs
+++ b/src/Data/EventList/Relative/TimeTime.hs
@@ -58,12 +58,17 @@
 import Data.EventList.Utility (floorDiff, )
 import Control.Monad.Trans.State (evalState, modify, get, gets, put, )
 
-import Control.Monad (liftM2, )
+import Control.Monad (Monad, return, liftM2, (>>), )
 import Control.Applicative (Applicative, WrappedMonad(WrapMonad, unwrapMonad), )
 
-import Prelude hiding
-   (null, foldr, foldl, map, filter, concat, cycle, reverse,
-    sequence, sequence_, mapM, mapM_, unzip, )
+import Data.Function ((.), ($), id, flip, )
+import Data.Functor (fmap, )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
+import Data.Tuple (fst, snd, )
+import Data.Ord (Ord, (<), )
+import Data.Eq (Eq, (==), )
+import Data.Bool (Bool(False, True), not, (&&), )
+import Prelude (Num, Integral, RealFrac, (*), (+), (-), seq, )
 
 
 
@@ -202,7 +207,7 @@
 isNormalized :: (NonNeg.C time, Ord body) =>
    T time body -> Bool
 isNormalized =
-   all isAscending . getBodies . collectCoincident
+   List.all isAscending . getBodies . collectCoincident
 
 
 {- |