Fix issue with re-exports not resolving

Author: garyb

src/Control/Comonad/Env.purs

@@ -4,9 +4,10 @@ module Control.Comonad.Env where
 
 import Prelude
 
-import Control.Comonad.Env.Trans
-import Data.Identity
-import Data.Tuple
+import Control.Comonad.Env.Trans (EnvT(..), runEnvT, withEnvT)
+
+import Data.Identity (Identity(..), runIdentity)
+import Data.Tuple (Tuple(..))
 
 -- | The `Env` comonad is a synonym for the `EnvT` comonad transformer, applied
 -- | to the `Identity` monad.

src/Control/Comonad/Env/Class.purs

@@ -4,10 +4,10 @@ module Control.Comonad.Env.Class where
 
 import Prelude
 
-import Control.Comonad
-import Control.Comonad.Env.Trans
+import Control.Comonad (Comonad)
+import Control.Comonad.Env.Trans (EnvT(..), runEnvT)
 
-import Data.Tuple
+import Data.Tuple (Tuple(..), fst)
 
 -- | The `ComonadEnv` type class represents those monads which support a global environment via
 -- | `ask` and `local`.

src/Control/Comonad/Env/Trans.purs

@@ -4,10 +4,11 @@ module Control.Comonad.Env.Trans where
 
 import Prelude
 
-import Control.Comonad
-import Control.Comonad.Trans
-import Control.Extend
-import Data.Tuple
+import Control.Comonad (Comonad, extract)
+import Control.Comonad.Trans (ComonadTrans)
+import Control.Extend (Extend, (<<=))
+
+import Data.Tuple (Tuple(..))
 
 -- | The environment comonad transformer.
 -- |

src/Control/Comonad/Store.purs

@@ -4,9 +4,10 @@ module Control.Comonad.Store where
 
 import Prelude
 
-import Control.Comonad.Store.Trans
-import Data.Identity
-import Data.Tuple
+import Control.Comonad.Store.Trans (StoreT(..), runStoreT)
+
+import Data.Identity (Identity(..), runIdentity)
+import Data.Tuple (Tuple(..), swap)
 
 -- | The `Store` comonad is a synonym for the `StoreT` comonad transformer, applied
 -- | to the `Identity` monad.

src/Control/Comonad/Store/Class.purs

@@ -4,11 +4,11 @@ module Control.Comonad.Store.Class where
 
 import Prelude
 
-import Control.Comonad
-import Control.Comonad.Store.Trans
-import Control.Extend
+import Control.Comonad (Comonad, extract)
+import Control.Comonad.Store.Trans (StoreT(..))
+import Control.Extend (Extend, duplicate)
 
-import Data.Tuple
+import Data.Tuple (Tuple(..))
 
 -- | The `ComonadStore` type class represents those monads which support local position information via
 -- | `pos` and `peek`.
@@ -51,4 +51,4 @@ seeks f x = peeks f $ duplicate x
 
 instance comonadStoreStoreT :: (Comonad w) => ComonadStore s (StoreT s w) where
   pos (StoreT (Tuple f s)) = s
-  peek s (StoreT (Tuple f _)) = extract f s
+  peek s (StoreT (Tuple f _)) = extract f s

src/Control/Comonad/Store/Trans.purs

@@ -4,11 +4,11 @@ module Control.Comonad.Store.Trans where
 
 import Prelude
 
-import Control.Extend
-import Control.Comonad
-import Control.Comonad.Trans
+import Control.Comonad (Comonad, extract)
+import Control.Comonad.Trans (ComonadTrans)
+import Control.Extend (Extend, (<<=))
 
-import Data.Tuple
+import Data.Tuple (Tuple(..))
 
 -- | The store comonad transformer.
 -- |

src/Control/Comonad/Traced.purs

@@ -4,8 +4,9 @@ module Control.Comonad.Traced where
 
 import Prelude
 
