representable-functors 2.1.2 → 2.2
raw patch · 3 files changed
+35/−42 lines, 3 filesdep ~comonaddep ~comonad-transformersdep ~comonads-fd
Dependency ranges changed: comonad, comonad-transformers, comonads-fd, contravariant, data-lens, distributive, free, keys, mtl, semigroupoids, semigroups, transformers
Files
- Control/Monad/Representable/Reader.hs +13/−14
- Control/Monad/Representable/State.hs +9/−15
- representable-functors.cabal +13/−13
Control/Monad/Representable/Reader.hs view
@@ -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
Control/Monad/Representable/State.hs view
@@ -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))
representable-functors.cabal view
@@ -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