    module RIO.Prelude
      (
        module RIO.Prelude.Types
        -- * @Bool@
        -- | Re-exported from "Data.Bool":
      , (Data.Bool.||)
      , (Data.Bool.&&)
      , Data.Bool.not
      , Data.Bool.otherwise
      , Data.Bool.bool

        -- * @Maybe@
        -- | Re-exported from "Data.Maybe":
      , Data.Maybe.maybe
      , Data.Maybe.fromMaybe
      , RIO.Prelude.Extra.fromFirst
      , Data.Maybe.isJust
      , Data.Maybe.isNothing
      , Data.Maybe.listToMaybe
      , Data.Maybe.maybeToList
      , Data.Maybe.catMaybes
      , Data.Maybe.mapMaybe
      , RIO.Prelude.Extra.mapMaybeA
      , RIO.Prelude.Extra.mapMaybeM
      , RIO.Prelude.Extra.forMaybeA
      , RIO.Prelude.Extra.forMaybeM

        -- * @Either@
        -- | Re-exported from "Data.Either":
      , Data.Either.either
      , Data.Either.fromLeft
      , Data.Either.fromRight
      , Data.Either.isLeft
      , Data.Either.isRight
      , RIO.Prelude.Extra.mapLeft
      , Data.Either.lefts
      , Data.Either.partitionEithers
      , Data.Either.rights

        -- * Tuples
        -- | Re-exported from "Data.Tuple":
      , Data.Tuple.fst
      , Data.Tuple.snd
      , Data.Tuple.curry
      , Data.Tuple.uncurry
      -- , Data.Tuple.swap -- TODO: export?

        -- * @Eq@
        -- | Re-exported from "Data.Eq":
      , (Data.Eq.==)
      , (Data.Eq./=)

        -- * @Ord@
        -- | Re-exported from "Data.Ord":
      , (Data.Ord.<)
      , (Data.Ord.<=)
      , (Data.Ord.>)
      , (Data.Ord.>=)
      , Data.Ord.max
      , Data.Ord.min
      , Data.Ord.compare
      , Data.Ord.comparing
      , Data.Ord.Down(..)

        -- * @Enum@
        -- | Re-exported from "Prelude":
      , Prelude.fromEnum

        -- * @Bounded@
        -- | Re-exported from "Prelude":
      , Prelude.minBound
      , Prelude.maxBound

        -- * @Num@
        -- | Re-exported from "Prelude":
      , (Prelude.+)
      , (Prelude.-)
      , (*) -- HSE can't parse qualified export, which results in hlint error.
      , (Prelude.^)
      , Prelude.negate
      , Prelude.abs
      , Prelude.signum
      , Prelude.fromInteger
      , Prelude.subtract

        -- * @Real@
        -- | Re-exported from "Prelude":
      , Prelude.toRational

        -- * @Integral@
        -- | Re-exported from "Prelude":
      , Prelude.quot
      , Prelude.rem
      , Prelude.div
      , Prelude.mod
      , Prelude.quotRem
      , Prelude.divMod
      , Prelude.toInteger
      , Prelude.even
      , Prelude.odd
      , Prelude.gcd
      , Prelude.lcm
      , Prelude.fromIntegral

        -- * @Fractional@
        -- | Re-exported from "Prelude":
      , (Prelude./)
      , (Prelude.^^)
      , Prelude.recip
      , Prelude.fromRational
      , Prelude.realToFrac

        -- * @Floating@
        -- | Re-exported from "Prelude":
      , Prelude.pi
      , Prelude.exp
      , Prelude.log
      , Prelude.sqrt
      , (Prelude.**)
      , Prelude.logBase
      , Prelude.sin
      , Prelude.cos
      , Prelude.tan
      , Prelude.asin
      , Prelude.acos
      , Prelude.atan
      , Prelude.sinh
      , Prelude.cosh
      , Prelude.tanh
      , Prelude.asinh
      , Prelude.acosh
      , Prelude.atanh

        -- * @RealFrac@
        -- | Re-exported from "Prelude":
      , Prelude.properFraction
      , Prelude.truncate
      , Prelude.round
      , Prelude.ceiling
      , Prelude.floor

        -- * @RealFloat@
        -- | Re-exported from "Prelude":
      , Prelude.floatRadix
      , Prelude.floatDigits
      , Prelude.floatRange
      , Prelude.decodeFloat
      , Prelude.encodeFloat
      , Prelude.exponent
      , Prelude.significand
      , Prelude.scaleFloat
      , Prelude.isNaN
      , Prelude.isInfinite
      , Prelude.isDenormalized
      , Prelude.isNegativeZero
      , Prelude.isIEEE
      , Prelude.atan2

        -- * @Word@
        -- | Re-exported from "Data.Word":
      , Data.Word.byteSwap16
      , Data.Word.byteSwap32
      , Data.Word.byteSwap64

        -- * @Semigroup@
        -- | Re-exported from "Data.Semigroup":
      , (Data.Semigroup.<>)
      , RIO.Prelude.Renames.sappend

        -- * @Monoid@
        -- | Re-exported from "Data.Monoid":
      , Data.Monoid.mempty
      , Data.Monoid.mappend
      , Data.Monoid.mconcat

        -- * @Functor@
        -- | Re-exported from "Data.Functor":
      , Data.Functor.fmap
      , (Data.Functor.<$>)
      , (Data.Functor.<$)
      , (Data.Functor.$>)
      , Data.Functor.void
      , (RIO.Prelude.Extra.<&>)

        -- * @Applicative@
        -- | Re-exported from "Control.Applicative":
      , Control.Applicative.pure
      , (Control.Applicative.<*>)
      , (Control.Applicative.<*)
      , (Control.Applicative.*>)
      , Control.Applicative.liftA
      , Control.Applicative.liftA2
      , Control.Applicative.liftA3
      , Control.Monad.forever
      , Data.Foldable.traverse_
      , Data.Foldable.for_
      , Data.Foldable.sequenceA_
      , Control.Monad.filterM
      , Control.Monad.replicateM_
      , Control.Monad.zipWithM
      , Control.Monad.zipWithM_

        -- * @Monad@
        -- | Re-exported from "Control.Monad":
      , Control.Monad.return
      , Control.Monad.join
      , Control.Monad.fail
      , (Control.Monad.>>=)
      , (Control.Monad.>>)
      , (Control.Monad.=<<)
      , (Control.Monad.>=>)
      , (Control.Monad.<=<)
      , (Control.Monad.<$!>)
      , Control.Monad.liftM
      , Control.Monad.liftM2
      , RIO.Prelude.Extra.whenM
      , RIO.Prelude.Extra.unlessM
      , Data.Foldable.mapM_
      , Data.Foldable.forM_
      , Data.Foldable.sequence_

      , Control.Monad.foldM
      , Control.Monad.foldM_
      -- TODO: Export these as well perhaps?
      -- , Data.Foldable.foldlM
      -- , Data.Foldable.foldrM

        -- * @Foldable@
        -- | Re-exported from "Data.Foldable":
      , Data.Foldable.foldr
      , Data.Foldable.foldl'
      , Data.Foldable.fold
      , Data.Foldable.foldMap
      , RIO.Prelude.Extra.foldMapM
      , Data.Foldable.elem
      , Data.Foldable.notElem
      , Data.Foldable.null
      , Data.Foldable.length
      , Data.Foldable.sum
      , Data.Foldable.product
      , Data.Foldable.all
      , Data.Foldable.any
      , Data.Foldable.and
      , Data.Foldable.or
      , Data.Foldable.toList
      , Data.Foldable.concat
      , Data.Foldable.concatMap

        -- * @Traversable@
        -- | Re-exported from "Data.Traversable":
      , Data.Traversable.traverse
      , Data.Traversable.for
      , Data.Traversable.sequenceA
      , Data.Traversable.mapM
      , Data.Traversable.forM
      , Data.Traversable.sequence

        -- * @Alternative@
        -- | Re-exported from "Control.Applicative":
      , (Control.Applicative.<|>)
      , Control.Applicative.some
      , Control.Applicative.many
      , Control.Applicative.optional
      , Data.Foldable.asum
      , Control.Monad.guard
      , Control.Monad.when
      , Control.Monad.unless

        -- * @Bifunctor@
        -- | Re-exported from "Data.Bifunctor":
      , Data.Bifunctor.bimap
      , Data.Bifunctor.first
      , Data.Bifunctor.second

        -- * @Bifoldable@
        -- | Re-exported from "Data.Bifoldable":
      , Data.Bifoldable.bifold
      , Data.Bifoldable.bifoldMap
      , Data.Bifoldable.bifoldr
      , Data.Bifoldable.bifoldl
      , Data.Bifoldable.bifoldr'
      , Data.Bifoldable.bifoldr1
      , Data.Bifoldable.bifoldrM
      , Data.Bifoldable.bifoldl'
      , Data.Bifoldable.bifoldl1
      , Data.Bifoldable.bifoldlM
      , Data.Bifoldable.bitraverse_
      , Data.Bifoldable.bifor_
      , Data.Bifoldable.bisequence_
      , Data.Bifoldable.biasum
      , Data.Bifoldable.biList
      , Data.Bifoldable.binull
      , Data.Bifoldable.bilength
      , Data.Bifoldable.bielem
      , Data.Bifoldable.bimaximum
      , Data.Bifoldable.biminimum
      , Data.Bifoldable.bisum
      , Data.Bifoldable.biproduct
      , Data.Bifoldable.biconcat
      , Data.Bifoldable.biconcatMap
      , Data.Bifoldable.biand
      , Data.Bifoldable.bior
      , Data.Bifoldable.biany
      , Data.Bifoldable.biall
      , Data.Bifoldable.bimaximumBy
      , Data.Bifoldable.biminimumBy
      , Data.Bifoldable.binotElem
      , Data.Bifoldable.bifind

        -- * @Bitraverse@
        -- | Re-exported from "Data.Bitraversable":
      , Data.Bitraversable.bitraverse
      , Data.Bitraversable.bisequence
      , Data.Bitraversable.bifor
      , Data.Bitraversable.bimapAccumL
      , Data.Bitraversable.bimapAccumR

        -- * @MonadPlus@
        -- | Re-exported from "Control.Monad":
      , Control.Monad.mzero
      , Control.Monad.mplus
      , Control.Monad.msum
      , Control.Monad.mfilter

        -- * @Arrow@
        -- | Re-exported from "Control.Arrow" and "Control.Category":
      , (Control.Arrow.&&&)
      , (Control.Arrow.***)
      , (Control.Category.>>>)

        -- * @Function@
        -- | Re-exported from "Data.Function":
      , Data.Function.id
      , Data.Function.const
      , (Data.Function..)
      , (Data.Function.$)
      , (Data.Function.&)
      , Data.Function.flip
      , Data.Function.fix
      , Data.Function.on

        -- * Miscellaneous functions
      , (Prelude.$!)
      , Prelude.seq
      , Prelude.error
      , Prelude.undefined
      , Prelude.asTypeOf
      , RIO.Prelude.Extra.asIO

        -- * List
        -- | Re-exported from "Data.List":
      , (Data.List.++)
      , Data.List.break
      , Data.List.drop
      , Data.List.dropWhile
      , Data.List.filter
      , Data.List.lookup
      , Data.List.map
      , Data.List.replicate
      , Data.List.reverse
      , Data.List.span
      , Data.List.take
      , Data.List.takeWhile
      , Data.List.zip
      , Data.List.zipWith
      , RIO.Prelude.Extra.nubOrd

        -- * @String@
        -- | Re-exported from "Data.String":
      , Data.String.fromString
      , Data.String.lines
      , Data.String.unlines
      , Data.String.unwords
      , Data.String.words

        -- ** @Show@
        -- | Re-exported from "Text.Show":
      , Text.Show.show
        -- ** @Read@
        -- | Re-exported from "Text.Read":
      , Text.Read.readMaybe

        -- * @NFData@

        -- | Re-exported from "Control.DeepSeq":
      , (Control.DeepSeq.$!!)
      , Control.DeepSeq.rnf
      , Control.DeepSeq.deepseq
      , Control.DeepSeq.force

        -- * @Void@
        -- | Re-exported from "Data.Void":
      , Data.Void.absurd

        -- * @Reader@
        -- | Re-exported from "Control.Monad.Reader":
      , Control.Monad.Reader.lift
      , Control.Monad.Reader.ask
      , Control.Monad.Reader.asks
      , Control.Monad.Reader.local
      , Control.Monad.Reader.runReader
      , Control.Monad.Reader.runReaderT

        -- * @ByteString@
        -- | Helper synonyms for converting bewteen lazy and strict @ByteString@s
      , RIO.Prelude.Renames.toStrictBytes
      , RIO.Prelude.Renames.fromStrictBytes

        -- * @ShortByteString@
        -- | Re-exported from "Data.ByteString.Short":
      , Data.ByteString.Short.toShort
      , Data.ByteString.Short.fromShort

        -- * @Text@
      , RIO.Prelude.Text.tshow
      , RIO.Prelude.Text.decodeUtf8Lenient
        -- | Re-exported from "Data.Text.Encoding":
      , Data.Text.Encoding.decodeUtf8'
      , Data.Text.Encoding.decodeUtf8With
      , Data.Text.Encoding.encodeUtf8
      , Data.Text.Encoding.encodeUtf8Builder
      , Data.Text.Encoding.Error.lenientDecode

        -- * @PrimMonad@
        -- | Re-exported from "Control.Monad.Primitive":
      , Control.Monad.Primitive.primitive
        -- | Re-exported from "Control.Monad.ST":
      , Control.Monad.ST.runST
      ) where

    import qualified RIO.Prelude.Extra
    import qualified RIO.Prelude.Renames
    import qualified RIO.Prelude.Text
    import qualified RIO.Prelude.Types

    import qualified Control.Applicative
    import qualified Control.Arrow
    import qualified Control.Category
    import qualified Control.DeepSeq
    import qualified Control.Monad
    import qualified Control.Monad.Primitive (primitive)
    import qualified Control.Monad.Reader
    import qualified Control.Monad.ST
    import qualified Data.Bifoldable
    import qualified Data.Bifunctor
    import qualified Data.Bitraversable
    import qualified Data.Bool
    import qualified Data.ByteString.Short
    import qualified Data.Either
    import qualified Data.Eq
    import qualified Data.Foldable
    import qualified Data.Function
    import qualified Data.Functor
    import qualified Data.List
    import qualified Data.Maybe
    import qualified Data.Monoid
    import qualified Data.Ord
    import qualified Data.Semigroup
    import qualified Data.String
    import qualified Data.Text.Encoding
        (decodeUtf8', decodeUtf8With, encodeUtf8, encodeUtf8Builder)
    import qualified Data.Text.Encoding.Error (lenientDecode)
    import qualified Data.Traversable
    import qualified Data.Tuple
    import qualified Data.Void
    import qualified Data.Word
    import           Prelude ((*))
    import qualified Prelude
    import qualified Text.Read
    import qualified Text.Show