diff --git a/arrow-list.cabal b/arrow-list.cabal
--- a/arrow-list.cabal
+++ b/arrow-list.cabal
@@ -1,29 +1,35 @@
 Name:             arrow-list
-Version:          0.6
+Version:          0.6.1
 Synopsis:         List arrows for Haskell.
-Description:      This small Haskell library provides some type class, types
-                  and functions to work with list (and list-like) arrows. List
-                  arrows represent computations that may return multiple
-                  outputs. Making functions that return lists an instance of
-                  both the `Category` and `Arrow` type class allow you to
-                  easily compose multiple computations into one with standard
-                  building blocks.
+Description:
+  This small Haskell library provides some type class, types and functions to
+  work with list (and list-like) arrows. List arrows represent computations
+  that may return multiple outputs. Making functions that return lists an
+  instance of both the `Category` and `Arrow` type class allow you to easily
+  compose multiple computations into one with standard building blocks.
 
 Category:         Control
 License:          BSD3
 License-file:     LICENSE
-Author:           Sebastiaan Visser
-Maintainer:       haskell@fvisser.nl
 Build-Type:       Simple
 Cabal-Version:    >= 1.6
 
+Author:        Sebastiaan Visser
+Maintainer:    Sebastiaan Visser <code@fvisser.nl>
+Homepage:      https://github.com/sebastiaanvisser/arrow-list
+Bug-Reports:   http://github.com/sebastiaanvisser/arrow-list/issues
+
+Source-Repository head
+  Type:     git
+  Location: git://github.com/sebastiaanvisser/arrow-list.git
+
 Library
   GHC-Options:      -Wall
   HS-Source-Dirs:   src
 
-  Build-Depends:    base ==4.*
-                  , mtl >= 1.1 && < 2.1
-                  , containers >=0.3 && < 0.5
+  Build-Depends:    base       == 4.*
+                  , mtl        >= 1.1 && < 2.2
+                  , containers >= 0.3 && < 0.6
 
   Exposed-modules:  Control.Arrow.ArrowF
                     Control.Arrow.ArrowKleisli
diff --git a/src/Control/Arrow/ArrowF.hs b/src/Control/Arrow/ArrowF.hs
--- a/src/Control/Arrow/ArrowF.hs
+++ b/src/Control/Arrow/ArrowF.hs
@@ -50,62 +50,62 @@
 -- assume the container type has an 'Applicative', an 'Alternative' and a
 -- 'Foldable' instance.
 
-class Arrow (~>) => ArrowF f (~>) | (~>) -> f where
-  embed   :: f a ~> a              -- ^ Use a container as the input for an arrow.
-  observe :: (a ~> b) -> a ~> f b  -- ^ Get the result as container.
+class Arrow ar => ArrowF f ar | ar -> f where
+  embed   :: f a `ar` a                -- ^ Use a container as the input for an arrow.
+  observe :: (a `ar` b) -> a `ar` f b  -- ^ Get the result as container.
 
 -- | Embed a monadic function returning an ordered list into a container arrow.
 
-arrMF :: (ArrowF f (~>), ArrowKleisli m (~>)) => (a -> m (f c)) -> a ~> c
+arrMF :: (ArrowF f ar, ArrowKleisli m ar) => (a -> m (f c)) -> a `ar` c
 arrMF x = embed . arrM x
 
 -- | Map a function over the result collection of a container arrow.
 
-mapF :: ArrowF f (~>) => (f b -> f c) -> a ~> b -> a ~> c
+mapF :: ArrowF f ar => (f b -> f c) -> a `ar` b -> a `ar` c
 mapF f a = embed . arr f . observe a
 
 -- | Take the output of an arrow producing two results and concatenate them
 -- into the result of the container arrow.
 
-unite :: ArrowPlus (~>) => (b, b) ~> b
+unite :: ArrowPlus ar => (b, b) `ar` b
 unite = arr fst <+> arr snd
 
 -- | Skip the input and produce a constant output.
 
-const :: Arrow (~>) => b -> a ~> b
+const :: Arrow ar => b -> a `ar` b
 const = arr . Prelude.const
 
 -- | Collect the results of applying multiple arrows to the same input.
 
-concatA :: ArrowPlus (~>) => [a ~> b] -> a ~> b
+concatA :: ArrowPlus ar => [a `ar` b] -> a `ar` b
 concatA = foldr (<+>) zeroArrow
 
 -- | Join the results of two arrows, like (<+>) from ArrowPlus.
 
-plus :: (Alternative f, ArrowF f (~>)) => (a ~> b) -> (a ~> b) -> a ~> b
+plus :: (Alternative f, ArrowF f ar) => (a `ar` b) -> (a `ar` b) -> a `ar` b
 plus a b = embed . arr (\(x, y) -> x <|> y) . (observe a &&& observe b)
 
 -- | Skip the input and produce a constant output specified as a container.
 
