module RIO
  (
    -- * Custom @Prelude@

    -- | One of the core features of @rio@ is that it can be used as a @Prelude@
    -- replacement. Therefore it is best to disable the default `Prelude` with:
    -- [NoImplicitPrelude](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#extension-NoImplicitPrelude)
    -- pragma:
    --
    -- > {-# LANGUAGE NoImplicitPrelude #-}
    -- > import RIO
    --
    -- Some functions not exported here can be found in "RIO.Partial":
    -- @fromJust@, @read@, @toEnum@, @pred@, @succ@.
    --
    module RIO.Prelude
  , module RIO.Prelude.Types
    -- * The @RIO@ Monad

  , module MonadRIO
    -- ** @SimpleApp@
    -- | If all you need is just some default environment that does basic logging and allows
    -- spawning processes, then you can use `SimpleApp`:
    --
    -- > {-# LANGUAGE OverloadedStrings #-}
    -- > module Main where
    -- >
    -- > main :: IO ()
    -- > main =
    -- >   runSimpleApp $ do
    -- >     logInfo "Hello World!"
    --
    -- Note the
    -- [OverloadedStrings](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#extension-OverloadedStrings)
    -- extension, which is enabled to simplify logging.
  , module RIO.Prelude.Simple
    -- * @MonadIO@ and @MonadUnliftIO@
  , module Control.Monad.IO.Unlift
    -- * Logger
    -- $logging-intro
  , module RIO.Prelude.Logger
    -- * Display
  , module RIO.Prelude.Display
    -- * Optics
    -- | @microlens@-based Lenses, Traversals, etc.
  , module RIO.Prelude.Lens
    -- * Concurrency
  , UnliftIO.Concurrent.ThreadId
  , UnliftIO.Concurrent.myThreadId
  , UnliftIO.Concurrent.isCurrentThreadBound
  , UnliftIO.Concurrent.threadWaitRead
  , UnliftIO.Concurrent.threadWaitWrite
  , UnliftIO.Concurrent.threadDelay
  , RIO.Prelude.Renames.yieldThread
    -- ** Async
  , module UnliftIO.Async
    -- ** STM
  , module UnliftIO.STM
    -- ** Chan
  , module UnliftIO.Chan
    -- ** Timeout
  , module UnliftIO.Timeout
    -- * Exceptions
  , module UnliftIO.Exception
    -- | Re-exported from "Control.Monad.Catch":
  , Control.Monad.Catch.throwM
    -- * Files and handles
  , module UnliftIO.IO
  , module UnliftIO.Temporary
  , module RIO.Prelude.IO
    -- * Exit
  , module RIO.Prelude.Exit
    -- * Mutable Variables
    -- ** SomeRef
  , module SomeRef
    -- ** URef
  , module RIO.Prelude.URef
    -- ** IORef
  , module UnliftIO.IORef
    -- ** MVar
  , module UnliftIO.MVar
    -- ** Memoize
  , module UnliftIO.Memoize
    -- ** Deque
  , module RIO.Deque

    -- * Debugging
  , module RIO.Prelude.Trace
  ) where

import qualified Control.Monad.Catch (MonadThrow(..))
import RIO.Deque
import RIO.Prelude
import RIO.Prelude.Display
import RIO.Prelude.Exit
import RIO.Prelude.Extra
import RIO.Prelude.IO
import RIO.Prelude.Lens
import RIO.Prelude.Logger
import RIO.Prelude.Renames
import RIO.Prelude.RIO as MonadRIO (RIO(..), liftRIO, runRIO)
import RIO.Prelude.RIO as SomeRef hiding (RIO(..), liftRIO, runRIO)
import RIO.Prelude.Simple
import RIO.Prelude.Text
import RIO.Prelude.Trace
import RIO.Prelude.Types
import RIO.Prelude.URef
import Control.Monad.IO.Unlift
import UnliftIO.Async
import UnliftIO.Chan
import UnliftIO.Exception
import UnliftIO.IO
import UnliftIO.IORef
import UnliftIO.Memoize
import UnliftIO.MVar
import UnliftIO.STM
import UnliftIO.Temporary
import UnliftIO.Timeout
import UnliftIO.Concurrent

--------------------------------------------------------------------------------
-- $logging-intro
--
-- The logging system in RIO is built upon "log functions", which are
-- accessed in RIO's environment via a class like "has log
-- function". There are two provided:
--
-- * In the common case: for logging plain text (via 'Utf8Builder')
--   efficiently, there is 'LogFunc', which can be created via
--   'withLogFunc', and is accessed via 'HasLogFunc'. This provides
--   all the classical logging facilities: timestamped text output
--   with log levels and colors (if terminal-supported) to the
--   terminal. We log output via 'logInfo', 'logDebug', etc.
--
-- * In the advanced case: where logging takes on a more semantic
--   meaning and the logs need to be digested, acted upon, translated
--   or serialized upstream (to e.g. a JSON logging server), we have
--   'GLogFunc' (as in "generic log function"), and is accessed via
--   'HasGLogFunc'. In this case, we log output via 'glog'. See the
--   Type-generic logger section for more information.