packages feed

comonad-transformers 3.1 → 4.0

raw patch · 11 files changed

+5/−822 lines, 11 filesdep −containersdep −contravariantdep −distributivedep ~comonad

Dependencies removed: containers, contravariant, distributive, semigroupoids, semigroups, transformers

Dependency ranges changed: comonad

Files

− CHANGELOG.markdown 
@@ -1,24 +0,0 @@-3.1-----* More instances for `Coproduct`--3.0.4-------* Removed unnecessary constraints in `Control.Comonad.Trans.Store`.--3.0.3-------* Marked modules Trustworthy as needed.--3.0.1-------* Removed upper bounds on my other dependencies-* Directory layout change-* Added support files-* Travis build notification to IRC--2.1-----* Removed Discont-* Switched to mkTyCon3-* Upgraded to transformers 0.3
comonad-transformers.cabal view
@@ -1,6 +1,6 @@ name:          comonad-transformers category:      Control, Comonads-version:       3.1+version:       4.0 license:       BSD3 cabal-version: >= 1.6 license-file:  LICENSE@@ -9,13 +9,11 @@ stability:     provisional homepage:      http://github.com/ekmett/comonad-transformers/ bug-reports:   http://github.com/ekmett/comonad-transformers/issues-copyright:     Copyright (C) 2008-2012 Edward A. Kmett-synopsis:      Comonad transformers-description:   Comonad transformers+copyright:     Copyright (C) 2008-2013 Edward A. Kmett+synopsis:      This package has been merged into comonad 4.0+description:   This package has been merged into comonad 4.0 build-type:    Simple extra-source-files:-  coq/Store.v-  CHANGELOG.markdown   README.markdown   .travis.yml   .ghci@@ -27,27 +25,4 @@   location: git://github.com/ekmett/comonad-transformers.git  library-  build-depends:-    base          >= 4       && < 5,-    comonad       >= 3.0,-    containers    >= 0.3     && < 0.6,-    contravariant >= 0.2.0.1,-    distributive  >= 0.2.2,-    semigroupoids >= 3.0,-    semigroups    >= 0.8.3.1,-    transformers  >= 0.2     && < 0.4--  extensions: CPP--  exposed-modules:-    Control.Comonad.Hoist.Class-    Control.Comonad.Trans.Class-    Control.Comonad.Trans.Env-    Control.Comonad.Trans.Identity-    Control.Comonad.Trans.Store-    Control.Comonad.Trans.Traced-    Data.Functor.Coproduct-    Data.Functor.Composition--  ghc-options: -Wall-  hs-source-dirs: src+  build-depends: base >= 4 && < 5, comonad >= 4
− coq/Store.v 
@@ -1,96 +0,0 @@-(* Proof StoreT forms a comonad -- Russell O'Connor *)--Set Implict Arguments.-Unset Strict Implicit.--Require Import FunctionalExtensionality.--Record Comonad (w : Type -> Type) : Type :=- { extract : forall a, w a -> a- ; extend : forall a b, (w a -> b) -> w a -> w b- ; law1 : forall a x, extend _ _ (extract a) x = x- ; law2 : forall a b f x, extract b (extend a _ f x) = f x- ; law3 : forall a b c f g x, extend b c f (extend a b g x) = extend a c (fun y => f (extend a b g y)) x- }.--Section StoreT.--Variables (s : Type) (w:Type -> Type).-Hypothesis wH : Comonad w.--Definition map a b f x := extend _ wH a b (fun y => f (extract _ wH _ y)) x.--Lemma map_extend : forall a b c f g x, map b c f (extend _ wH a b g x) = extend _ wH _ _ (fun y => f (g y)) x.-Proof.-intros a b c f g x.-unfold map.-rewrite law3.-apply equal_f.-apply f_equal.-extensionality y.-rewrite law2.-reflexivity.-Qed.--Record StoreT (a:Type): Type := mkStoreT-  {store : w (s -> a)-  ;loc   : s}.--Definition extractST a (x:StoreT a) : a := - extract _ wH _ (store _ x) (loc _ x).--Definition mapST a b (f:a -> b) (x:StoreT a) : StoreT b :=- mkStoreT _ (map _ _ (fun g x => f (g x)) (store _ x)) (loc _ x).--Definition duplicateST a (x:StoreT a) : StoreT (StoreT a) :=- mkStoreT _ (extend _ wH _ _ (mkStoreT _) (store _ x)) (loc _ x).--Let extendST := fun a b f x => mapST _ b f (duplicateST a x).--Lemma law1ST : forall a x, extendST _ _ (extractST a) x = x.-Proof.-intros a [v b].-unfold extractST, extendST, duplicateST, mapST.-simpl.-rewrite map_extend.-simpl.-replace (fun (y : w (s -> a)) (x : s) => extract w wH (s -> a) y x)- with (extract w wH (s -> a)).- rewrite law1.- reflexivity.-extensionality y.-extensionality x.-reflexivity.-Qed.--Lemma law2ST : forall a b f x, extractST b (extendST a _ f x) = f x.-Proof.-intros a b f [v c].-unfold extendST, mapST, extractST.-simpl.-rewrite map_extend.-rewrite law2.-reflexivity.-Qed.--Lemma law3ST : forall a b c f g x, extendST b c f (extendST a b g x) = extendST a c (fun y => f (extendST a b g y)) x.-Proof.-intros a b c f g [v d].-unfold extendST, mapST, extractST.-simpl.-repeat rewrite map_extend.-rewrite law3.-repeat (apply equal_f||apply f_equal).-extensionality y.-extensionality x.-rewrite map_extend.-reflexivity.-Qed.--Definition StoreTComonad : Comonad StoreT :=- Build_Comonad _ _ _ law1ST law2ST law3ST.--End StoreT.--Check StoreTComonad.-
− src/Control/Comonad/Hoist/Class.hs 
@@ -1,29 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Hoist.Class--- Copyright   :  (C) 2008-2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------------------------------------------------------------------------------module Control.Comonad.Hoist.Class (ComonadHoist(..)) where--import Control.Comonad-import Control.Monad.Trans.Identity-import Data.Functor.Identity--class ComonadHoist t where-  -- | Ideally we would offer a way to lift comonad homomorphisms-  -- but this isn't Haskell 98, so we settle for the most common case-  -- here.-  ---  -- > liftTrans :: (forall a. w a -> v a) -> t w a -> t v a -  -- > cohoist = liftTrans (Identity . extract)-  cohoist :: Comonad w => t w a -> t Identity a---- avoiding orphans--instance ComonadHoist IdentityT where-  cohoist = IdentityT . Identity . extract . runIdentityT
− src/Control/Comonad/Trans/Class.hs 
@@ -1,26 +0,0 @@-{-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Trans.Class--- Copyright   :  (C) 2008-2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------------------------------------------------------------------------------module Control.Comonad.Trans.Class-  ( ComonadTrans(..) ) where--import Control.Comonad-import Control.Monad.Trans.Identity--class ComonadTrans t where-  lower :: Comonad w => t w a -> w a---- avoiding orphans-instance ComonadTrans IdentityT where-  lower = runIdentityT
− src/Control/Comonad/Trans/Env.hs 
@@ -1,186 +0,0 @@-{-# LANGUAGE CPP #-}-{-# LANGUAGE FlexibleContexts #-}-#if __GLASGOW_HASKELL__ >= 707-{-# LANGUAGE StandaloneDeriving, DeriveDataTypeable #-}-#endif-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Trans.Env--- Copyright   :  (C) 2008-2013 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------ The environment comonad holds a value along with some retrievable context.------ This module specifies the environment comonad transformer (aka coreader),--- which is left adjoint to the reader comonad.------ The following sets up an experiment that retains its initial value in the--- background:------ >>> let initial = env 0 0------ Extract simply retrieves the value:------ >>> extract initial--- 0------ Play around with the value, in our case producing a negative value:------ >>> let experiment = fmap (+ 10) initial--- >>> extract experiment--- 10------ Oh noes, something went wrong, 10 isn't very negative! Better restore the--- initial value using the default:------ >>> let initialRestored = experiment =>> ask--- >>> extract initialRestored--- 0------------------------------------------------------------------------------module Control.Comonad.Trans.Env-  (-  -- * The strict environment comonad-    Env-  , env-  , runEnv-  -- * The strict environment comonad transformer-  , EnvT(..)-  , runEnvT-  , lowerEnvT-  -- * Combinators-  , ask-  , asks-  , local-  ) where--import Control.Comonad-import Control.Comonad.Hoist.Class-import Control.Comonad.Trans.Class-import Data.Foldable-import Data.Traversable-import Data.Functor.Apply-import Data.Functor.Identity-import Data.Functor.Extend-import Data.Semigroup--#ifdef __GLASGOW_HASKELL__-#if __GLASGOW_HASKELL__ >= 707-#define Typeable1 Typeable-#endif-import Data.Data--#if __GLASGOW_HASKELL__ >= 707-deriving instance Typeable EnvT-#else-instance (Typeable s, Typeable1 w) => Typeable1 (EnvT s w) where-  typeOf1 dswa = mkTyConApp envTTyCon [typeOf (s dswa), typeOf1 (w dswa)]-    where-      s :: EnvT s w a -> s-      s = undefined-      w :: EnvT s w a -> w a-      w = undefined-#endif--envTTyCon :: TyCon-#if __GLASGOW_HASKELL__ < 704-envTTyCon = mkTyCon "Control.Comonad.Trans.Env.EnvT"-#else-envTTyCon = mkTyCon3 "comonad-transformers" "Control.Comonad.Trans.Env" "EnvT"-#endif-{-# NOINLINE envTTyCon #-}--#if __GLASGOW_HASKELL__ < 707-instance (Typeable s, Typeable1 w, Typeable a) => Typeable (EnvT s w a) where-  typeOf = typeOfDefault-#endif--instance-  ( Data e-  , Typeable1 w, Data (w a)-  , Data a-  ) => Data (EnvT e w a) where-    gfoldl f z (EnvT e wa) = z EnvT `f` e `f` wa-    toConstr _ = envTConstr-    gunfold k z c = case constrIndex c of-        1 -> k (k (z EnvT))-        _ -> error "gunfold"-    dataTypeOf _ = envTDataType-    dataCast1 f = gcast1 f--envTConstr :: Constr-envTConstr = mkConstr envTDataType "EnvT" [] Prefix-{-# NOINLINE envTConstr #-}--envTDataType :: DataType-envTDataType = mkDataType "Control.Comonad.Trans.Env.EnvT" [envTConstr]-{-# NOINLINE envTDataType #-}--#endif--type Env e = EnvT e Identity-data EnvT e w a = EnvT e (w a)----- | Create an Env using an environment and a value-env :: e -> a -> Env e a-env e a = EnvT e (Identity a)--runEnv :: Env e a -> (e, a)-runEnv (EnvT e (Identity a)) = (e, a)--runEnvT :: EnvT e w a -> (e, w a)-runEnvT (EnvT e wa) = (e, wa)--instance Functor w => Functor (EnvT e w) where-  fmap g (EnvT e wa) = EnvT e (fmap g wa)--instance Extend w => Extend (EnvT e w) where-  duplicated (EnvT e wa) = EnvT e (extended (EnvT e) wa)--instance Comonad w => Comonad (EnvT e w) where-  duplicate (EnvT e wa) = EnvT e (extend (EnvT e) wa)-  extract (EnvT _ wa) = extract wa--instance ComonadTrans (EnvT e) where-  lower (EnvT _ wa) = wa---- | Gets rid of the environment. This differs from 'extract' in that it will---   not continue extracting the value from the contained comonad.-lowerEnvT :: EnvT e w a -> w a-lowerEnvT (EnvT _ wa) = wa--instance ComonadHoist (EnvT e) where-  cohoist (EnvT e wa) = EnvT e (Identity (extract wa))--instance (Semigroup e, Apply w) => Apply (EnvT e w) where-  EnvT ef wf <.> EnvT ea wa = EnvT (ef <> ea) (wf <.> wa)--instance (Semigroup e, ComonadApply w) => ComonadApply (EnvT e w) where-  EnvT ef wf <@> EnvT ea wa = EnvT (ef <> ea) (wf <@> wa)--instance Foldable w => Foldable (EnvT e w) where-  foldMap f (EnvT _ w) = foldMap f w--instance Traversable w => Traversable (EnvT e w) where-  traverse f (EnvT e w) = EnvT e <$> traverse f w---- | Retrieves the environment.-ask :: EnvT e w a -> e-ask (EnvT e _) = e---- | Like 'ask', but modifies the resulting value with a function.------   > asks = f . ask-asks :: (e -> f) -> EnvT e w a -> f-asks f (EnvT e _) = f e---- | Modifies the environment using the specified function.-local :: (e -> e') -> EnvT e w a -> EnvT e' w a-local f (EnvT e wa) = EnvT (f e) wa
− src/Control/Comonad/Trans/Identity.hs 
@@ -1,16 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Trans.Identity--- Copyright   :  (C) 2008-2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable---------------------------------------------------------------------------------module Control.Comonad.Trans.Identity-  ( IdentityT(..)-  ) where--import Control.Monad.Trans.Identity
− src/Control/Comonad/Trans/Store.hs 
@@ -1,201 +0,0 @@-{-# LANGUAGE CPP #-}-#if __GLASGOW_HASKELL__ >= 707-{-# LANGUAGE StandaloneDeriving, DeriveDataTypeable #-}-#endif-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Trans.Store--- Copyright   :  (C) 2008-2013 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable--------- The store comonad holds a constant value along with a modifiable /accessor/--- function, which maps the /stored value/ to the /focus/.------ This module defines the strict store (aka state-in-context/costate) comonad--- transformer.------ @stored value = (1, 5)@, @accessor = fst@, @resulting focus = 1@:------ > storeTuple :: Store (Int, Int) Int--- > storeTuple = store fst (1, 5)------ Add something to the focus:------ > addToFocus :: Int -> Store (Int, Int) Int -> Int--- > addToFocus x wa = x + extract wa--- >--- > added3 :: Store (Int, Int) Int--- > added3 = extend (addToFocus 3) storeTuple------ The focus of added3 is now @1 + 3 = 4@. However, this action changed only--- the accessor function and therefore the focus but not the stored value:------ >>> pos added3--- (1, 5)--- >>> extract added3--- 4------ The strict store (state-in-context/costate) comonad transformer is subject--- to the laws:------ > x = seek (pos x) x--- > y = pos (seek y x)--- > seek y x = seek y (seek z x)------ Thanks go to Russell O'Connor and Daniel Peebles for their help formulating--- and proving the laws for this comonad transformer.------------------------------------------------------------------------------module Control.Comonad.Trans.Store-  (-  -- * The Store comonad-    Store, store, runStore-  -- * The Store comonad transformer-  , StoreT(..), runStoreT-  -- * Operations-  , pos-  , seek, seeks-  , peek, peeks-  , experiment-  ) where--import Control.Applicative-import Control.Comonad-import Control.Comonad.Hoist.Class-import Control.Comonad.Trans.Class-import Data.Functor.Identity-import Data.Functor.Apply-import Data.Functor.Extend-import Data.Semigroup--#ifdef __GLASGOW_HASKELL__-import Data.Typeable--#if __GLASGOW_HASKELL__ >= 707-deriving instance Typeable StoreT-#else-instance (Typeable s, Typeable1 w) => Typeable1 (StoreT s w) where-  typeOf1 dswa = mkTyConApp storeTTyCon [typeOf (s dswa), typeOf1 (w dswa)]-    where-      s :: StoreT s w a -> s-      s = undefined-      w :: StoreT s w a -> w a-      w = undefined--instance (Typeable s, Typeable1 w, Typeable a) => Typeable (StoreT s w a) where-  typeOf = typeOfDefault--storeTTyCon :: TyCon-#if __GLASGOW_HASKELL__ < 704-storeTTyCon = mkTyCon "Control.Comonad.Trans.Store.StoreT"-#else-storeTTyCon = mkTyCon3 "comonad-transformers" "Control.Comonad.Trans.Store" "StoreT"-#endif-{-# NOINLINE storeTTyCon #-}-#endif--#endif--type Store s = StoreT s Identity---- | Create a Store using an accessor function and a stored value-store :: (s -> a) -> s -> Store s a-store f s = StoreT (Identity f) s--runStore :: Store s a -> (s -> a, s)-runStore (StoreT (Identity f) s) = (f, s)--data StoreT s w a = StoreT (w (s -> a)) s--runStoreT :: StoreT s w a -> (w (s -> a), s)-runStoreT (StoreT wf s) = (wf, s)--instance Functor w => Functor (StoreT s w) where-  fmap f (StoreT wf s) = StoreT (fmap (f .) wf) s--instance (Apply w, Semigroup s) => Apply (StoreT s w) where-  StoreT ff m <.> StoreT fa n = StoreT ((<*>) <$> ff <.> fa) (m <> n)--instance (ComonadApply w, Semigroup s) => ComonadApply (StoreT s w) where-  StoreT ff m <@> StoreT fa n = StoreT ((<*>) <$> ff <@> fa) (m <> n)--instance (Applicative w, Monoid s) => Applicative (StoreT s w) where-  pure a = StoreT (pure (const a)) mempty-  StoreT ff m <*> StoreT fa n = StoreT ((<*>) <$> ff <*> fa) (mappend m n)--instance Extend w => Extend (StoreT s w) where-  duplicated (StoreT wf s) = StoreT (extended StoreT wf) s-  extended f (StoreT wf s) = StoreT (extended (\wf' s' -> f (StoreT wf' s')) wf) s--instance Comonad w => Comonad (StoreT s w) where-  duplicate (StoreT wf s) = StoreT (extend StoreT wf) s-  extend f (StoreT wf s) = StoreT (extend (\wf' s' -> f (StoreT wf' s')) wf) s-  extract (StoreT wf s) = extract wf s--instance ComonadTrans (StoreT s) where-  lower (StoreT f s) = fmap ($ s) f--instance ComonadHoist (StoreT s) where-  cohoist (StoreT f s) = StoreT (Identity (extract f)) s---- | Read the stored value------ >>> pos $ store fst (1,5)--- (1,5)----pos :: StoreT s w a -> s-pos (StoreT _ s) = s---- | Set the stored value------ >>> pos . seek (3,7) $ store fst (1,5)--- (3,7)------ Seek satisfies the law------ > seek s = peek s . duplicate-seek :: s -> StoreT s w a -> StoreT s w a-seek s ~(StoreT f _) = StoreT f s---- | Modify the stored value------ >>> pos . seeks swap $ store fst (1,5)--- (5,1)------ Seeks satisfies the law------ > seeks f = peeks f . duplicate-seeks :: (s -> s) -> StoreT s w a -> StoreT s w a-seeks f ~(StoreT g s) = StoreT g (f s)---- | Peek at what the current focus would be for a different stored value------ Peek satisfies the law------ > peek x . extend (peek y) = peek y-peek :: Comonad w => s -> StoreT s w a -> a-peek s (StoreT g _) = extract g s----- | Peek at what the current focus would be if the stored value was---   modified by some function-peeks :: Comonad w => (s -> s) -> StoreT s w a -> a-peeks f ~(StoreT g s) = extract g (f s)---- | Applies a functor-valued function to the stored value, and then uses the---   new accessor to read the resulting focus.------   >>> let f x = if x > 0 then Just (x^2) else Nothing---   >>> experiment f $ store (+1) 2---   Just 5---   >>> experiment f $ store (+1) (-2)---   Nothing-experiment :: (Comonad w, Functor f) => (s -> f s) -> StoreT s w a -> f a-experiment f (StoreT wf s) = extract wf <$> f s
− src/Control/Comonad/Trans/Traced.hs 
@@ -1,127 +0,0 @@-{-# LANGUAGE CPP #-}-#if __GLASGOW_HASKELL__ >= 707-{-# LANGUAGE StandaloneDeriving, DeriveDataTypeable #-}-#endif-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Control.Comonad.Trans.Traced--- Copyright   :  (C) 2008-2013 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------ The trace comonad builds up a result by prepending monoidal values to each--- other.------ This module specifies the traced comonad transformer (aka the cowriter or--- exponential comonad transformer).---------------------------------------------------------------------------------module Control.Comonad.Trans.Traced-  (-  -- * Traced comonad-    Traced-  , traced-  , runTraced-  -- * Traced comonad transformer-  , TracedT(..)-  -- * Operations-  , trace-  , listen-  , listens-  , censor-  ) where--import Control.Applicative-import Control.Monad.Instances ()-import Control.Monad (ap)-import Control.Comonad-import Control.Comonad.Hoist.Class-import Control.Comonad.Trans.Class-import Data.Distributive-import Data.Functor.Apply-import Data.Functor.Extend-import Data.Functor.Identity-import Data.Semigroup-import Data.Typeable--type Traced m = TracedT m Identity--traced :: (m -> a) -> Traced m a-traced f = TracedT (Identity f)--runTraced :: Traced m a -> m -> a-runTraced (TracedT (Identity f)) = f--newtype TracedT m w a = TracedT { runTracedT :: w (m -> a) }--instance Functor w => Functor (TracedT m w) where-  fmap g = TracedT . fmap (g .) . runTracedT--instance Apply w => Apply (TracedT m w) where-  TracedT wf <.> TracedT wa = TracedT (ap <$> wf <.> wa)--instance (ComonadApply w, Monoid m) => ComonadApply (TracedT m w) where-  TracedT wf <@> TracedT wa = TracedT (ap <$> wf <@> wa)--instance Applicative w => Applicative (TracedT m w) where-  pure = TracedT . pure . const-  TracedT wf <*> TracedT wa = TracedT (ap <$> wf <*> wa)--instance (Extend w, Semigroup m) => Extend (TracedT m w) where-  extended f = TracedT . extended (\wf m -> f (TracedT (fmap (. (<>) m) wf))) . runTracedT--instance (Comonad w, Monoid m) => Comonad (TracedT m w) where-  extend f = TracedT . extend (\wf m -> f (TracedT (fmap (. mappend m) wf))) . runTracedT-  extract (TracedT wf) = extract wf mempty--instance Monoid m => ComonadTrans (TracedT m) where-  lower = fmap ($ mempty) . runTracedT--instance Monoid m => ComonadHoist (TracedT m) where-  cohoist = traced . extract . runTracedT--instance Distributive w => Distributive (TracedT m w) where-  distribute = TracedT . fmap (\tma m -> fmap ($ m) tma) . collect runTracedT--trace :: Comonad w => m -> TracedT m w a -> a-trace m (TracedT wf) = extract wf m--listen :: Functor w => TracedT m w a -> TracedT m w (a, m)-listen = TracedT . fmap (\f m -> (f m, m)) . runTracedT--listens :: Functor w => (m -> b) -> TracedT m w a -> TracedT m w (a, b)-listens g = TracedT . fmap (\f m -> (f m, g m)) . runTracedT--censor :: Functor w => (m -> m) -> TracedT m w a -> TracedT m w a-censor g = TracedT . fmap (. g) . runTracedT--#ifdef __GLASGOW_HASKELL__--#if __GLASGOW_HASKELL__ >= 707-deriving instance Typeable TracedT-#else-instance (Typeable s, Typeable1 w) => Typeable1 (TracedT s w) where-  typeOf1 dswa = mkTyConApp tracedTTyCon [typeOf (s dswa), typeOf1 (w dswa)]-    where-      s :: TracedT s w a -> s-      s = undefined-      w :: TracedT s w a -> w a-      w = undefined--tracedTTyCon :: TyCon-#if __GLASGOW_HASKELL__ < 704-tracedTTyCon = mkTyCon "Control.Comonad.Trans.Traced.TracedT"-#else-tracedTTyCon = mkTyCon3 "comonad-transformers" "Control.Comonad.Trans.Traced" "TracedT"-#endif-{-# NOINLINE tracedTTyCon #-}--#endif--#endif
− src/Data/Functor/Composition.hs 
@@ -1,14 +0,0 @@-module Data.Functor.Composition-  ( Composition(..) ) where--import Data.Functor.Compose---- | We often need to distinguish between various forms of Functor-like composition in Haskell in order to please the type system.--- This lets us work with these representations uniformly.-class Composition o where-  decompose :: o f g x -> f (g x)-  compose :: f (g x) -> o f g x--instance Composition Compose where-  decompose = getCompose-  compose = Compose
− src/Data/Functor/Coproduct.hs 
@@ -1,73 +0,0 @@-{-# LANGUAGE CPP #-}-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702-{-# LANGUAGE Trustworthy #-}-#endif--------------------------------------------------------------------------------- |--- Module      :  Data.Functor.Coproduct--- Copyright   :  (C) 2008-2011 Edward Kmett--- License     :  BSD-style (see the file LICENSE)------ Maintainer  :  Edward Kmett <ekmett@gmail.com>--- Stability   :  provisional--- Portability :  portable------------------------------------------------------------------------------module Data.Functor.Coproduct-  ( Coproduct(..)-  , left-  , right-  , coproduct-  ) where--import Control.Comonad-import Data.Functor.Contravariant-import Data.Functor.Extend-import Data.Foldable-import Data.Traversable-import Data.Semigroup.Foldable-import Data.Semigroup.Traversable--newtype Coproduct f g a = Coproduct { getCoproduct :: Either (f a) (g a) }-  deriving (Eq, Ord, Read, Show)--left :: f a -> Coproduct f g a-left = Coproduct . Left--right :: g a -> Coproduct f g a-right = Coproduct . Right--coproduct :: (f a -> b) -> (g a -> b) -> Coproduct f g a -> b-coproduct f g = either f g . getCoproduct--instance (Functor f, Functor g) => Functor (Coproduct f g) where-  fmap f = Coproduct . coproduct (Left . fmap f) (Right . fmap f)--instance (Foldable f, Foldable g) => Foldable (Coproduct f g) where-  foldMap f = coproduct (foldMap f) (foldMap f)--instance (Foldable1 f, Foldable1 g) => Foldable1 (Coproduct f g) where-  foldMap1 f = coproduct (foldMap1 f) (foldMap1 f)--instance (Traversable f, Traversable g) => Traversable (Coproduct f g) where-  traverse f = coproduct-    (fmap (Coproduct . Left) . traverse f)-    (fmap (Coproduct . Right) . traverse f)--instance (Traversable1 f, Traversable1 g) => Traversable1 (Coproduct f g) where-  traverse1 f = coproduct-    (fmap (Coproduct . Left) . traverse1 f)-    (fmap (Coproduct . Right) . traverse1 f)--instance (Extend f, Extend g) => Extend (Coproduct f g) where-  extended f = Coproduct . coproduct-    (Left . extended (f . Coproduct . Left))-    (Right . extended (f . Coproduct . Right))--instance (Comonad f, Comonad g) => Comonad (Coproduct f g) where-  extend f = Coproduct . coproduct-    (Left . extend (f . Coproduct . Left))-    (Right . extend (f . Coproduct . Right))-  extract = coproduct extract extract--instance (Contravariant f, Contravariant g) => Contravariant (Coproduct f g) where-  contramap f = Coproduct . coproduct (Left . contramap f) (Right . contramap f)