content: -- | A custom @Prelude@-like module for this project
  module Fission.Prelude
    ( module Control.Lens
  
    , module Control.Monad.Trans.Control
  
    , module Control.Monad.Logger
    , module Control.Monad.Time
  
    , module Control.Monad.Cleanup
    , module Control.Monad.Raise
    , module Control.Monad.Rescue
  
    , module Control.Monad.Trans.Cleanup
    , module Control.Monad.Trans.Rescue
  
    , module Data.Aeson
    , module Data.Bool
    , module Data.Bifunctor
    , module Data.Has
    , module Data.Maybe
    , module Data.WorldPeace
  
    , module Data.Generics.Product
    , module Data.Generics.Sum
  
    , module Fission.Text.Encoded
    , module Fission.Unit.Prefix
    , module Fission.Internal.Log
  
    , module Web.UCAN.Internal.Time
  
    , module Flow
  
    , module RIO
    , module RIO.Process
    , module RIO.Time
    , module Test.QuickCheck
  
    , Entity (..)
    , buildByteString
    , buildLazyByteString
    , headMaybe
    , identity
    , intercalate
    , putText
    , putTextLn
    , textShow
    , displayLazyBS
    , bind
    , ord
    , ok
    , noop
    ) where
  
  import           Control.Lens                                ((?~))
  import           Control.Monad.Logger                        (LogLevel (..),
                                                                LogSource,
                                                                MonadLogger (..),
                                                                ToLogStr (..),
                                                                logWithoutLoc)
  import           Control.Monad.Time
  
  import           Control.Monad.Trans.Control
  
  import           Control.Monad.Cleanup
  import           Control.Monad.Raise
  import           Control.Monad.Rescue
  
  import           Control.Monad.Trans.Cleanup
  import           Control.Monad.Trans.Rescue
  
  import           Network.IPFS.Internal.Orphanage.Utf8Builder ()
  
  import           Data.Aeson                                  hiding (Encoding,
                                                                Options)
  import           Data.Bifunctor                              (bimap)
  import           Data.Bool
  import           Data.Has                                    hiding (Lens)
  import           Data.Maybe
  import           Data.WorldPeace
  
  import           Data.Generics.Product
  import           Data.Generics.Sum
  
  import           Database.Persist                            (Entity (..))
  
  import           Flow
  
  import           RIO.Char                                    (ord)
  import           RIO.List                                    (headMaybe,
                                                                intercalate)
  import           RIO.Process
  import           RIO.Time
  
  import           RIO.Orphans                                 ()
  
  import           RIO                                         hiding (Handler,
                                                                LogLevel (..),
                                                                LogSource, const,
                                                                exp, id, logDebug,
                                                                logDebugS,
                                                                logError,
                                                                logErrorS,
                                                                logInfo, logInfoS,
                                                                logOther,
                                                                logOtherS,
                                                                logWarn, logWarnS,
                                                                timeout, (&),
                                                                (^.))
  
  import           Test.QuickCheck                             hiding
                                                               (Result (..))
  import           Test.QuickCheck.Instances                   ()
  
  import           Fission.Text.Encoded
  import           Fission.Unit.Prefix
  
  import           Web.UCAN.Internal.Orphanage.ClientError     ()
  import           Web.UCAN.Internal.Time
  
  import           Fission.Internal.Log
  import           Fission.Internal.Orphanage.OpenUnion        ()
  import           Fission.Internal.Orphanage.String           ()
  import           Fission.Internal.UTF8                       (displayLazyBS,
                                                                putText,
                                                                putTextLn,
                                                                textShow)
  
  -- Not reexported
  import qualified Data.ByteString.Builder                     as Builder
  import qualified RIO.ByteString.Lazy                         as Lazy
  
  identity :: a -> a
  identity a = a
  
  bind :: Monad m => (a -> m b) -> m a -> m b
  bind = (=<<)
  
  ok :: Either err ()
  ok = Right ()
  
  noop :: Applicative f => f ()
  noop = pure ()
  
  buildByteString :: Utf8Builder -> ByteString
  buildByteString utf8 = Lazy.toStrict $ buildLazyByteString utf8
  
  buildLazyByteString :: Utf8Builder -> Lazy.ByteString
  buildLazyByteString (Utf8Builder builder) = Builder.toLazyByteString builder
  