diff --git a/pointless-haskell.cabal b/pointless-haskell.cabal
--- a/pointless-haskell.cabal
+++ b/pointless-haskell.cabal
@@ -1,5 +1,5 @@
 Name:            pointless-haskell
-Version:         0.0.3
+Version:         0.0.4
 License:         BSD3
 License-file:    LICENSE
 Author:          Alcino Cunha <alcino@di.uminho.pt>, Hugo Pacheco <hpacheco@di.uminho.pt>
diff --git a/src/Generics/Pointless/Combinators.hs b/src/Generics/Pointless/Combinators.hs
--- a/src/Generics/Pointless/Combinators.hs
+++ b/src/Generics/Pointless/Combinators.hs
@@ -193,3 +193,10 @@
 coassocr :: Either (Either a b) c -> Either a (Either b c)
 coassocr = (id -|- inl) \/ (inr . inr)
 
+-- | The product distribution combinator
+distp :: ((c,d),(a,b)) -> ((c,a),(d,b))
+distp = fst >< fst /\ snd >< snd
+
+-- | The sum distribution combinator.
+dists :: (Either a b,Either c d) -> Either (Either (a,c) (a,d)) (Either (b,c) (b,d))
+dists = (distr -|- distr) . distl
diff --git a/src/Generics/Pointless/Examples/Examples.hs b/src/Generics/Pointless/Examples/Examples.hs
--- a/src/Generics/Pointless/Examples/Examples.hs
+++ b/src/Generics/Pointless/Examples/Examples.hs
@@ -366,20 +366,58 @@
    where f = nil \/ isumOp . swap . (id >< cons . (zero . bang /\ id))
          isumOp (l,x) = map (x+) l
 
--- | Incrementation the elements of a list by a specified value a catamorphism.
+-- | Incrementation the elements of a list by a specified value as a catamorphism.
 fisum :: [Int] -> Int -> [Int]
 fisum = cata (_L::[Int]) f
     where f = pnt (nil . bang) \/ comp . swap . (curry add >< (cons .) . split . (pnt id . bang /\ id))
 
+data NeLis a = Wrap a | NeCons a (NeLis a) deriving (Eq,Show)
+type instance PF (NeLis a) = Const a :+: Const a :*: Id
+instance Mu (NeLis a) where
+    inn (Left x) = Wrap x
+    inn (Right (x,xs)) = NeCons x xs
+    out (Wrap x) = Left x
+    out (NeCons x xs) = Right (x,xs)
+neCons = uncurry NeCons
+
+-- | Incrementation the elements of a list by a specified value as an accumulation.
+-- The result is always a non-empty list
+isumsAccum :: ([Int],Int) -> NeLis Int
+isumsAccum = accum _L h tau
+    where h = inn . (snd -|- swap . (snd >< id)) . distl
+          tau = (fst -|- aux) . distl
+          aux = assocr . (fst /\ addAccum . (fst >< id))
+
+isumsAna :: ([Int],Int) -> NeLis Int
+isumsAna = ana _L h
+    where h = (snd -|- (snd /\ aux)) . distl . (out >< id)
+          aux = (id >< addAccum) . assocr . (swap >< id)
+
 -- | Definition of list mapping as a catamorphism.
 mapCata :: [a] -> (a -> b) -> [b]
 mapCata = cata (_L::[a]) f
    where f = (([]!)!) \/ curry (cons . (app . swap >< app) . ((fst >< id) /\ (snd >< id)))
 
 -- | Definition of list reversion as a catamorphism.
-reverseAna :: [a] -> [a]
-reverseAna = cata (_L::[a]) f 
+reverseCata :: [a] -> [a]
+reverseCata = cata (_L::[a]) f 
     where f = nil \/ (cat . swap . (wrap >< id))
+
+-- | Linear version of reverse using accumulations
+reverseAccum l = reverseAccum' (l,[])
+
+reverseAccum' :: ([a],[a]) -> [a]
+reverseAccum' = accum (_L ::[a]) h tau
+    where h = (snd \/ snd . fst) . distl
+          tau = (fst -|- aux) . distl
+          aux = assocr . (id >< cons) . distp . ((id /\ id) >< id) . assocr
+
+reverseHylo :: ([a],[a]) -> [a]
+reverseHylo = hylo t g h
+    where g = id \/ id
+          h = (snd -|- aux) . distl . (out >< id)
+          aux = (id >< inn . inr) . assocr . (swap >< id)
+          t = _L :: K [a] :+!: I
 
 -- | Definition of the quicksort algorithm as an hylomorphism.
 qsort :: (Ord a) => [a] -> [a]