diff --git a/Control/Replicate.hs b/Control/Replicate.hs
--- a/Control/Replicate.hs
+++ b/Control/Replicate.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE GADTs, Rank2Types #-}
 -- | Composable replication schemes of applicative actions.
 --
 -- This module separates common combinators such as @some@ and @many@ (from
@@ -89,19 +90,34 @@
 import Data.Monoid
 import Control.Applicative hiding (many, some)
 import Control.Category
+import Control.Arrow
 
+
 -- | A set of frequencies which with an applicative action is allowed to
 -- occur. @a@ is the result type of a single atomic action. @b@ is the
 -- composite result type after executing the action a number of times allowed
 -- by this set.
-data Replicate a b
-  = Nil
-  | Cons (Maybe b) (Replicate a (a -> b))
+data Replicate a b where
+  Nil :: Replicate a b
+  Cons :: (c -> b) -> Maybe c -> Replicate a (a -> c) -> Replicate a b
 
+-- Fold the Replicate list given:
+-- * an "empty" value
+-- * a function to combine the Cons value into the result
+-- * a function to convert the value of the recursive call to the expected type
+foldReplicate :: (forall c. f c) 
+              -> (forall c. c -> f c -> f c) 
+              -> (forall c. f (a -> c) -> f c) 
+              -> Replicate a b -> f b
+foldReplicate e _ _ Nil = e
+foldReplicate e f g (Cons fx mx xs) = 
+  maybe id (f . fx) mx . g . foldReplicate e f g . fmap (fx .) $ xs
+
+
 -- | Map over the composite result type.
 instance Functor (Replicate a) where
   fmap _ Nil = Nil
-  fmap f (Cons mx xs) = Cons (f <$> mx) (fmap (f .) xs)
+  fmap f (Cons fx mx xs) = Cons (f . fx) mx xs
 
 -- | Pairwise addition.
 -- 
@@ -124,10 +140,10 @@
   -- lowerBound (f1 <*> f2) = lowerBound f1 + lowerBound f2
   -- upperBound (f1 <*> f2) = upperBound f1 + upperBound f2
   Nil <*> _ = Nil
-  Cons mx xs <*> ys =  -- 0 + n = n
-                       maybe empty (<$> ys) mx
+  Cons fx mx xs <*> ys =  -- 0 + n = n
+                       maybe empty ((<$> ys) . fx) mx
                    <|> -- (1 + m) + n = 1 + (m + n)
-                       Cons Nothing (flip <$> xs <*> ys)
+                       Cons id Nothing ((\x y z -> fx (x z) y) <$> xs <*> ys)
 
 -- | 'empty' is the empty set {} of allowed occurrences. Not even performing
 -- an action zero times is allowed in that case.
@@ -140,9 +156,9 @@
   
   Nil <|> ys = ys
   xs <|> Nil = xs
-  Cons mx xs <|> Cons my ys =
+  Cons fx mx xs <|> Cons fy my ys =
     -- <|> on Maybes discards the right operand if the left is a Just.
-    Cons (mx <|> my) (xs <|> ys)
+    Cons id (fx <$> mx <|> fy <$> my) (fmap fx <$> xs <|> fmap fy <$> ys)
 
 -- | Behaves exactly as the 'Alternative' instance.
 instance Monoid (Replicate a b) where
@@ -157,47 +173,55 @@
 -- '.' produces the set of occurrences that are the products of all possible
 -- pairs from the two operands.
 instance Category Replicate where
-  id = one
-  Nil        . _   = Nil
-  Cons mx xs . ys  =  -- 0 * n = 0
-                      maybe empty zero mx
-                  <|> -- (m + 1) * n = m * n + n
-                      ys <**> (xs . ys)
+  id  = one
+  (.) = (*?)
 
+-- | As 'Replicate' is both 'Applicative' and 'Category', it is also an 'Arrow'.
+instance Arrow Replicate where
+  arr f    = f   <$> id
+  f &&& g  = (,) <$> f <*> g
+  f *** g  = f . arr fst &&& g . arr snd
+  first  f = f  *** id
+  second f = id *** f
 
+-- | Behaves exactly as the 'Alternative' instance.
+instance ArrowZero Replicate where
+  zeroArrow = empty
+-- | Behaves exactly as the 'Alternative' instance.
+instance ArrowPlus Replicate where
+  (<+>) = (<|>)
+
+
 -- | Run an action a certain number of times, using '<|>' to branch (at the
 -- deepest point possible) if multiple frequencies are allowed. Use greedy
 -- choices: always make the longer alternative the left operand of @\<|\>@.
 (*!) :: Alternative f => Replicate a b -> f a -> f b
-Nil        *! _ = empty
-Cons mx xs *! p = p <**> (xs *! p) <|> maybe empty pure mx
+r *! p = foldReplicate empty (\x xs -> xs <|> pure x) (p <**>) r
 
 -- | Run an action a certain number of times, using '<|>' to branch (at the
 -- deepest point possible) if multiple frequencies are allowed. Use lazy
 -- choices: always make the 'pure' alternative the left operand of @\<|\>@.
 (*?) :: Alternative f => Replicate a b -> f a -> f b
-Nil        *? _ = empty
-Cons mx xs *? p = maybe empty pure mx <|> p <**> (xs *? p)
+r *? p = foldReplicate empty (\x xs -> pure x <|> xs) (p <**>) r
 
+
 -- | Enumerate all the numbers of allowed occurrences encoded by the
 -- replication scheme.
-sizes :: Num num => Replicate a b -> [num]
-sizes = sizes' 0
-  where
-    -- Type signature is mandatory here.
-    sizes' :: Num num => num -> Replicate a b -> [num]
-    sizes' _ Nil = []
-    sizes' n (Cons mx xs) = maybe [] (const [n]) mx ++ sizes' (n + 1) xs
-
+sizes :: Replicate a b -> [Int]
+sizes = ($ 0) . getConst . sizesFold where
+  sizesFold = foldReplicate 
+    (                Const (\_ -> []))
+    (\_ (Const g) -> Const (\n -> n : g n))
+    (\  (Const g) -> Const (\n -> g (n + 1)))
 
 
 -- | Perform an action exactly zero times.
 zero :: b -> Replicate a b
-zero x = Cons (Just x) Nil
+zero x = Cons id (Just x) Nil
 
 -- | Perform an action exactly one time.
 one :: Replicate a a
-one = Cons Nothing (zero id)
+one = Cons id Nothing (zero id)
 
 -- | Perform an action exactly two times.
 two :: Replicate a (a, a)
@@ -239,4 +263,4 @@
 
 -- | Repeat an action forever.
 forever :: Replicate a b
-forever = Cons Nothing (const <$> forever)
+forever = Cons id Nothing (const <$> forever)
diff --git a/ReplicateEffects.cabal b/ReplicateEffects.cabal
--- a/ReplicateEffects.cabal
+++ b/ReplicateEffects.cabal
@@ -1,5 +1,5 @@
 Name:                ReplicateEffects
-Version:             0.2
+Version:             0.3
 Synopsis:            Composable replication schemes of applicative functors
 -- Description:         
 Category:            Control
@@ -13,10 +13,13 @@
 Bug-reports:         https://github.com/MedeaMelana/ReplicateEffects/issues
 -- Copyright:           
 
-
 Build-type:          Simple
-Cabal-version:       >= 1.2
+Cabal-version:       >= 1.6
 
 Library
   Exposed-modules:     Control.Replicate
-  Build-depends:       base >= 4.0 && < 4.4
+  Build-depends:       base >= 4.0 && < 5
+
+Source-Repository head
+  Type:              Git
+  Location:          https://github.com/MedeaMelana/ReplicateEffects