-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Execute arbitrary actions for each unread element of RSS/Atom feeds
--   
--   Cf README file
@package imm
@version 1.3.0.0

module Imm.Prelude
type LByteString = ByteString
type ByteString = ByteString
type LText = Text
type Text = Text

-- | Shortcut to <a>liftIO</a>
io :: MonadIO m => IO a -> m a

-- | Generic <a>show</a>
show :: (Show a, IsString b) => a -> b


-- | Logger module.
module Imm.Logger
data LogLevel
Debug :: LogLevel
Info :: LogLevel
Warning :: LogLevel
Error :: LogLevel

-- | Monad capable of logging pretty text.
class Monad m => MonadLog m
log :: MonadLog m => LogLevel -> Doc AnsiStyle -> m ()
getLogLevel :: MonadLog m => m LogLevel
setLogLevel :: MonadLog m => LogLevel -> m ()
setColorizeLogs :: MonadLog m => Bool -> m ()
flushLogs :: MonadLog m => m ()
logDebug :: MonadLog m => Doc AnsiStyle -> m ()
logInfo :: MonadLog m => Doc AnsiStyle -> m ()
logWarning :: MonadLog m => Doc AnsiStyle -> m ()
logError :: MonadLog m => Doc AnsiStyle -> m ()
instance GHC.Show.Show Imm.Logger.LogLevel
instance GHC.Read.Read Imm.Logger.LogLevel
instance GHC.Classes.Ord Imm.Logger.LogLevel
instance GHC.Classes.Eq Imm.Logger.LogLevel
instance Data.Text.Prettyprint.Doc.Internal.Pretty Imm.Logger.LogLevel


-- | Implementation of <a>Imm.Logger</a> based on <tt>fast-logger</tt>. For
--   further information, please consult <a>System.Log.FastLogger</a>.
module Imm.Logger.Simple
data LoggerSettings
LoggerSettings :: LoggerSet -> LoggerSet -> LogLevel -> Bool -> LoggerSettings

-- | <a>LoggerSet</a> used for <a>Debug</a>, <a>Info</a> and <a>Warning</a>
--   logs
[_loggerSet] :: LoggerSettings -> LoggerSet

-- | <a>LoggerSet</a> used for <a>Error</a> logs
[_errorLoggerSet] :: LoggerSettings -> LoggerSet

-- | Discard logs that are strictly less serious than this level
[_logLevel] :: LoggerSettings -> LogLevel

-- | Enable log colorisation
[_colorizeLogs] :: LoggerSettings -> Bool

-- | Default logger forwards error messages to stderr, and other messages
--   to stdout.
defaultLogger :: IO (MVar LoggerSettings)
instance Imm.Logger.MonadLog (Control.Monad.Trans.Reader.ReaderT (GHC.MVar.MVar Imm.Logger.Simple.LoggerSettings) GHC.Types.IO)


-- | HTTP module abstracts over HTTP requests to the external world.
module Imm.HTTP

-- | Monad capable of performing GET HTTP requests.
class MonadThrow m => MonadHttpClient m
httpGet :: MonadHttpClient m => URI -> m LByteString

-- | Simple wrapper around <a>httpGet</a> that also logs the requested URI.
get :: (MonadHttpClient m, MonadLog m, MonadThrow m) => URI -> m LByteString


-- | Implementation of <a>Imm.HTTP</a> based on <a>Network.HTTP.Client</a>.
module Imm.HTTP.Simple

-- | Default manager uses TLS and no proxy
defaultManager :: IO Manager
instance Imm.HTTP.MonadHttpClient (Control.Monad.Trans.Reader.ReaderT Network.HTTP.Client.Types.Manager GHC.Types.IO)


-- | Helpers to manipulate feeds
module Imm.Feed

