free 4.12.1 → 4.12.2

raw patch · 13 files changed

+104/−23 lines, 13 filesdep +containersdep +transformers-compatdep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: containers, transformers-compat

Dependency ranges changed: transformers

API changes (from Hackage documentation)

Files

• CHANGELOG.markdown +6/−0
• README.markdown +1/−1
• examples/Cabbage.lhs +1/−1
• free.cabal +5/−3
• src/Control/Comonad/Cofree.hs +31/−6
• src/Control/Comonad/Cofree/Class.hs +4/−0
• src/Control/Comonad/Trans/Cofree.hs +21/−0
• src/Control/Monad/Free.hs +10/−4
• src/Control/Monad/Free/Church.hs +8/−3
• src/Control/Monad/Free/Class.hs +4/−0
• src/Control/Monad/Free/TH.hs +10/−2
• src/Control/Monad/Trans/Free.hs +2/−2
• src/Control/Monad/Trans/Iter.hs +1/−1

@@ -1,3 +1,9 @@+4.12.2+------+* Add instances for `ExceptT`: like `ErrorT`, but without an `Error` constraint.+* Support `containers`+* Support `transformers` 0.5+ 4.12.1 ------ * Support GHC 7.4

@@ -1,7 +1,7 @@ free ==== -[![Build Status](https://secure.travis-ci.org/ekmett/free.png?branch=master)](http://travis-ci.org/ekmett/free)+[![Hackage](https://img.shields.io/hackage/v/free.svg)](https://hackage.haskell.org/package/free) [![Build Status](https://secure.travis-ci.org/ekmett/free.png?branch=master)](http://travis-ci.org/ekmett/free)  This package provides a common definitions for working with free monads, free applicatives, and cofree comonads in Haskell. 

@@ -43,7 +43,7 @@  @ *Cabbage> singleOut1 (== Sheep) [Wolf, Sheep, Cabbage]-[(Just Wolf,[Sheep,Cabbage]),(Just Sheep,[Wolf,Cabbage]),(Just Cabbage,[Wolf,Sheep]),(Nothing,[Wolf,Sheep,Cabbage])]+(Just Sheep,[Wolf,Cabbage]) @  > singleOutAll :: [a] -> [(Maybe a,[a])]

@@ -1,6 +1,6 @@ name:          free category:      Control, Monads-version:       4.12.1+version:       4.12.2 license:       BSD3 cabal-version: >= 1.10 license-file:  LICENSE@@ -76,9 +76,11 @@     profunctors          >= 4 && < 6,     semigroupoids        >= 4 && < 6,     semigroups           >= 0.8.3.1 && < 1,-    transformers         >= 0.2.0   && < 0.5,+    transformers         >= 0.2.0   && < 0.6,+    transformers-compat  >= 0.3     && < 1,     template-haskell     >= 2.7.0.0 && < 3,-    exceptions           >= 0.6 && < 0.9+    exceptions           >= 0.6 && < 0.9,+    containers           < 0.6    exposed-modules:     Control.Applicative.Free

@@ -25,6 +25,7 @@   , ComonadCofree(..)   , section   , coiter+  , coiterW   , unfold   , unfoldM   , hoistCofree@@ -41,6 +42,7 @@ import Control.Comonad.Env.Class import Control.Comonad.Store.Class as Class import Control.Comonad.Traced.Class+import Control.Comonad.Hoist.Class import Control.Category import Control.Monad(ap, (>=>), liftM) import Control.Monad.Zip@@ -64,7 +66,7 @@ -- /Formally/ -- -- A 'Comonad' @v@ is a cofree 'Comonad' for @f@ if every comonad homomorphism--- another comonad @w@ to @v@ is equivalent to a natural transformation+-- from another comonad @w@ to @v@ is equivalent to a natural transformation -- from @w@ to @f@. -- -- A 'cofree' functor is right adjoint to a forgetful functor.@@ -110,6 +112,10 @@ coiter :: Functor f => (a -> f a) -> a -> Cofree f a coiter psi a = a :< (coiter psi <$> psi a) +-- | Like coiter for comonadic values.+coiterW :: (Comonad w, Functor f) => (w a -> f (w a)) -> w a -> Cofree f a+coiterW psi a = extract a :< (coiterW psi <$> psi a)+ -- | Unfold a cofree comonad from a seed. unfold :: Functor f => (b -> (a, f b)) -> b -> Cofree f a unfold f c = case f c of@@ -151,7 +157,7 @@   {-# INLINE lower #-}  instance Alternative f => Monad (Cofree f) where-  return x = x :< empty+  return = pure   {-# INLINE return #-}   (a :< m) >>= k = case k a of                      b :< n -> b :< (n <|> fmap (>>= k) m)@@ -182,7 +188,7 @@   {-# INLINE (@>) #-}  instance Alternative f => Applicative (Cofree f) where-  pure = return+  pure x = x :< empty   {-# INLINE pure #-}   (<*>) = ap   {-# INLINE (<*>) #-}@@ -235,6 +241,10 @@   foldMap f = go where     go (a :< as) = f a `mappend` foldMap go as   {-# INLINE foldMap #-}+#if __GLASGOW_HASKELL__ >= 709+  length = go 0 where+    go s (_ :< as) = foldl' go (s + 1) as+#endif  instance Foldable1 f => Foldable1 (Cofree f) where   foldMap1 f = go where@@ -291,6 +301,9 @@ {-# NOINLINE cofreeDataType #-} #endif +instance ComonadHoist Cofree where+  cohoist = hoistCofree+ instance ComonadEnv e w => ComonadEnv e (Cofree w) where   ask = ask . lower   {-# INLINE ask #-}@@ -331,12 +344,24 @@ _unwrap  f (a :< as) = (a :<) <$> f as {-# INLINE _unwrap #-} --- | Construct a @Lens@ into a @'Cofree' f@ given a list of lenses into the base functor.+-- | Construct an @Lens@ into a @'Cofree' g@ given a list of lenses into the base functor.+-- When the input list is empty, this is equivalent to '_extract'.+-- When the input list is non-empty, this composes the input lenses+-- with '_unwrap' to walk through the @'Cofree' g@ before using+-- '_extract' to get the element at the final location. -- -- For more on lenses see the 'lens' package on hackage. ----- @telescoped :: 'Functor' g => [Lens' ('Cofree' g a) (g ('Cofree' g a))] -> Lens' ('Cofree' g a) a@-telescoped :: (Functor f, Functor g) =>+-- @telescoped :: [Lens' (g ('Cofree' g a)) ('Cofree' g a)]      -> Lens' ('Cofree' g a) a@+--+-- @telescoped :: [Traversal' (g ('Cofree' g a)) ('Cofree' g a)] -> Traversal' ('Cofree' g a) a@+--+-- @telescoped :: [Getter (g ('Cofree' g a)) ('Cofree' g a)]     -> Getter ('Cofree' g a) a@+--+-- @telescoped :: [Fold (g ('Cofree' g a)) ('Cofree' g a)]       -> Fold ('Cofree' g a) a@+--+-- @telescoped :: [Setter' (g ('Cofree' g a)) ('Cofree' g a)]    -> Setter' ('Cofree' g a) a@+telescoped :: Functor f =>              [(Cofree g a -> f (Cofree g a)) -> g (Cofree g a) -> f (g (Cofree g a))] ->               (a -> f a) -> Cofree g a -> f (Cofree g a) telescoped = Prelude.foldr (\l r -> _unwrap . l . r) _extract

@@ -23,6 +23,7 @@ import Control.Comonad.Trans.Traced import Control.Comonad.Trans.Identity import Data.List.NonEmpty+import Data.Tree import Data.Semigroup  -- | Allows you to peel a layer off a cofree comonad.@@ -33,6 +34,9 @@ instance ComonadCofree Maybe NonEmpty where   unwrap (_ :| [])       = Nothing   unwrap (_ :| (a : as)) = Just (a :| as)++instance ComonadCofree [] Tree where+  unwrap = subForest  instance ComonadCofree (Const b) ((,) b) where   unwrap = Const . fst

@@ -3,6 +3,7 @@ {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE Rank2Types #-} #if __GLASGOW_HASKELL__ >= 707 {-# LANGUAGE DeriveDataTypeable #-} #endif@@ -26,6 +27,7 @@   , ComonadCofree(..)   , headF   , tailF+  , transCofreeT   , coiterT   ) where @@ -33,6 +35,8 @@ import Control.Comonad import Control.Comonad.Trans.Class import Control.Comonad.Cofree.Class+import Control.Comonad.Env.Class+import Control.Comonad.Hoist.Class import Control.Category import Data.Bifunctor import Data.Bifoldable@@ -83,6 +87,10 @@ instance Traversable f => Bitraversable (CofreeF f) where   bitraverse f g (a :< as) = (:<) <$> f a <*> traverse g as +transCofreeF :: (forall x. f x -> g x) -> CofreeF f a b -> CofreeF g a b+transCofreeF t (a :< fb) = a :< t fb+{-# INLINE transCofreeF #-}+ -- | This is a cofree comonad of some functor @f@, with a comonad @w@ threaded through it at each level. newtype CofreeT f w a = CofreeT { runCofreeT :: w (CofreeF f a (CofreeT f w a)) } #if __GLASGOW_HASKELL__ >= 707@@ -138,6 +146,13 @@ instance (Functor f, Comonad w) => ComonadCofree f (CofreeT f w) where   unwrap = tailF . extract . runCofreeT +instance (Functor f, ComonadEnv e w) => ComonadEnv e (CofreeT f w) where+  ask = ask . lower+  {-# INLINE ask #-} ++instance Functor f => ComonadHoist (CofreeT f) where+  cohoist g = CofreeT . fmap (second (cohoist g)) . g . runCofreeT+ instance Show (w (CofreeF f a (CofreeT f w a))) => Show (CofreeT f w a) where   showsPrec d (CofreeT w) = showParen (d > 10) $     showString "CofreeT " . showsPrec 11 w@@ -153,8 +168,10 @@   compare (CofreeT a) (CofreeT b) = compare a b  instance (Alternative f, Monad w) => Monad (CofreeT f w) where+#if __GLASGOW_HASKELL__ < 710   return = CofreeT . return . (:< empty)   {-# INLINE return #-}+#endif   CofreeT cx >>= f = CofreeT $ do     a :< m <- cx     b :< n <- runCofreeT $ f a@@ -176,6 +193,10 @@   mzip (CofreeT ma) (CofreeT mb) = CofreeT $ do                                      (a :< fa, b :< fb) <- mzip ma mb                                      return $ (a, b) :< (uncurry mzip <$> mzip fa fb)++-- | Lift a natural transformation from @f@ to @g@ into a comonad homomorphism from @'CofreeT' f w@ to @'CofreeT' g w@+transCofreeT :: (Functor g, Comonad w) => (forall x. f x -> g x) -> CofreeT f w a -> CofreeT g w a+transCofreeT t = CofreeT . liftW (fmap (transCofreeT t) . transCofreeF t) . runCofreeT  -- | Unfold a @CofreeT@ comonad transformer from a coalgebra and an initial comonad. coiterT :: (Functor f, Comonad w) => (w a -> f (w a)) -> w a -> CofreeT f w a

@@ -28,6 +28,7 @@   , retract   , liftF   , iter+  , iterA   , iterM   , hoistFree   , foldFree@@ -186,7 +187,7 @@   Free m >>- f = Free ((>>- f) <$> m)  instance Functor f => Monad (Free f) where-  return = Pure+  return = pure   {-# INLINE return #-}   Pure a >>= f = f a   Free m >>= f = Free ((>>= f) <$> m)@@ -303,17 +304,22 @@ iter _ (Pure a) = a iter phi (Free m) = phi (iter phi <$> m) --- | Like iter for monadic values.+-- | Like 'iter' for applicative values.+iterA :: (Applicative p, Functor f) => (f (p a) -> p a) -> Free f a -> p a+iterA _   (Pure x) = pure x+iterA phi (Free f) = phi (iterA phi <$> f)++-- | Like 'iter' for monadic values. iterM :: (Monad m, Functor f) => (f (m a) -> m a) -> Free f a -> m a iterM _   (Pure x) = return x-iterM phi (Free f) = phi $ fmap (iterM phi) f+iterM phi (Free f) = phi (iterM phi <$> f)  -- | Lift a natural transformation from @f@ to @g@ into a natural transformation from @'FreeT' f@ to @'FreeT' g@. hoistFree :: Functor g => (forall a. f a -> g a) -> Free f b -> Free g b hoistFree _ (Pure a)  = Pure a hoistFree f (Free as) = Free (hoistFree f <$> f as) --- | The very definition of a free monoid is that given a natural transformation you get a monoid homomorphism.+-- | The very definition of a free monad is that given a natural transformation you get a monad homomorphism. foldFree :: (Functor m, Monad m) => (forall x . f x -> m x) -> Free f a -> m a foldFree _ (Pure a)  = return a foldFree f (Free as) = f as >>= foldFree f

@@ -56,6 +56,7 @@   ( F(..)   , improve   , fromF+  , iter   , iterM   , toF   , retract@@ -69,7 +70,7 @@ import Control.Applicative import Control.Monad as Monad import Control.Monad.Fix-import Control.Monad.Free hiding (retract, iterM, cutoff)+import Control.Monad.Free hiding (retract, iter, iterM, cutoff) import qualified Control.Monad.Free as Free import Control.Monad.Reader.Class import Control.Monad.Writer.Class@@ -87,6 +88,10 @@ -- <http://comonad.com/reader/2011/free-monads-for-less-2/> newtype F f a = F { runF :: forall r. (a -> r) -> (f r -> r) -> r } +-- | Tear down a 'Free' 'Monad' using iteration.+iter :: Functor f => (f a -> a) -> F f a -> a+iter phi xs = runF xs id phi+ -- | Like iter for monadic values. iterM :: (Monad m, Functor f) => (f (m a) -> m a) -> F f a -> m a iterM phi xs = runF xs return phi@@ -110,7 +115,7 @@   (>>-) = (>>=)  instance Monad (F f) where-  return a = F (\kp _ -> kp a)+  return = pure   F m >>= f = F (\kp kf -> m (\a -> runF (f a) kp kf) kf)  instance MonadFix (F f) where@@ -169,7 +174,7 @@ hoistF :: (forall x. f x -> g x) -> F f a -> F g a hoistF t (F m) = F (\p f -> m p (f . t)) --- | The very definition of a free monoid is that given a natural transformation you get a monoid homomorphism.+-- | The very definition of a free monad is that given a natural transformation you get a monad homomorphism. foldF :: Monad m => (forall x. f x -> m x) -> F f a -> m a foldF f (F m) = m return (Monad.join . f) 

@@ -43,6 +43,7 @@ import Control.Monad.Trans.Maybe import Control.Monad.Trans.List import Control.Monad.Trans.Error+import Control.Monad.Trans.Except import Control.Monad.Trans.Identity  #if !(MIN_VERSION_base(4,8,0))@@ -143,6 +144,9 @@  instance (Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) where   wrap = ErrorT . wrap . fmap runErrorT++instance (Functor f, MonadFree f m) => MonadFree f (ExceptT e m) where+  wrap = ExceptT . wrap . fmap runExceptT  -- instance (Functor f, MonadFree f m) => MonadFree f (EitherT e m) where --   wrap = EitherT . wrap . fmap runEitherT

@@ -195,7 +195,11 @@         -> Maybe [Name]     -- ^ Include only mentioned constructor names. Use all constructors when @Nothing@.         -> Dec              -- ^ Data type declaration.         -> Q [Dec]+#if MIN_VERSION_template_haskell(2,11,0)+liftDec typeSig onlyCons (DataD _ tyName tyVarBndrs _ cons _)+#else liftDec typeSig onlyCons (DataD _ tyName tyVarBndrs cons _)+#endif   | null tyVarBndrs = fail $ "Type " ++ show tyName ++ " needs at least one free variable"   | otherwise = concat <$> mapM (liftCon typeSig [] [] con nextTyName (init tyNames)) cons'     where@@ -232,7 +236,11 @@ genFreeCon typeSig cname = do   info <- reify cname   case info of-    DataConI _ _ tname _ -> genFree typeSig (Just [cname]) tname+    DataConI _ _ tname+#if !(MIN_VERSION_template_haskell(2,11,0))+                       _+#endif+                         -> genFree typeSig (Just [cname]) tname     _ -> fail "makeFreeCon expects a data constructor"  -- | @$('makeFree' ''T)@ provides free monadic actions for the@@ -240,7 +248,7 @@ makeFree :: Name -> Q [Dec] makeFree = genFree True Nothing --- | Like 'makeFreeCon', but does not provide type signatures.+-- | Like 'makeFree', but does not provide type signatures. -- This can be used to attach Haddock comments to individual arguments -- for each generated function. --

@@ -224,7 +224,7 @@  instance (Functor f, Monad m) => Monad (FreeT f m) where   fail e = FreeT (fail e)-  return a = FreeT (return (Pure a))+  return = pure   {-# INLINE return #-}   FreeT m >>= f = FreeT $ m >>= \v -> case v of     Pure a -> runFreeT (f a)@@ -332,7 +332,7 @@ hoistFreeT :: (Monad m, Functor f) => (forall a. m a -> n a) -> FreeT f m b -> FreeT f n b hoistFreeT mh = FreeT . mh . liftM (fmap (hoistFreeT mh)) . runFreeT --- | Lift a natural transformation from @f@ to @g@ into a monad homomorphism from @'FreeT' f m@ to @'FreeT' g n@+-- | Lift a natural transformation from @f@ to @g@ into a monad homomorphism from @'FreeT' f m@ to @'FreeT' g m@ transFreeT :: (Monad m, Functor g) => (forall a. f a -> g a) -> FreeT f m b -> FreeT g m b transFreeT nt = FreeT . liftM (fmap (transFreeT nt) . transFreeF nt) . runFreeT 

@@ -172,7 +172,7 @@   {-# INLINE (<*>) #-}  instance Monad m => Monad (IterT m) where-  return = IterT . return . Left+  return = pure   {-# INLINE return #-}   IterT m >>= k = IterT $ m >>= either (runIterT . k) (return . Right . (>>= k))   {-# INLINE (>>=) #-}