diff --git a/data-fresh.cabal b/data-fresh.cabal
--- a/data-fresh.cabal
+++ b/data-fresh.cabal
@@ -1,8 +1,19 @@
 name:               data-fresh
-version:            0.2013.250
+version:            0.2013.250.1
 stability:          experimental
 category:           Control
-synopsis:           An interface for generating fresh values
+synopsis:           Interface and functor transformers for fresh values
+description:
+    A simple library, mostly containing of an interface to generate fresh values.
+    .
+    This package also includes two functor transformers which implement this
+    interface. They consume fresh values from user-supplied comonads.
+    Currently, two approaches are implemented:
+    .
+    * In @Stream@, the comonad provides a way to succeed a value.
+    .
+    * In @Delta@, the comonad provides a way to split the value or to succeeded
+    it. The benefit is that the underlying functor doesn't need to be a monad.
 license:            BSD3
 license-file:       LICENSE
 copyright:          Copyright (c) 2013 Stijn van Drongelen
@@ -17,7 +28,16 @@
 
 library
     default-language:   Haskell2010
-    other-extensions:   FlexibleInstances, MultiParamTypeClasses
-    exposed-modules:    Control.Monad.Trans.Fresh, Data.Fresh
-    build-depends:      base >= 4 && < 5, transformers >= 0.2 && < 1
+    other-extensions:
+        FlexibleInstances
+        MultiParamTypeClasses
+    exposed-modules:
+        Control.Monad.Trans.Fresh.Delta
+        Control.Monad.Trans.Fresh.Stream
+        Data.Fresh
+    build-depends:
+        base >= 4 && < 5,
+        free -any,
+        transformers >= 0.2 && < 1
     hs-source-dirs:     src