-- | Feed reference: either its URI, or its UID from database
data FeedRef
ByUID :: Int -> FeedRef
ByURI :: URI -> FeedRef
data Feed
Rss :: (RssDocument '[ContentModule, DublinCoreModule]) -> Feed
Atom :: AtomFeed -> Feed
data FeedElement
RssElement :: (RssItem '[ContentModule, DublinCoreModule]) -> FeedElement
AtomElement :: AtomEntry -> FeedElement
getFeedTitle :: Feed -> Text
getElements :: Feed -> [FeedElement]
getDate :: FeedElement -> Maybe UTCTime
getTitle :: FeedElement -> Text
getContent :: FeedElement -> Text
getHashes :: FeedElement -> [Int]
prettyElement :: FeedElement -> Doc a
instance GHC.Show.Show Imm.Feed.FeedElement
instance GHC.Classes.Eq Imm.Feed.FeedElement
instance GHC.Show.Show Imm.Feed.Feed
instance GHC.Classes.Eq Imm.Feed.Feed
instance GHC.Show.Show Imm.Feed.FeedRef
instance GHC.Classes.Eq Imm.Feed.FeedRef
instance Data.Text.Prettyprint.Doc.Internal.Pretty Imm.Feed.FeedRef


-- | Hooks module to define the main behavior of the program.
module Imm.Hooks

-- | Monad capable of acting on specific events.
class Monad m => MonadImm m

-- | Action triggered for each unread feed element
processNewElement :: MonadImm m => Feed -> FeedElement -> m ()
onNewElement :: (MonadImm m, MonadLog m) => Feed -> FeedElement -> m ()


-- | Implementation of <a>Imm.Hooks</a> that writes a file for each new
--   RSS/Atom item.
module Imm.Hooks.WriteFile

-- | Where and what to write in a file
data FileInfo
FileInfo :: FilePath -> Builder -> FileInfo
newtype WriteFileSettings
WriteFileSettings :: (Feed -> FeedElement -> FileInfo) -> WriteFileSettings

-- | Wrapper around <a>defaultFilePath</a> and <a>defaultFileContent</a>
defaultSettings :: FilePath -> WriteFileSettings

-- | Generate a path
--   <tt><a>root</a><i><a>title</a></i><a>date</a>-<a>title</a>.html</tt>,
--   where <tt><a>root</a></tt> is the first argument
defaultFilePath :: FilePath -> Feed -> FeedElement -> FilePath

-- | Generate an HTML page, with a title, a header and an article that
--   contains the feed element
defaultFileContent :: Feed -> FeedElement -> Builder
defaultArticleTitle :: Feed -> FeedElement -> Html
defaultArticleAuthor :: Feed -> FeedElement -> Html
defaultArticleDate :: Feed -> FeedElement -> Html

-- | Generate the HTML content for a given feed element
defaultBody :: Feed -> FeedElement -> Html
convertAtomURI :: (IsString t) => AtomURI -> t
convertURI :: (IsString t) => URIRef a -> t
convertText :: (IsString t) => Text -> t
convertDoc :: (IsString t) => Doc a -> t
instance Imm.Hooks.MonadImm (Control.Monad.Trans.Reader.ReaderT Imm.Hooks.WriteFile.WriteFileSettings GHC.Types.IO)


-- | Implementation of <a>Imm.Hooks</a> that sends a mail via a SMTP server
--   for each new RSS/Atom element. You may want to check out
--   <a>Network.HaskellNet.SMTP</a>, <a>Network.HaskellNet.SMTP.SSL</a> and
--   <a>Network.Mail.Mime</a> modules for additional information.
--   
--   Here is an example configuration:
--   
--   <pre>
--   sendmail :: SendMailSettings
--   sendmail = SendMailSettings smtpServer formatMail
--   
--   formatMail :: FormatMail
--   formatMail = FormatMail
--     (\a b -&gt; (defaultFormatFrom a b) { addressEmail = "user@host" } )
--     defaultFormatSubject
--     defaultFormatBody
--     (\_ _ -&gt; [Address Nothing "user@host"])
--   
--   smtpServer :: Feed -&gt; FeedElement -&gt; SMTPServer
--   smtpServer _ _ = SMTPServer
--     (Just $ Authentication PLAIN "user" "password")
--     (StartTls "smtp.server" defaultSettingsSMTPSTARTTLS)
--   </pre>
module Imm.Hooks.SendMail
type Username = String
type Password = String
type ServerName = String

-- | How to connect to the SMTP server
data ConnectionSettings
Plain :: ServerName -> PortNumber -> ConnectionSettings
Ssl :: ServerName -> Settings -> ConnectionSettings
StartTls :: ServerName -> Settings -> ConnectionSettings

-- | How to authenticate to the SMTP server
data Authentication
Authentication :: AuthType -> Username -> Password -> Authentication
data SMTPServer
SMTPServer :: (Maybe Authentication) -> ConnectionSettings -> SMTPServer

-- | How to format outgoing mails from feed elements
data FormatMail
FormatMail :: (Feed -> FeedElement -> Address) -> (Feed -> FeedElement -> Text) -> (Feed -> FeedElement -> Text) -> (Feed -> FeedElement -> [Address]) -> FormatMail

-- | How to write the From: header of feed mails
[formatFrom] :: FormatMail -> Feed -> FeedElement -> Address

-- | How to write the Subject: header of feed mails
[formatSubject] :: FormatMail -> Feed -> FeedElement -> Text

-- | How to write the body of feed mails (sic!)
[formatBody] :: FormatMail -> Feed -> FeedElement -> Text

-- | How to write the To: header of feed mails
[formatTo] :: FormatMail -> Feed -> FeedElement -> [Address]
data SendMailSettings
SendMailSettings :: (Feed -> FeedElement -> SMTPServer) -> FormatMail -> SendMailSettings

-- | Fill <a>addressName</a> with the feed title and, if available, the
--   authors' names.
--   
--   This function leaves <a>addressEmail</a> empty. You are expected to
--   fill it adequately, because many SMTP servers enforce constraints on
--   the From: email.
defaultFormatFrom :: Feed -> FeedElement -> Address

-- | Fill mail subject with the element title
defaultFormatSubject :: Feed -> FeedElement -> Text

-- | Fill mail body with:
--   
--   <ul>
--   <li>a list of links associated to the element</li>
--   <li>the element's content or description/summary</li>
--   </ul>
defaultFormatBody :: Feed -> FeedElement -> Text
authenticate_ :: SMTPConnection -> Authentication -> IO Bool
withSMTPConnection :: SMTPServer -> (SMTPConnection -> IO a) -> IO a

-- | Build mail from a given feed
buildMail :: FormatMail -> UTCTime -> TimeZone -> Feed -> FeedElement -> Mail
instance GHC.Show.Show Imm.Hooks.SendMail.SMTPServer
instance GHC.Classes.Eq Imm.Hooks.SendMail.SMTPServer
instance GHC.Show.Show Imm.Hooks.SendMail.Authentication
instance GHC.Classes.Eq Imm.Hooks.SendMail.Authentication
instance GHC.Show.Show Imm.Hooks.SendMail.ConnectionSettings
instance GHC.Classes.Eq Imm.Hooks.SendMail.ConnectionSettings
instance Imm.Hooks.MonadImm (Control.Monad.Trans.Reader.ReaderT Imm.Hooks.SendMail.SendMailSettings GHC.Types.IO)


-- | Implementation of <a>Imm.Hooks</a> that does nothing, except
--   suggesting the user to define proper hooks.
--   
--   This is the default implementation of the program.
module Imm.Hooks.Dummy
data DummyHooks
DummyHooks :: DummyHooks
instance Imm.Hooks.MonadImm (Control.Monad.Trans.Reader.ReaderT Imm.Hooks.Dummy.DummyHooks GHC.Types.IO)


-- | Database module abstracts over a key-value database that supports CRUD
--   operations.
module Imm.Database

-- | Generic database table
class (Ord (Key t), Show (Key t), Show (Entry t), Typeable t, Show t, Pretty t, Pretty (Key t)) => Table t where {
    type family Key t :: *;
    type family Entry t :: *;
}

-- | Monad capable of interacting with a key-value store.
class MonadThrow m => MonadDatabase t m
_describeDatabase :: MonadDatabase t m => t -> m (Doc a)
_fetchList :: MonadDatabase t m => t -> [Key t] -> m (Map (Key t) (Entry t))
_fetchAll :: MonadDatabase t m => t -> m (Map (Key t) (Entry t))
_update :: MonadDatabase t m => t -> Key t -> (Entry t -> Entry t) -> m ()
_insertList :: MonadDatabase t m => t -> [(Key t, Entry t)] -> m ()
_deleteList :: MonadDatabase t m => t -> [Key t] -> m ()
_purge :: MonadDatabase t m => t -> m ()
_commit :: MonadDatabase t m => t -> m ()
data DatabaseException t
NotCommitted :: t -> DatabaseException t
NotDeleted :: t -> [Key t] -> DatabaseException t
NotFound :: t -> [Key t] -> DatabaseException t
NotInserted :: t -> [(Key t, Entry t)] -> DatabaseException t
NotPurged :: t -> DatabaseException t
NotUpdated :: t -> (Key t) -> DatabaseException t
UnableFetchAll :: t -> DatabaseException t
fetch :: (MonadDatabase t m, Table t, MonadThrow m) => t -> Key t -> m (Entry t)
fetchList :: (MonadDatabase t m, MonadThrow m) => t -> [Key t] -> m (Map (Key t) (Entry t))
fetchAll :: (MonadThrow m, MonadDatabase t m) => t -> m (Map (Key t) (Entry t))
update :: (MonadDatabase t m, MonadThrow m) => t -> Key t -> (Entry t -> Entry t) -> m ()
insert :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> Key t -> Entry t -> m ()
insertList :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> [(Key t, Entry t)] -> m ()
delete :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> Key t -> m ()
deleteList :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> [Key t] -> m ()
purge :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> m ()
commit :: (MonadThrow m, MonadDatabase t m, MonadLog m) => t -> m ()
instance (GHC.Classes.Eq t, GHC.Classes.Eq (Imm.Database.Key t), GHC.Classes.Eq (Imm.Database.Entry t)) => GHC.Classes.Eq (Imm.Database.DatabaseException t)
instance (GHC.Show.Show t, GHC.Show.Show (Imm.Database.Key t), GHC.Show.Show (Imm.Database.Entry t)) => GHC.Show.Show (Imm.Database.DatabaseException t)
instance (Imm.Database.Table t, GHC.Show.Show (Imm.Database.Key t), GHC.Show.Show (Imm.Database.Entry t), Data.Text.Prettyprint.Doc.Internal.Pretty (Imm.Database.Key t), Data.Typeable.Internal.Typeable t) => GHC.Exception.Exception (Imm.Database.DatabaseException t)
instance (Data.Text.Prettyprint.Doc.Internal.Pretty t, Data.Text.Prettyprint.Doc.Internal.Pretty (Imm.Database.Key t)) => Data.Text.Prettyprint.Doc.Internal.Pretty (Imm.Database.DatabaseException t)


-- | Feed table definitions. This is a specialization of
--   <a>Imm.Database</a>.
module Imm.Database.FeedTable

-- | Unique key in feeds table
newtype FeedID
FeedID :: URI -> FeedID
prettyFeedID :: FeedID -> Doc AnsiStyle
data DatabaseEntry
DatabaseEntry :: URI -> Set Text -> Set Int -> Maybe UTCTime -> DatabaseEntry
[entryURI] :: DatabaseEntry -> URI
[entryTags] :: DatabaseEntry -> Set Text
[entryReadHashes] :: DatabaseEntry -> Set Int
[entryLastCheck] :: DatabaseEntry -> Maybe UTCTime
prettyDatabaseEntry :: DatabaseEntry -> Doc AnsiStyle
newDatabaseEntry :: FeedID -> Set Text -> DatabaseEntry

-- | Singleton type to represent feeds table
data FeedTable
FeedTable :: FeedTable
data FeedStatus
Unknown :: FeedStatus
New :: FeedStatus
LastUpdate :: UTCTime -> FeedStatus
newtype Database
Database :: [DatabaseEntry] -> Database
register :: (MonadThrow m, MonadLog m, MonadDatabase FeedTable m) => FeedID -> Set Text -> m ()
getStatus :: (MonadDatabase FeedTable m, MonadCatch m) => FeedID -> m FeedStatus
addReadHash :: (MonadDatabase FeedTable m, MonadThrow m, MonadLog m) => FeedID -> Int -> m ()

-- | Set the last check time to now
markAsRead :: (MonadTime m, MonadDatabase FeedTable m, MonadThrow m, MonadLog m) => FeedID -> m ()

-- | Unset feed's last update and remove all read hashes
markAsUnread :: (MonadDatabase FeedTable m, MonadThrow m, MonadLog m) => FeedID -> m ()
instance GHC.Show.Show Imm.Database.FeedTable.Database
instance GHC.Classes.Eq Imm.Database.FeedTable.Database
instance GHC.Show.Show Imm.Database.FeedTable.FeedTable
instance GHC.Show.Show Imm.Database.FeedTable.DatabaseEntry
instance GHC.Classes.Eq Imm.Database.FeedTable.DatabaseEntry
instance GHC.Show.Show Imm.Database.FeedTable.FeedID
instance GHC.Classes.Ord Imm.Database.FeedTable.FeedID
instance GHC.Classes.Eq Imm.Database.FeedTable.FeedID
instance Data.Text.Prettyprint.Doc.Internal.Pretty Imm.Database.FeedTable.FeedStatus
instance Data.Text.Prettyprint.Doc.Internal.Pretty Imm.Database.FeedTable.FeedTable
instance Imm.Database.Table Imm.Database.FeedTable.FeedTable
instance Data.Aeson.Types.FromJSON.FromJSON Imm.Database.FeedTable.DatabaseEntry
instance Data.Aeson.Types.ToJSON.ToJSON Imm.Database.FeedTable.DatabaseEntry
instance Data.Aeson.Types.FromJSON.FromJSON Imm.Database.FeedTable.FeedID
instance Data.Aeson.Types.ToJSON.ToJSON Imm.Database.FeedTable.FeedID
instance Data.Text.Prettyprint.Doc.Internal.Pretty Imm.Database.FeedTable.FeedID


-- | Implementation of <a>Imm.Database</a> based on a JSON file.
module Imm.Database.JsonFile
data JsonFileDatabase t
mkJsonFileDatabase :: (Table t) => FilePath -> JsonFileDatabase t

-- | Default database is stored in <tt>$XDG_CONFIG_HOME/imm/feeds.json</tt>
defaultDatabase :: Table t => IO (MVar (JsonFileDatabase t))
data JsonException
UnableDecode :: JsonException
instance GHC.Show.Show Imm.Database.JsonFile.JsonException
instance GHC.Classes.Eq Imm.Database.JsonFile.JsonException
instance GHC.Show.Show Imm.Database.JsonFile.CacheStatus
instance GHC.Classes.Eq Imm.Database.JsonFile.CacheStatus
instance GHC.Exception.Exception Imm.Database.JsonFile.JsonException
instance Data.Text.Prettyprint.Doc.Internal.Pretty (Imm.Database.JsonFile.JsonFileDatabase t)
instance (Imm.Database.Table t, Data.Aeson.Types.FromJSON.FromJSON (Imm.Database.Key t), Data.Aeson.Types.FromJSON.FromJSON (Imm.Database.Entry t), Data.Aeson.Types.ToJSON.ToJSON (Imm.Database.Key t), Data.Aeson.Types.ToJSON.ToJSON (Imm.Database.Entry t)) => Imm.Database.MonadDatabase t (Control.Monad.Trans.Reader.ReaderT (GHC.MVar.MVar (Imm.Database.JsonFile.JsonFileDatabase t)) GHC.Types.IO)


-- | XML module abstracts over the parsing of RSS/Atom feeds.
module Imm.XML

-- | Monad capable of parsing XML into a <a>Feed</a> (RSS or Atom).
class MonadThrow m => MonadXmlParser m
parseXml :: MonadXmlParser m => URI -> LByteString -> m Feed


-- | Implementation of <a>Imm.XML</a> based on <a>Conduit</a>.
module Imm.XML.Conduit

-- | A pre-process <a>Conduit</a> can be set to alter the raw XML before
--   feeding it to the parser, depending on the feed <a>URI</a>
newtype XmlParser
XmlParser :: (forall m. Monad m => URI -> ConduitT Event Event m ()) -> XmlParser

-- | <a>Conduit</a> based implementation

-- | Forward all <a>Event</a>s without any pre-process
defaultXmlParser :: XmlParser
instance (Control.Monad.IO.Class.MonadIO m, Control.Monad.Catch.MonadCatch m) => Imm.XML.MonadXmlParser (Control.Monad.Trans.Reader.ReaderT Imm.XML.Conduit.XmlParser m)

module Imm.Core

-- | Feed reference: either its URI, or its UID from database
data FeedRef
printVersions :: (MonadBase IO m) => m ()

-- | Register the given feed URI in database
subscribe :: (MonadLog m, MonadDatabase FeedTable m, MonadCatch m) => URI -> Set Text -> m ()

-- | Print database status for given feed(s)
showFeed :: (MonadLog m, MonadThrow m, MonadDatabase FeedTable m) => [FeedID] -> m ()

-- | Check for unread elements without processing them
check :: (MonadAsync m, MonadCatch m, MonadLog m, MonadDatabase FeedTable m, MonadHttpClient m, MonadXmlParser m) => [FeedID] -> m ()
run :: (MonadTime m, MonadAsync m, MonadCatch m, MonadImm m, MonadLog m, MonadDatabase FeedTable m, MonadHttpClient m, MonadXmlParser m) => [FeedID] -> m ()

-- | <a>subscribe</a> to all feeds described by the OPML document provided
--   in input
importOPML :: (MonadLog m, MonadDatabase FeedTable m, MonadCatch m) => ConduitT () ByteString m () -> m ()


-- | <h1>Getting started</h1>
--   
--   <h2>Dynamic reconfiguration</h2>
--   
--   This program is dynamically configured using the <a>dyre</a> library.
--   
--   You may want to check out <a>this documentation</a> to know how to get
--   started.
--   
--   Your personal configuration is located at
--   <tt>$XDG_CONFIG_HOME/imm/imm.hs</tt>.
--   
--   <h2><tt>ReaderT</tt> pattern</h2>
--   
--   The behavior of this program can be customized through the
--   <tt>ReaderT</tt> pattern.
module Imm.Boot

-- | Main function, meant to be used in your personal configuration file.
--   
--   Here is an example:
--   
--   <pre>
--   import           Imm.Boot
--   import           Imm.Database.JsonFile
--   import           Imm.Feed
--   import           Imm.Hooks.SendMail
--   import           Imm.HTTP.Conduit
--   import           Imm.Logger.Simple
--   import           Imm.XML.Simple
--   
--   main :: IO ()
--   main = do
--     logger   &lt;- defaultLogger
--     manager  &lt;- defaultManager
--     database &lt;- defaultDatabase
--   
--     imm $ mkModulesM manager database logger sendmail defaultXmlParser
--   
--   sendmail :: SendMailSettings
--   sendmail = SendMailSettings smtpServer formatMail
--   
--   formatMail :: FormatMail
--   formatMail = FormatMail
--     (\a b -&gt; (defaultFormatFrom a b) { addressEmail = "user@host" } )
--     defaultFormatSubject
--     defaultFormatBody
--     (\_ _ -&gt; [Address Nothing "user@host"])
--   
--   smtpServer :: Feed -&gt; FeedElement -&gt; SMTPServer
--   smtpServer _ _ = SMTPServer
--     (Just $ Authentication PLAIN "user" "password")
--     (StartTls "smtp.host" defaultSettingsSMTPSTARTTLS)
--   </pre>
imm :: ModulesM IO -> IO ()

-- | Modules are independent features of the program which behavior can be
--   controlled by the user.
data Modules httpClient databaseClient logger hooks xmlParser
Modules :: httpClient -> databaseClient -> logger -> hooks -> xmlParser -> Modules httpClient databaseClient logger hooks xmlParser

-- | HTTP client interpreter (cf <a>Imm.HTTP</a>)
[_httpClient] :: Modules httpClient databaseClient logger hooks xmlParser -> httpClient

-- | Database interpreter (cf <a>Imm.Database</a>)
[_databaseClient] :: Modules httpClient databaseClient logger hooks xmlParser -> databaseClient

-- | Logging interpreter (cf <a>Imm.Logger</a>)
[_logger] :: Modules httpClient databaseClient logger hooks xmlParser -> logger

-- | Hooks interpreter (cf <a>Imm.Hooks</a>)
[_hooks] :: Modules httpClient databaseClient logger hooks xmlParser -> hooks

-- | XML parsing interpreter (cf <a>Imm.XML</a>)
[_xmlParser] :: Modules httpClient databaseClient logger hooks xmlParser -> xmlParser

-- | Type-erased version of <a>Modules</a>, using existential
--   quantification.
data ModulesM m

-- | Constructor for <a>ModulesM</a>.
mkModulesM :: (MonadXmlParser (ReaderT e m), MonadImm (ReaderT d m), MonadLog (ReaderT c m), MonadDatabase FeedTable (ReaderT b m), MonadHttpClient (ReaderT a m)) => a -> b -> c -> d -> e -> ModulesM m
instance GHC.Show.Show Imm.Boot.InterruptedException
instance GHC.Read.Read Imm.Boot.InterruptedException
instance GHC.Classes.Eq Imm.Boot.InterruptedException
instance GHC.Show.Show Imm.Boot.SafeGuard
instance GHC.Read.Read Imm.Boot.SafeGuard
instance GHC.Classes.Eq Imm.Boot.SafeGuard
instance GHC.Exception.Exception Imm.Boot.InterruptedException
instance (Control.Monad.IO.Class.MonadIO m, Imm.Logger.MonadLog (Control.Monad.Trans.Reader.ReaderT c m)) => Imm.Logger.MonadLog (Control.Monad.Trans.Reader.ReaderT (Imm.Boot.Modules a b c d e) m)
instance (GHC.Base.Monad m, Imm.Hooks.MonadImm (Control.Monad.Trans.Reader.ReaderT d m)) => Imm.Hooks.MonadImm (Control.Monad.Trans.Reader.ReaderT (Imm.Boot.Modules a b c d e) m)
instance (Control.Monad.Catch.MonadThrow m, Imm.HTTP.MonadHttpClient (Control.Monad.Trans.Reader.ReaderT a m)) => Imm.HTTP.MonadHttpClient (Control.Monad.Trans.Reader.ReaderT (Imm.Boot.Modules a b c d e) m)
instance (Control.Monad.Catch.MonadThrow m, Imm.XML.MonadXmlParser (Control.Monad.Trans.Reader.ReaderT e m)) => Imm.XML.MonadXmlParser (Control.Monad.Trans.Reader.ReaderT (Imm.Boot.Modules a b c d e) m)
instance (Control.Monad.Catch.MonadThrow m, Imm.Database.MonadDatabase Imm.Database.FeedTable.FeedTable (Control.Monad.Trans.Reader.ReaderT b m)) => Imm.Database.MonadDatabase Imm.Database.FeedTable.FeedTable (Control.Monad.Trans.Reader.ReaderT (Imm.Boot.Modules a b c d e) m)


-- | Meta-module that reexports many Imm sub-modules.
--   
--   To get started, please consult <a>Imm.Boot</a>.
module Imm