-import Control.Comonad.Traced.Trans
-import Data.Identity
+import Control.Comonad.Traced.Trans (TracedT(..), runTracedT)
+
+import Data.Identity (Identity(..), runIdentity)
 
 -- | The `Traced` comonad is a synonym for the `TracedT` comonad transformer, applied
 -- | to the `Identity` monad.

src/Control/Comonad/Traced/Class.purs

@@ -4,11 +4,11 @@ module Control.Comonad.Traced.Class where
 
 import Prelude
 
-import Control.Comonad
-import Control.Comonad.Traced.Trans
+import Control.Comonad (Comonad, extract)
+import Control.Comonad.Traced.Trans (TracedT(..), runTracedT)
 
-import Data.Monoid
-import Data.Tuple
+import Data.Monoid (Monoid)
+import Data.Tuple (Tuple(..))
 
 -- | The `ComonadTraced` type class represents those monads which support relative (monoidal)
 -- | position information via `track`.

src/Control/Comonad/Traced/Trans.purs

@@ -4,11 +4,11 @@ module Control.Comonad.Traced.Trans where
 
 import Prelude
 
-import Control.Comonad
-import Control.Comonad.Trans
-import Control.Extend
+import Control.Comonad (Comonad, extract)
+import Control.Comonad.Trans (ComonadTrans)
+import Control.Extend (Extend, (<<=))
 
-import Data.Monoid
+import Data.Monoid (Monoid, mempty)
 
 -- | The cowriter comonad transformer.
 -- |

src/Control/Comonad/Trans.purs

@@ -4,7 +4,7 @@ module Control.Comonad.Trans where
 
 import Prelude
 
-import Control.Comonad
+import Control.Comonad (Comonad)
 
 -- | The `ComonadTrans` type class represents _comonad transformers_.
 -- |
@@ -14,7 +14,7 @@ import Control.Comonad
 -- | This allows us to extend a comonad to provide additional context. By iterating this
 -- | process, we create comonad transformer _stacks_, which contain all of the contextual information
 -- | required for a particular computation.
--- | 
+-- |
 -- | The laws state that `lower` is a `Comonad` morphism.
 -- |
 -- | Laws:

src/Control/Monad/Cont/Trans.purs

@@ -1,18 +1,18 @@
 -- | This module defines the CPS monad transformer.
 
-module Control.Monad.Cont.Trans 
+module Control.Monad.Cont.Trans
   ( ContT(..), runContT, mapContT, withContT
   , module Control.Monad.Trans
   , module Control.Monad.Cont.Class
   ) where
 
 import Prelude
 
-import Control.Monad.Trans
-import Control.Monad.Eff.Class
+import Control.Monad.Trans (MonadTrans, lift)
+import Control.Monad.Eff.Class (MonadEff, liftEff)
 import Control.Monad.Cont.Class
-import Control.Monad.Reader.Class
-import Control.Monad.State.Class
+import Control.Monad.Reader.Class (MonadReader, ask, local)
+import Control.Monad.State.Class (MonadState, state)
 
 -- | The CPS monad transformer.
 -- |
@@ -53,12 +53,12 @@ instance monadTransContT :: MonadTrans (ContT r) where
 
 instance monadEffContT :: (MonadEff eff m) => MonadEff eff (ContT r m) where
   liftEff = lift <<< liftEff
-  
+
 instance monadReaderContT :: (MonadReader r1 m) => MonadReader r1 (ContT r m) where
   ask = lift ask
   local f c = ContT \k -> do
     r <- ask
     local f (runContT c (local (const (r :: r1)) <<< k))
-    
+
 instance monadStateContT :: (MonadState s m) => MonadState s (ContT r m) where
-  state = lift <<< state
+  state = lift <<< state

src/Control/Monad/Error/Class.purs

@@ -4,8 +4,8 @@ module Control.Monad.Error.Class where
 
 import Prelude
 
