diff --git a/data-fresh.cabal b/data-fresh.cabal
--- a/data-fresh.cabal
+++ b/data-fresh.cabal
@@ -1,12 +1,12 @@
 name:               data-fresh
-version:            0.2013.250.1
+version:            0.2013.251.0
 stability:          experimental
 category:           Control
 synopsis:           Interface and functor transformers for fresh values
 description:
-    A simple library, mostly containing of an interface to generate fresh values.
+    A simple library, which contains an interface for generating fresh values.
     .
-    This package also includes two functor transformers which implement this
+    This library also includes two functor transformers which implement this
     interface. They consume fresh values from user-supplied comonads.
     Currently, two approaches are implemented:
     .
@@ -35,6 +35,7 @@
         Control.Monad.Trans.Fresh.Delta
         Control.Monad.Trans.Fresh.Stream
         Data.Fresh
+        Data.Triplet
     build-depends:
         base >= 4 && < 5,
         free -any,
diff --git a/src/Control/Monad/Trans/Fresh/Delta.hs b/src/Control/Monad/Trans/Fresh/Delta.hs
--- a/src/Control/Monad/Trans/Fresh/Delta.hs
+++ b/src/Control/Monad/Trans/Fresh/Delta.hs
@@ -4,12 +4,12 @@
 module Control.Monad.Trans.Fresh.Delta where
 
 import Control.Applicative
-import Control.Arrow (first)
+import Control.Arrow (first, second)
 import Control.Comonad.Cofree
 import Control.Monad.Trans.Class
+import Data.Bits
 import Data.Fresh
-
-data Triplet a = Triplet a a a
+import Data.Triplet
 
 newtype FreshT v m a = FreshT
     { runFreshT :: Cofree Triplet v -> m (a, Cofree Triplet v) }
@@ -28,9 +28,13 @@
         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))
+-- | A delta of integer pairs.
+integerPairDelta :: (Integer, Integer) -> Cofree Triplet (Integer, Integer)
+integerPairDelta n = seedDelta n sukk splt
+  where
+    sukk = second succ
+    splt (m, _) = let m' = m `shiftL` 1
+                  in ((m', 0), (m' .|. 1, 0))
 
 instance Functor m => Functor (FreshT v m) where
     fmap f (FreshT xx) = FreshT $ \s -> fmap (first f) (xx s)
@@ -42,10 +46,10 @@
 
 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
+    FreshT aa >>= f = FreshT $ \(_ :< Triplet l _ r) -> do
+        (a, _) <- aa l
         let FreshT ff = f a
-        ff s1
+        ff r
 
 -- TODO Alternative, MonadPlus
 -- TODO MonadFix
diff --git a/src/Data/Triplet.hs b/src/Data/Triplet.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Triplet.hs
@@ -0,0 +1,22 @@
+module Data.Triplet where
+
+import Control.Applicative
+import Data.Foldable
+import Data.Monoid
+import Data.Traversable
+
+data Triplet a = Triplet a a a
+    deriving (Eq, Read, Show)
+
+instance Functor Triplet where
+    fmap f (Triplet l m r) = Triplet (f l) (f m) (f r)
+
+instance Applicative Triplet where
+    pure x = Triplet x x x
+    Triplet fl fm fr <*> Triplet xl xm xr = Triplet (fl xl) (fm xm) (fr xr)
+
+instance Foldable Triplet where
+    foldMap f (Triplet l m r) = mconcat . map f $ [l, m, r]
+
+instance Traversable Triplet where
+    sequenceA (Triplet l m r) = Triplet <$> l <*> m <*> r