-constF :: ArrowF f (~>) => f c -> a ~> c
+constF :: ArrowF f ar => f c -> a `ar` c
 constF f = embed . const f
 
 -- | Ignore the input and produce no results. Like `zeroArrow'.
 
-none :: (Alternative f, ArrowF f (~>)) => a ~> b
+none :: (Alternative f, ArrowF f ar) => a `ar` b
 none = constF empty
 
 -- | Returns a `Bool' indicating whether the input arrow produces a container
 -- with any results.
 
-results :: (Foldable f, ArrowF f (~>)) => (a ~> b) -> (a ~> Bool)
+results :: (Foldable f, ArrowF f ar) => (a `ar` b) -> (a `ar` Bool)
 results a = arr (not . null . toList) . observe a
 
 -- | Create a filtering container arrow by mapping a predicate function over the
 -- input. When the predicate returns `True' the input will be returned in the
 -- output container, when `False' the empty container is returned.
 
-isA :: (Alternative f, ArrowF f (~>)) => (a -> Bool) -> a ~> a
+isA :: (Alternative f, ArrowF f ar) => (a -> Bool) -> a `ar` a
 isA f = embed . arr (\a -> if f a then pure a else empty)
 
 -- | Use the result of a container arrow as a conditional, like an if-then-else
@@ -113,7 +113,7 @@
 -- used, when the first arrow produces no results the /else/ arrow will be
 -- used.
 
-ifA :: (Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> b) -> (a ~> t) -> (a ~> t) -> a ~> t
+ifA :: (Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` b) -> (a `ar` t) -> (a `ar` t) -> a `ar` t
 ifA c t e = proc i -> do x <- results c -< i; if x then t -< i else e -< i
 
 -- | Apply a container arrow only when a conditional arrow produces any
@@ -123,7 +123,7 @@
 
 infix 7 `when`
 
-when :: (Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> a) -> (a ~> c) -> a ~> a
+when :: (Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` a) -> (a `ar` c) -> a `ar` a
 when a c = ifA c a id
 
 -- | Apply a container arrow only when a conditional arrow produces any
@@ -133,19 +133,19 @@
 
 infix 8 `guards`
 
-guards :: (Alternative f, Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> c) -> (a ~> b) -> (a ~> b)
+guards :: (Alternative f, Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` c) -> (a `ar` b) -> (a `ar` b)
 guards c a = ifA c a none
 
 -- | Filter the results of an arrow with a predicate arrow, when the filter
 -- condition produces results the input is accepted otherwise it is excluded.
 
-filterA :: (Alternative f, Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> c) -> a ~> a
+filterA :: (Alternative f, Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` c) -> a `ar` a
 filterA c = ifA c id none
 
 -- | Negation container arrow. Only accept the input when the condition
 -- produces no output.
 
