hs-functors 0.1.2.0 → 0.1.3.0

raw patch · 4 files changed

+81/−13 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• Control/Comonad/Density.hs +24/−0
• Control/Monad/Codensity.hs +34/−0
• Control/Monad/Morph.hs +18/−10
• hs-functors.cabal +5/−3

@@ -0,0 +1,24 @@+{-# LANGUAGE ExistentialQuantification #-}++module Control.Comonad.Density where++import Control.Comonad+import Control.Comonad.Trans.Class++data Density f a = ∀ b . Density (f b -> a) (f b)++deriving instance Functor (Density f)++instance Applicative f => Applicative (Density f) where+    pure a = Density (pure a) (pure ())+    Density f x <*> Density g y = pure ((f x) (g y))++instance Comonad (Density f) where+    copure (Density f x) = f x+    cut ɯ@(Density _ x) = Density (pure ɯ) x++instance ComonadTrans Density where+    colift (Density f x) = f <<= x++lift :: Comonad ɯ => ɯ a -> Density ɯ a+lift = Density copure

@@ -0,0 +1,34 @@+{-# LANGUAGE RankNTypes #-}++module Control.Monad.Codensity where++import Prelude hiding (fail)+import Control.Applicative+import Control.Monad hiding (fail)+import Control.Monad.Fail+import Control.Monad.Trans.Class++newtype Codensity m a = Codensity { codensity :: ∀ b . (a -> m b) -> m b }++deriving instance Functor (Codensity m)++instance Applicative (Codensity p) where+    pure x = Codensity ($ x)+    Codensity x <*> Codensity y = Codensity (\ g -> x (\ f -> y (g . f)))++instance Monad (Codensity m) where+    Codensity x >>= f = Codensity (x . flip (codensity . f))++instance MonadFail f => MonadFail (Codensity f) where+    fail xs = Codensity (\ _ -> fail xs)++instance Alternative p => Alternative (Codensity p) where+    empty = Codensity (pure empty)+    Codensity x <|> Codensity y = Codensity (liftA2 (<|>) x y)++instance Alternative p => MonadPlus (Codensity p)++instance MonadTrans Codensity where lift xm = Codensity (xm >>=)++unlift :: Applicative p => Codensity p a -> p a+unlift = flip codensity pure

@@ -3,13 +3,16 @@ module Control.Monad.Morph where  import Control.Monad+import Control.Monad.Trans.Accum import Control.Monad.Trans.Class import Control.Monad.Trans.Except import Control.Monad.Trans.Identity import Control.Monad.Trans.Maybe import Control.Monad.Trans.Reader-import Control.Monad.Trans.State-import Control.Monad.Trans.Writer+import Control.Monad.Trans.State.Lazy as L+import Control.Monad.Trans.State.Strict as S+import Control.Monad.Trans.Writer.Lazy as L+import Control.Monad.Trans.Writer.Strict as S import Data.Functor.Compose import Data.Functor.Product import Data.Functor.Sum@@ -31,16 +34,21 @@     mmap _ (InL x) = InL x     mmap f (InR y) = InR (f y) -instance MFunctor (ExceptT e) where mmap = mapExceptT-instance MFunctor IdentityT   where mmap = mapIdentityT-instance MFunctor MaybeT      where mmap = mapMaybeT-instance MFunctor (ReaderT r) where mmap = mapReaderT-instance MFunctor (StateT  s) where mmap = mapStateT-instance MFunctor (WriterT w) where mmap = mapWriterT+instance MFunctor (ExceptT e)   where mmap = mapExceptT+instance MFunctor IdentityT     where mmap = mapIdentityT+instance MFunctor MaybeT        where mmap = mapMaybeT+instance MFunctor (ReaderT r)   where mmap = mapReaderT+instance MFunctor (L.StateT s)  where mmap = L.mapStateT+instance MFunctor (S.StateT s)  where mmap = S.mapStateT+instance MFunctor (L.WriterT w) where mmap = L.mapWriterT+instance MFunctor (S.WriterT w) where mmap = S.mapWriterT+instance MFunctor (AccumT c)    where mmap = mapAccumT  instance MMonad (ExceptT e) where mjoin (ExceptT   (ExceptT   x)) = ExceptT (join <$> x) instance MMonad IdentityT   where mjoin (IdentityT (IdentityT x)) = IdentityT x instance MMonad MaybeT      where mjoin (MaybeT    (MaybeT    x)) = MaybeT (join <$> x) instance MMonad (ReaderT r) where mjoin (ReaderT f) = ReaderT (join (runReaderT . f))-instance Monoid w => MMonad (WriterT w) where-    mjoin (WriterT (WriterT x)) = WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)+instance Monoid w => MMonad (L.WriterT w) where+    mjoin (L.WriterT (L.WriterT x)) = L.WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)+instance Monoid w => MMonad (S.WriterT w) where+    mjoin (S.WriterT (S.WriterT x)) = S.WriterT ((\ ((a, u), v) -> (a, u <> v)) <$> x)

@@ -1,5 +1,5 @@ name:                hs-functors-version:             0.1.2.0+version:             0.1.3.0 synopsis:            Functors from products of Haskell and its dual to Haskell -- description:          license:             BSD3@@ -10,13 +10,15 @@ category:            Math build-type:          Simple cabal-version:       >=1.10-tested-with:         GHC ==8.0.2-                   , GHC ==8.2.2+tested-with:         GHC ==8.2.2+                   , GHC ==8.4.2  library   exposed-modules:     Control.Comonad                      , Control.Comonad.Cofree+                     , Control.Comonad.Density                      , Control.Comonad.Trans.Class+                     , Control.Monad.Codensity                      , Control.Monad.Free                      , Control.Monad.Morph                      , Control.Monad.Trans.Compose