diff --git a/Control/Monad/Representable/Reader.hs b/Control/Monad/Representable/Reader.hs --- a/Control/Monad/Representable/Reader.hs +++ b/Control/Monad/Representable/Reader.hs @@ -6,18 +6,18 @@ -- Copyright : (c) Edward Kmett 2011, -- (c) Conal Elliott 2008 -- License : BSD3 --- +-- -- Maintainer : ekmett@gmail.com -- Stability : experimental --- +-- -- Representable functors on Hask all monads, being isomorphic to -- a reader monad. ---------------------------------------------------------------------- module Control.Monad.Representable.Reader - ( + ( -- * Representable functor monad - Reader, reader, runReader + Reader, runReader -- * Monad Transformer , ReaderT(..) , ask @@ -45,8 +45,6 @@ type Reader f = ReaderT f Identity -reader :: Representable f => (Key f -> b) -> Reader f b -reader = readerT . fmap Identity runReader :: Indexable f => Reader f b -> Key f -> b runReader = fmap runIdentity . runReaderT @@ -59,7 +57,7 @@ readerT = ReaderT . tabulate runReaderT :: Indexable f => ReaderT f m b -> Key f -> m b -runReaderT = index . getReaderT +runReaderT = index . getReaderT type instance Key (ReaderT f m) = (Key f, Key m) @@ -70,7 +68,7 @@ ReaderT ff <.> ReaderT fa = ReaderT ((<.>) <$> ff <.> fa) instance (Representable f, Applicative m) => Applicative (ReaderT f m) where - pure = ReaderT . pure . pure + pure = ReaderT . pure . pure ReaderT ff <*> ReaderT fa = ReaderT ((<*>) <$> ff <*> fa) instance (Representable f, Bind m) => Bind (ReaderT f m) where @@ -80,12 +78,13 @@ return = ReaderT . pure . return ReaderT fm >>= f = ReaderT $ tabulate (\a -> index fm a >>= flip index a . getReaderT . f) -instance (Representable f, Monad m, Key f ~ e) => MonadReader e (ReaderT f m) where +instance (Representable f, Monad m, Key f ~ e) => MonadReader e (ReaderT f m) where ask = ReaderT (tabulate return) local f m = readerT $ \r -> runReaderT m (f r) - + reader = readerT . fmap return + instance Representable f => MonadTrans (ReaderT f) where - lift = ReaderT . pure + lift = ReaderT . pure instance (Representable f, Distributive m) => Distributive (ReaderT f m) where distribute = ReaderT . fmap distribute . collect getReaderT @@ -104,7 +103,7 @@ instance (Representable f, Representable m) => Representable (ReaderT f m) where tabulate = ReaderT . tabulate . fmap tabulate . curry - + instance (Foldable f, Foldable m) => Foldable (ReaderT f m) where foldMap f = foldMap (foldMap f) . getReaderT @@ -115,7 +114,7 @@ foldMapWithKey f = foldMapWithKey (\k -> foldMapWithKey (f . (,) k)) . getReaderT instance (FoldableWithKey1 f, FoldableWithKey1 m) => FoldableWithKey1 (ReaderT f m) where - foldMapWithKey1 f = foldMapWithKey1 (\k -> foldMapWithKey1 (f . (,) k)) . getReaderT + foldMapWithKey1 f = foldMapWithKey1 (\k -> foldMapWithKey1 (f . (,) k)) . getReaderT instance (Traversable f, Traversable m) => Traversable (ReaderT f m) where traverse f = fmap ReaderT . traverse (traverse f) . getReaderT @@ -143,7 +142,7 @@ extract = extractRep instance (Representable f, MonadIO m) => MonadIO (ReaderT f m) where - liftIO = lift . liftIO + liftIO = lift . liftIO instance (Representable f, MonadWriter w m) => MonadWriter w (ReaderT f m) where tell = lift . tell diff --git a/Control/Monad/Representable/State.hs b/Control/Monad/Representable/State.hs --- a/Control/Monad/Representable/State.hs +++ b/Control/Monad/Representable/State.hs @@ -9,16 +9,15 @@ -- Module : Control.Monad.Representable.State -- Copyright : (c) Edward Kmett & Sjoerd Visscher 2011 -- License : BSD3 --- +-- -- Maintainer : ekmett@gmail.com -- Stability : experimental --- +-- -- A generalized State monad, parameterized by a Representable functor. -- The representation of that functor serves as the state. ---------------------------------------------------------------------- module Control.Monad.Representable.State ( State - , state , runState , evalState , execState @@ -51,7 +50,7 @@ import Data.Functor.Representable -- --------------------------------------------------------------------------- --- | A memoized state monad parameterized by a representable functor @g@, where +-- | A memoized state monad parameterized by a representable functor @g@, where -- the representatation of @g@, @Key g@ is the state to carry. -- -- The 'return' function leaves the state unchanged, while @>>=@ uses @@ -59,16 +58,10 @@ -- the second. type State g = StateT g Identity --- | Construct a state monad computation from a function. --- (The inverse of 'runState'.) -state :: Representable g - => (Key g -> (a, Key g)) -- ^ pure state transformer - -> State g a -- ^ equivalent state-passing computation -state f = stateT (Identity . f) -- | Unwrap a state monad computation as a function. -- (The inverse of 'state'.) -runState :: Indexable g +runState :: Indexable g => State g a -- ^ state-passing computation to execute -> Key g -- ^ initial state -> (a, Key g) -- ^ return value and final state @@ -78,7 +71,7 @@ -- and return the final value, discarding the final state. -- -- * @'evalState' m s = 'fst' ('runState' m s)@ -evalState :: Indexable g +evalState :: Indexable g => State g a -- ^state-passing computation to execute -> Key g -- ^initial value -> a -- ^return value of the state computation @@ -111,7 +104,7 @@ -- The 'return' function leaves the state unchanged, while @>>=@ uses -- the final state of the first computation as the initial state of -- the second. -newtype StateT g m a = StateT { getStateT :: g (m (a, Key g)) } +newtype StateT g m a = StateT { getStateT :: g (m (a, Key g)) } stateT :: Representable g => (Key g -> m (a, Key g)) -> StateT g m a stateT = StateT . tabulate @@ -152,7 +145,7 @@ instance (Functor g, Indexable g, Bind m) => Bind (StateT g m) where StateT m >>- f = StateT $ fmap (>>- rightAdjunctRep (runStateT . f)) m - + instance (Representable g, Monad m) => Monad (StateT g m) where return = StateT . leftAdjunctRep return StateT m >>= f = StateT $ fmap (>>= rightAdjunctRep (runStateT . f)) m @@ -166,6 +159,7 @@ instance (Representable g, Monad m, Key g ~ s) => MonadState s (StateT g m) where get = stateT $ \s -> return (s, s) put s = StateT $ pure $ return ((),s) + state f = stateT (return . f) -- get :: (Representable g, Monad m) => StateT g m (Key g) -- put :: (Applicative g, Monad m) => Key g -> StateT g m () @@ -194,7 +188,7 @@ instance (Functor f, Representable g, MonadFree f m) => MonadFree f (StateT g m) where wrap as = stateT $ \s -> wrap (fmap (`runStateT` s) as) - + leftAdjunctRep :: Representable u => ((a, Key u) -> b) -> a -> u b leftAdjunctRep f a = tabulate (\s -> f (a,s)) diff --git a/representable-functors.cabal b/representable-functors.cabal --- a/representable-functors.cabal +++ b/representable-functors.cabal @@ -1,6 +1,6 @@ name: representable-functors category: Monads, Functors, Data Structures -version: 2.1.2 +version: 2.2 license: BSD3 cabal-version: >= 1.6 license-file: LICENSE @@ -32,19 +32,19 @@ build-depends: array >= 0.3.0.2 && < 0.5, base >= 4 && < 5, - comonad >= 1.1.1.1 && < 1.2, + comonad >= 1.1.1.3 && < 1.2, containers >= 0.3 && < 0.5, - contravariant >= 0.1.2 && < 0.2, - distributive >= 0.2 && < 0.3, - mtl >= 2.0.1.0 && < 2.1, - semigroups >= 0.8 && < 0.9, - semigroupoids >= 1.2.6.1 && < 1.3.0, - transformers >= 0.2.0 && < 0.3, - keys >= 2.1.2 && < 2.2, - free >= 2.0.3 && < 2.1, - comonad-transformers >= 2.0.3 && < 2.1, - comonads-fd >= 2.0.2.1 && < 2.1, - data-lens >= 2.0.2 && < 2.1 + contravariant >= 0.2.0.1 && < 0.3, + distributive >= 0.2.1 && < 0.3, + mtl >= 2.0.1.0 && < 2.2, + semigroups >= 0.8.2 && < 0.9, + semigroupoids >= 1.3 && < 1.4, + transformers >= 0.3 && < 0.4, + keys >= 2.1.3 && < 2.2, + free >= 2.1 && < 2.2, + comonad-transformers >= 2.1 && < 2.2, + comonads-fd >= 2.1 && < 2.2, + data-lens >= 2.0.3 && < 2.1 exposed-modules: Data.Functor.Corepresentable