-notA :: (Alternative f, Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> c) -> a ~> a
+notA :: (Alternative f, Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` c) -> a `ar` a
 notA c = ifA c none id
 
 -- | Apply the input arrow, when the arrow does not produces any results the
@@ -154,20 +154,20 @@
 
 infix 6 `orElse`
 
-orElse :: (Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> b) -> (a ~> b) -> a ~> b
+orElse :: (Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` b) -> (a `ar` b) -> a `ar` b
 orElse a = ifA a a 
 
 -- | Map a `Maybe' input to a container output. When the Maybe is a `Nothing'
 -- an empty container will be returned, `Just' will result in a singleton
 -- container.
 
-maybeA :: (Alternative f, ArrowF f (~>)) => Maybe a ~> a
+maybeA :: (Alternative f, ArrowF f ar) => Maybe a `ar` a
 maybeA = embed . arr (maybe empty pure)
 
 -- | Apply a container arrow, when there are no results a `Nothing' will be
 -- returned, otherwise the results will be wrapped in a `Just'. This function
 -- always produces result.
 
-optional :: (Foldable f, ArrowF f (~>), ArrowChoice (~>)) => (a ~> b) -> a ~> Maybe b
+optional :: (Foldable f, ArrowF f ar, ArrowChoice ar) => (a `ar` b) -> a `ar` Maybe b
 optional a = ifA a (arr Just . a) (arr (const Nothing))
 
diff --git a/src/Control/Arrow/ArrowKleisli.hs b/src/Control/Arrow/ArrowKleisli.hs
--- a/src/Control/Arrow/ArrowKleisli.hs
+++ b/src/Control/Arrow/ArrowKleisli.hs
@@ -15,18 +15,18 @@
 import Control.Monad.Trans
 import Prelude hiding ((.), id)
 
-class (Monad m, Arrow (~>)) => ArrowKleisli m (~>) | (~>) -> m where
-  arrM :: (a -> m b) -> a ~> b
+class (Monad m, Arrow ar) => ArrowKleisli m ar | ar -> m where
+  arrM :: (a -> m b) -> a `ar` b
 
 instance Monad m => ArrowKleisli m (Kleisli m) where
   arrM f = Kleisli f
 
-constM :: ArrowKleisli m (~>) => m b -> a ~> b
+constM :: ArrowKleisli m ar => m b -> a `ar` b
 constM a = arrM (const a)
 
-effect :: ArrowKleisli m (~>) => m () -> a ~> a
+effect :: ArrowKleisli m ar => m () -> a `ar` a
 effect a = arrM (\b -> a >> return b)
 
-arrIO :: (MonadIO m, ArrowKleisli m (~>)) => (a -> IO b) -> a ~> b
+arrIO :: (MonadIO m, ArrowKleisli m ar) => (a -> IO b) -> a `ar` b
 arrIO f = arrM (liftIO . f)
 
diff --git a/src/Control/Arrow/ArrowList.hs b/src/Control/Arrow/ArrowList.hs
--- a/src/Control/Arrow/ArrowList.hs
+++ b/src/Control/Arrow/ArrowList.hs
@@ -45,58 +45,58 @@
 -- 
 --   2. Mapping a function over the result list of a list arrow.
 
-class Arrow (~>) => ArrowList (~>) where
-  arrL :: (a -> [b]) -> a ~> b
-  mapL :: ([b] -> [c]) -> (a ~> b) -> (a ~> c)
+class Arrow ar => ArrowList ar where
+  arrL :: (a -> [b]) -> a `ar` b
+  mapL :: ([b] -> [c]) -> (a `ar` b) -> (a `ar` c)
 
 -- | Create a list arrow of an input list.
 
-unlist :: ArrowList (~>) => [b] ~> b
+unlist :: ArrowList ar => [b] `ar` b
 unlist = arrL id
 
 -- | Take the output of an arrow producing two results and concatenate them
 -- into the result of the list arrow.
 
-unite :: ArrowList (~>) => (a ~> (b, b)) -> a ~> b
+unite :: ArrowList ar => (a `ar` (b, b)) -> a `ar` b
 unite = mapL (concatMap (\(a, b) -> [a, b]))
 
 -- | Ignore the input and produce no results. Like `zeroArrow'.
 
-none :: ArrowList (~>) => a ~> b
+none :: ArrowList ar => a `ar` b
 none = arrL (const [])
 
 -- | Collect the results of applying multiple arrows to the same input.
 
-concatA :: ArrowPlus (~>) => [a ~> b] -> a ~> b
+concatA :: ArrowPlus ar => [a `ar` b] -> a `ar` b
 concatA = foldr (<+>) zeroArrow
 
 -- | Collect the entire results of an list arrow as a singleton value in the
 -- result list.
 