+    ghc-options:        -Wall
diff --git a/src/Control/Monad/Trans/Fresh.hs b/src/Control/Monad/Trans/Fresh.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/Fresh.hs
+++ /dev/null
@@ -1,49 +0,0 @@
-{-# LANGUAGE Haskell2010 #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-module Control.Monad.Trans.Fresh where
-
-import Control.Applicative
-import Control.Arrow (first)
-import Control.Monad.Trans.Class
-import Data.Fresh
-import Data.Functor.Identity
-
-newtype FreshT v m a = FreshT { runFreshT :: (v -> (v, v)) -> v -> m (a, v) }
-
-instance Functor m => Functor (FreshT v m) where
-    fmap f (FreshT xx) = FreshT $ \sp s -> fmap (first f) (xx sp s)
-    x <$ FreshT xx = FreshT $ \sp s -> fmap (setFst x) (xx sp s)
-      where
-        setFst :: b -> (a, c) -> (b, c)
-        setFst x (_, y) = (x, y)
-
-instance (Functor m, Monad m) => Applicative (FreshT v m) where
-    pure = return
-    FreshT ff <*> FreshT xx = FreshT $ \sp s -> do
-        (fv, s1) <- ff sp s    
-        (xv, s2) <- xx sp s1
-        return (fv xv, s2)
-    --FreshT ll *> FreshT rr = FreshT $ undefined
-    --FreshT ll <* FreshT rr = FreshT $ undefined
-
-instance Monad m => Monad (FreshT v m) where
-    return x = FreshT $ \_ s -> return (x, s)
-    FreshT aa >>= f = FreshT $ \sp s -> do
-        (a, s1) <- aa sp s
-        let FreshT ff = f a
-        ff sp s1
-    -- (>>) = (*>)
-
--- TODO Alternative, MonadPlus
--- TODO MonadFix
-
-instance MonadTrans (FreshT v) where
-    lift m = FreshT $ \_ s -> do
-                r <- m
-                return (r, s)
-
--- TODO MonadIO
-
-instance Applicative m => Fresh v (FreshT v m) where
-    fresh = FreshT $ \sp s -> pure (sp s)
diff --git a/src/Control/Monad/Trans/Fresh/Delta.hs b/src/Control/Monad/Trans/Fresh/Delta.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Trans/Fresh/Delta.hs
@@ -0,0 +1,61 @@
+{-# LANGUAGE Haskell2010 #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+module Control.Monad.Trans.Fresh.Delta where
+
+import Control.Applicative
+import Control.Arrow (first)
+import Control.Comonad.Cofree
+import Control.Monad.Trans.Class
+import Data.Fresh
+
+data Triplet a = Triplet a a a
+
+newtype FreshT v m a = FreshT
+    { runFreshT :: Cofree Triplet v -> m (a, Cofree Triplet v) }
+
+-- | Creates a @Cofree Triplet v@, based on a seed, and functions to split
+--   and succeed it.
+seedDelta
+    :: v                -- ^ Delta seed
+    -> (v -> v)         -- ^ Successor
+    -> (v -> (v, v))    -- ^ Splitter
+    -> Cofree Triplet v
+seedDelta seed sukk splt = go seed
+  where
+    go tt = tt `seq` (tt :< Triplet (go ll) (go mm) (go rr))
+      where
+        mm = sukk tt
+        (ll, rr) = splt tt
+
+-- | A delta of integers.
+integerDelta :: Integer -> Cofree Triplet Integer
+integerDelta n = seedDelta n succ (\m -> let m' = 2 * m in (m', m' + 1))
+
+instance Functor m => Functor (FreshT v m) where
+    fmap f (FreshT xx) = FreshT $ \s -> fmap (first f) (xx s)
+
+instance Applicative m => Applicative (FreshT v m) where
+    pure x = FreshT $ \s -> pure (x, s)
+    FreshT ff <*> FreshT xx = FreshT $ \(_ :< Triplet l _ r)
+        -> (\(f, sf) (x, _) -> (f x, sf)) <$> ff l <*> xx r
+
+instance Monad m => Monad (FreshT v m) where
+    return x = FreshT $ \s -> return (x, s)
+    FreshT aa >>= f = FreshT $ \s -> do
+        (a, s1) <- aa s
+        let FreshT ff = f a
+        ff s1
+
+-- TODO Alternative, MonadPlus
+-- TODO MonadFix
+
+instance MonadTrans (FreshT v) where
+    lift m = FreshT $ \s -> do
+                r <- m
+                return (r, s)
+
+-- TODO MonadIO
+
+instance Applicative m => Fresh v (FreshT v m) where
+    fresh = FreshT $ \(s :< Triplet _ s' _) -> pure (s, s')
diff --git a/src/Control/Monad/Trans/Fresh/Stream.hs b/src/Control/Monad/Trans/Fresh/Stream.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Trans/Fresh/Stream.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE Haskell2010 #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+module Control.Monad.Trans.Fresh.Stream where
+
+import Control.Applicative
+import Control.Arrow (first)
+import Control.Comonad.Cofree
+import Control.Monad.Trans.Class
+import Data.Fresh
+import Data.Functor.Identity
+
+newtype FreshT v m a = FreshT
+    { runFreshT :: Cofree Identity v -> m (a, Cofree Identity v) }
+
+-- | Creates a @Cofree Identity v@, based on a seed, and a function to split it.
+seedStream
+    :: v                -- ^ Stream seed
+    -> (v -> v)         -- ^ Successor
+    -> Cofree Identity v
+seedStream seed sukk = go seed
+  where
+    go tt = tt `seq` (mm :< Identity (go mm))
+      where
+        mm = sukk tt
+
+-- | A stream of integers.
+integerStream :: Integer -> Cofree Identity Integer
+integerStream n = seedStream n succ
+
+-- | Creates a @Cofree Identity v@ based on an infinite list.
+--
+--   This function will cause an error when the list turns out to be finite.
+listStream :: [v] -> Cofree Identity v
+listStream (x:xs) = x :< Identity (listStream xs)
+listStream [] = error "Can't create a stream from a finite list."
+
+instance Functor m => Functor (FreshT v m) where
+    fmap f (FreshT xx) = FreshT $ \s -> fmap (first f) (xx s)
+
+instance (Functor m, Monad m) => Applicative (FreshT v m) where
+    pure = return
+    FreshT ff <*> FreshT xx = FreshT $ \s -> do
+        (fv, s1) <- ff s
+        (xv, s2) <- xx s1
+        return (fv xv, s2)
+
+instance Monad m => Monad (FreshT v m) where
+    return x = FreshT $ \s -> return (x, s)
+    FreshT aa >>= f = FreshT $ \s -> do
+        (a, s1) <- aa s
+        let FreshT ff = f a
+        ff s1
+
+-- TODO Alternative, MonadPlus
+-- TODO MonadFix
+
+instance MonadTrans (FreshT v) where
+    lift m = FreshT $ \s -> do
+                r <- m
+                return (r, s)
+
+-- TODO MonadIO
+
+instance Applicative m => Fresh v (FreshT v m) where
+    fresh = FreshT $ \(s :< Identity s') -> pure (s, s')