-import Data.Maybe
-import Data.Either
+import Data.Maybe (Maybe(..))
+import Data.Either (Either(..))
 
 -- | The `MonadError` type class represents those monads which support errors via
 -- | `throwError` and `catchError`.
@@ -22,7 +22,7 @@ import Data.Either
 -- | - Left zero: `throwError e >>= f = throwError e`
 -- | - Catch: `catchError (throwError e) f = f e`
 -- | - Pure: `catchError (pure a) f = pure a`
--- | 
+-- |
 class (Monad m) <= MonadError e m where
   throwError :: forall a. e -> m a
   catchError :: forall a. m a -> (e -> m a) -> m a

src/Control/Monad/Except.purs

@@ -10,10 +10,11 @@ module Control.Monad.Except
 
 import Prelude
 
-import Data.Either
-import Data.Identity
-import Control.Monad.Except.Trans
 import Control.Monad.Error.Class
+import Control.Monad.Except.Trans (ExceptT(..), withExceptT, runExceptT, mapExceptT)
+
+import Data.Either (Either())
+import Data.Identity (Identity(..), runIdentity)
 
 -- | A parametrizable exception monad; computations are either exceptions or
 -- | pure values. If an exception is thrown (see `throwError`), the computation

src/Control/Monad/Except/Trans.purs

@@ -14,12 +14,15 @@ import Data.Monoid (Monoid, mempty)
 
 import Control.Alt (Alt)
 import Control.Alternative (Alternative)
-import Control.Monad.Rec.Class (MonadRec, tailRecM)
+import Control.Monad.Cont.Class (MonadCont, callCC)
 import Control.Monad.Eff.Class (MonadEff, liftEff)
 import Control.Monad.Error.Class (MonadError, throwError, catchError)
-import Control.Monad.Cont.Class (MonadCont, callCC)
-import Control.Monad.RWS.Class
-import Control.Monad.Trans
+import Control.Monad.Reader.Class (MonadReader, ask, local)
+import Control.Monad.Rec.Class (MonadRec, tailRecM)
+import Control.Monad.RWS.Class (MonadRWS)
+import Control.Monad.State.Class (MonadState, state)
+import Control.Monad.Trans (MonadTrans, lift)
+import Control.Monad.Writer.Class (MonadWriter, writer, listen, pass)
 import Control.MonadPlus (MonadPlus)
 import Control.Plus (Plus)
 

src/Control/Monad/List/Trans.purs

@@ -32,12 +32,14 @@ module Control.Monad.List.Trans
   ) where
 
 import Prelude
+
 import Control.Alt (Alt)
 import Control.Alternative (Alternative)
+import Control.Monad.Eff.Class (MonadEff, liftEff)
 import Control.Monad.Trans (MonadTrans, lift)
 import Control.MonadPlus (MonadPlus)
-import Control.Monad.Eff.Class
 import Control.Plus (Plus)
+
 import Data.Lazy (Lazy(), defer, force)
 import Data.Maybe (Maybe(..), fromMaybe)
 import Data.Monoid (Monoid)

src/Control/Monad/Maybe/Trans.purs

@@ -7,21 +7,24 @@ module Control.Monad.Maybe.Trans
 
 import Prelude
 
