data-fresh 0.2013.250 → 0.2013.250.1

raw patch · 4 files changed

+152/−54 lines, 4 filesdep +freePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: free

API changes (from Hackage documentation)

Files

• data-fresh.cabal +25/−5
• src/Control/Monad/Trans/Fresh.hs +0/−49
• src/Control/Monad/Trans/Fresh/Delta.hs +61/−0
• src/Control/Monad/Trans/Fresh/Stream.hs +66/−0

@@ -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

@@ -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)

@@ -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')

@@ -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')