-list :: ArrowList (~>) => (a ~> b) -> a ~> [b]
+list :: ArrowList ar => (a `ar` b) -> a `ar` [b]
 list = mapL return
 
 -- | Returns a `Bool' indicating whether the input arrow produce any results.
 
-empty :: ArrowList (~>) => (a ~> b) -> a ~> Bool
+empty :: ArrowList ar => (a `ar` b) -> a `ar` Bool
 empty = mapL (\xs -> [if null xs then True else False])
 
 -- | Create a filtering list arrow by mapping a predicate function over the
 -- input. When the predicate returns `True' the input will be returned in the
 -- output list, when `False' the empty list is returned.
 
-isA :: ArrowList (~>) => (a -> Bool) -> a ~> a
+isA :: ArrowList ar => (a -> Bool) -> a `ar` a
 isA f = arrL (\a -> if f a then [a] else [])
 
 -- | Use the result a list arrow as a conditional, like an if-then-else arrow.
 -- When the first arrow produces any results the /then/ arrow will be used,
 -- when the first arrow produces no results the /else/ arrow will be used.
 
-ifA :: (ArrowList (~>), ArrowChoice (~>))
-    => (a ~> c)  -- ^ Arrow used as condition.
-    -> (a ~> b)  -- ^ Arrow to use when condition has results.
-    -> (a ~> b)  -- ^ Arrow to use when condition has no results.
-    -> a ~> b
+ifA :: (ArrowList ar, ArrowChoice ar)
+    => (a `ar` c)  -- ^ Arrow used as condition.
+    -> (a `ar` b)  -- ^ Arrow to use when condition has results.
+    -> (a `ar` b)  -- ^ Arrow to use when condition has no results.
+    -> a `ar` b
 ifA c t e = proc i -> do x <- empty c -< i; if x then e -< i else t -< i
 
 -- | Apply a list arrow only when a conditional arrow produces any results.
@@ -106,10 +106,10 @@
 
 infix 8 `when`
 
-when :: (ArrowList (~>), ArrowChoice (~>))
-     => (a ~> a)  -- ^ The arrow to apply,
-     -> (a ~> b)  -- ^ when this conditional holds.
-     -> a ~> a
+when :: (ArrowList ar, ArrowChoice ar)
+     => (a `ar` a)  -- ^ The arrow to apply,
+     -> (a `ar` b)  -- ^ when this conditional holds.
+     -> a `ar` a
 when a c = ifA c a id
 
 -- | Apply a list arrow only when a conditional arrow produces any results.
@@ -119,22 +119,22 @@
 
 infix 8 `guards`
 
-guards :: (ArrowList (~>), ArrowChoice (~>))
-       => (a ~> c)  -- ^ When this condition holds,
-       -> (a ~> b)  -- ^ then apply this arrow.
-       -> a ~> b
+guards :: (ArrowList ar, ArrowChoice ar)
+       => (a `ar` c)  -- ^ When this condition holds,
+       -> (a `ar` b)  -- ^ then apply this arrow.
+       -> a `ar` b
 guards c a = ifA c a none
 
 -- | Filter the results of an arrow with a predicate arrow, when the filter
 -- condition produces results the input is accepted otherwise it is excluded.
 
-filterA :: (ArrowChoice (~>), ArrowList (~>)) => (a ~> c) -> a ~> a
+filterA :: (ArrowChoice ar, ArrowList ar) => (a `ar` c) -> a `ar` a
 filterA c = ifA c id none
 
 -- | Negation list arrow. Only accept the input when the condition produces no
 -- output.
 
-notA :: (ArrowList (~>), ArrowChoice (~>)) => (a ~> c) -> a ~> a
+notA :: (ArrowList ar, ArrowChoice ar) => (a `ar` c) -> a `ar` a
 notA c = ifA c none id
 
 -- | Apply the input arrow, when the arrow does not produces any results the
@@ -143,19 +143,19 @@
 
 infix 8 `orElse`
 
-orElse :: (ArrowList (~>), ArrowChoice (~>)) => (a ~> b) -> (a ~> b) -> a ~> b
+orElse :: (ArrowList ar, ArrowChoice ar) => (a `ar` b) -> (a `ar` b) -> a `ar` b
 orElse a = ifA a a 
 
 -- | Map a `Maybe' input to a list output. When the Maybe is a `Nothing' an
 -- empty list will be returned, `Just' will result in a singleton list.
 
-maybeL :: ArrowList (~>) => Maybe a ~> a
+maybeL :: ArrowList ar => Maybe a `ar` a
 maybeL = arrL (maybe [] return)
 
 -- | Apply a list arrow, when there are no results a `Nothing' will be
 -- returned, otherwise the results will be wrapped in a `Just'. This function
 -- always produces result.
 
-optional :: (ArrowChoice (~>), ArrowList (~>)) => (a ~> b) -> a ~> Maybe b
+optional :: (ArrowChoice ar, ArrowList ar) => (a `ar` b) -> a `ar` Maybe b
 optional a = ifA a (arr Just . a) (arr (const Nothing))
 
diff --git a/src/Control/Arrow/List.hs b/src/Control/Arrow/List.hs
--- a/src/Control/Arrow/List.hs
+++ b/src/Control/Arrow/List.hs
@@ -52,6 +52,6 @@
 
 -- * Embed a monadic function returning lists.
 
-arrML :: (ArrowList (~>), ArrowKleisli m (~>)) => (a -> m [b]) -> a ~> b
+arrML :: (ArrowList ar, ArrowKleisli m ar) => (a -> m [b]) -> a `ar` b
 arrML x = unlist . arrM x
 
diff --git a/src/Control/Monad/Sequence.hs b/src/Control/Monad/Sequence.hs
--- a/src/Control/Monad/Sequence.hs
+++ b/src/Control/Monad/Sequence.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# OPTIONS -fno-warn-orphans #-}
 module Control.Monad.Sequence
 (
@@ -15,6 +16,8 @@
 import Data.Traversable
 import Prelude hiding (mapM)
 
+#if MIN_VERSION_containers(0,5,2)
+#else
 instance Applicative Seq where
   pure  = return
   (<*>) = ap
@@ -22,6 +25,7 @@
 instance Alternative Seq where
   empty = mzero
   (<|>) = mplus
+#endif
 
 -- | Parameterizable `Sequence' monad, with an inner monad. The semantics of
 -- `SeqT' are comparable to that of `ListT`.