-import Data.Either
-import Data.Maybe
-import Data.Tuple
-import Data.Monoid
-
-import Control.Alt
-import Control.Alternative
-import Control.Monad.Trans
-import Control.Monad.Rec.Class
-import Control.Monad.Eff.Class
-import Control.Monad.Cont.Class
-import Control.Monad.Error.Class
-import Control.Monad.RWS.Class
-import Control.MonadPlus
-import Control.Plus
+import Data.Either (Either(..))
+import Data.Maybe (Maybe(..))
+import Data.Tuple (Tuple(..))
+import Data.Monoid (Monoid)
+
+import Control.Alt (Alt)
+import Control.Alternative (Alternative)
+import Control.Monad.Cont.Class (MonadCont, callCC)
+import Control.Monad.Eff.Class (MonadEff, liftEff)
+import Control.Monad.Error.Class (MonadError, throwError, catchError)
+import Control.Monad.Reader.Class (MonadReader, ask, local)
+import Control.Monad.Rec.Class (MonadRec, tailRecM)
+import Control.Monad.RWS.Class (MonadRWS)
+import Control.Monad.State.Class (MonadState, state)
+import Control.Monad.Trans (MonadTrans, lift)
+import Control.Monad.Writer.Class (MonadWriter, writer, listen, pass)
+import Control.MonadPlus (MonadPlus)
+import Control.Plus (Plus)
 
 -- | The `MaybeT` monad transformer.
 -- |

src/Control/Monad/RWS.purs

@@ -13,11 +13,11 @@ module Control.Monad.RWS
 
 import Prelude
 
-import Data.Identity
-import Data.Tuple
-
 import Control.Monad.RWS.Class
-import Control.Monad.RWS.Trans
+import Control.Monad.RWS.Trans (RWST(..), RWSResult(), runRWST, mapRWST, withRWST, execRWST, evalRWST)
+
+import Data.Identity (Identity(..), runIdentity)
+import Data.Tuple (Tuple())
 
 -- | The `RWS` monad is a synonym for the `RWST` monad transformer, applied
 -- | to the `Identity` monad.

src/Control/Monad/RWS/Class.purs

@@ -1,6 +1,6 @@
 -- | This module defines the `MonadRWS` type class and its instances.
 
-module Control.Monad.RWS.Class 
+module Control.Monad.RWS.Class
   ( MonadRWS
   , module Control.Monad.Trans
   , module Control.Monad.Reader.Class
@@ -17,7 +17,7 @@ import Control.Monad.Reader.Class
 import Control.Monad.State.Class
 import Control.Monad.Writer.Class
 
--- | `MonadRWS r w s` combines the operations and laws of the `MonadReader r`, 
+-- | `MonadRWS r w s` combines the operations and laws of the `MonadReader r`,
 -- | `MonadWriter w` and `MonadState s` type classes.
 -- |
 -- | An implementation is provided for `RWST`, and for other monad transformers

src/Control/Monad/RWS/Trans.purs

@@ -9,15 +9,18 @@ module Control.Monad.RWS.Trans
 
 import Prelude
 
-import Data.Either
-import Data.Monoid
-import Data.Tuple
-
-import Control.Monad.Eff.Class
-import Control.Monad.Error.Class
+import Data.Either (Either(..))
+import Data.Monoid (Monoid, mempty)
+import Data.Tuple (Tuple(..), uncurry)
+
+import Control.Monad.Eff.Class (MonadEff, liftEff)
+import Control.Monad.Error.Class (MonadError, throwError, catchError)
+import Control.Monad.Reader.Class (MonadReader)
+import Control.Monad.Rec.Class (MonadRec, tailRecM)
 import Control.Monad.RWS.Class
-import Control.Monad.Rec.Class
-import Control.Monad.Trans
+import Control.Monad.State.Class (MonadState)
+import Control.Monad.Trans (MonadTrans, lift)
+import Control.Monad.Writer.Class (MonadWriter)
 
 data RWSResult state result writer = RWSResult state result writer
 

src/Control/Monad/Reader.purs

@@ -10,10 +10,10 @@ module Control.Monad.Reader
 
 import Prelude
 
-import Data.Identity
-
 import Control.Monad.Reader.Class
-import Control.Monad.Reader.Trans
+import Control.Monad.Reader.Trans (ReaderT(), runReaderT, mapReaderT, withReaderT)
+
+import Data.Identity (Identity(..), runIdentity)
 
 -- | The `Reader` monad is a synonym for the `ReaderT` monad transformer, applied
 -- | to the `Identity` monad.