kan-extensions 3.0 → 3.1
raw patch · 3 files changed
+21/−104 lines, 3 filesdep ~adjunctionsdep ~freedep ~representable-functors
Dependency ranges changed: adjunctions, free, representable-functors
Files
- kan-extensions.cabal +4/−5
- src/Control/Monad/Codensity.hs +17/−0
- src/Control/Monad/Free/Church.hs +0/−99
kan-extensions.cabal view
@@ -1,6 +1,6 @@ name: kan-extensions category: Data Structures, Monads, Comonads, Functors-version: 3.0+version: 3.1 license: BSD3 cabal-version: >= 1.6 license-file: LICENSE@@ -34,7 +34,7 @@ TypeFamilies build-depends:- adjunctions == 3.0.*,+ adjunctions >= 3.0.0.1 && < 3.1, array >= 0.3.0.2 && < 0.5, base == 4.*, comonad == 3.0.*,@@ -43,10 +43,10 @@ containers >= 0.4 && < 0.6, contravariant >= 0.2.0.1 && < 0.3, distributive >= 0.2.2 && < 0.3,- free == 3.0.*,+ free >= 3.0 && < 3.3, keys == 3.0.*, mtl >= 2.0.1 && < 2.2,- representable-functors == 3.0.*,+ representable-functors >= 3.0.0.1 && < 3.1, semigroupoids == 3.0.*, speculation >= 1.4.1 && < 1.5, transformers >= 0.2 && < 0.4@@ -55,7 +55,6 @@ Control.Comonad.Density Control.Monad.Co Control.Monad.Codensity- Control.Monad.Free.Church Data.Functor.KanExtension Data.Functor.Yoneda Data.Functor.Yoneda.Contravariant
src/Control/Monad/Codensity.hs view
@@ -26,6 +26,7 @@ import Control.Monad (ap, MonadPlus(..)) import Data.Functor.Adjunction import Data.Functor.Apply+import Data.Functor.Plus import Control.Monad.Trans.Class import Control.Monad.IO.Class import Control.Concurrent.Speculation@@ -56,6 +57,22 @@ instance MonadTrans Codensity where lift m = Codensity (m >>=)++instance Alt v => Alt (Codensity v) where+ Codensity m <!> Codensity n = Codensity (\k -> m k <!> n k)++instance Plus v => Plus (Codensity v) where+ zero = Codensity (const zero)++{-+instance Plus v => Alternative (Codensity v) where+ empty = zero+ (<|>) = (<!>)++instance Plus v => MonadPlus (Codensity v) where+ mzero = zero+ mplus = (<!>)+-} instance Alternative v => Alternative (Codensity v) where empty = Codensity (\_ -> empty)
− src/Control/Monad/Free/Church.hs
@@ -1,99 +0,0 @@-{-# LANGUAGE Rank2Types, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}--------------------------------------------------------------------------------- |--- Module : Control.Monad.Free.Church--- Copyright : (C) 2011 Edward Kmett--- License : BSD-style (see the file LICENSE)------ Maintainer : Edward Kmett <ekmett@gmail.com>--- Stability : provisional--- Portability : non-portable (rank-2 polymorphism)------ Free Monads for Less------ http://comonad.com/reader/2011/free-monads-for-less-2/---------------------------------------------------------------------------------module Control.Monad.Free.Church- ( F(..)- , improve- , fromF- , toF- , liftF- , retract- ) where--import Control.Applicative-import Control.Monad-import Control.Monad.Free hiding (liftF, retract)-import Control.Monad.Reader.Class-import Control.Monad.Writer.Class-import Control.Monad.Cont.Class-import Control.Monad.Trans.Class-import Control.Monad.State.Class-import Control.Concurrent.Speculation-import Control.Concurrent.Speculation.Class--instance MonadSpec (F f) where- specByM f g a = F (\k _ -> specBy f g k a)- specByM' f g a = F (\k _ -> specBy' f g k a)--newtype F f a = F { runF :: forall r. (a -> r) -> (f r -> r) -> r }--instance Functor (F f) where- fmap f (F g) = F (\kp -> g (kp . f))--instance Applicative (F f) where- pure a = F (\kp _ -> kp a)- F f <*> F g = F (\kp kf -> f (\a -> g (\b -> kp (a b)) kf) kf)--instance Alternative f => Alternative (F f) where- empty = F (\_ kf -> kf empty)- F f <|> F g = F (\kp kf -> kf (pure (f kp kf) <|> pure (g kp kf)))--instance Monad (F f) where- return a = F (\kp _ -> kp a)- F m >>= f = F (\kp kf -> m (\a -> runF (f a) kp kf) kf)--instance MonadPlus f => MonadPlus (F f) where- mzero = F (\_ kf -> kf mzero)- F f `mplus` F g = F (\kp kf -> kf (return (f kp kf) `mplus` return (g kp kf)))--instance MonadTrans F where- lift f = F (\kp kf -> kf (liftM kp f))--instance Functor f => MonadFree f (F f) where- wrap f = F (\kp kf -> kf (fmap (\ (F m) -> m kp kf) f))--instance MonadState s m => MonadState s (F m) where- get = lift get- put = lift . put--instance MonadReader e m => MonadReader e (F m) where- ask = lift ask - local f = lift . local f . retract--instance MonadWriter w m => MonadWriter w (F m) where- tell = lift . tell- pass = lift . pass . retract- listen = lift . listen . retract--instance MonadCont m => MonadCont (F m) where- callCC f = lift $ callCC (retract . f . fmap lift)--liftF :: Functor f => f a -> F f a-liftF f = F (\kp kf -> kf (fmap kp f))--retract :: Monad m => F m a -> m a-retract (F m) = m return join--fromF :: MonadFree f m => F f a -> m a-fromF (F m) = m return wrap--toF :: Functor f => Free f a -> F f a-toF xs = F (\kp kf -> go kp kf xs) where- go kp _ (Pure a) = kp a- go kp kf (Free fma) = kf (fmap (go kp kf) fma)--improve :: Functor f => (forall m. MonadFree f m => m a) -> Free f a-improve m = fromF m