{-# LANGUAGE CPP #-}
module RIO.Prelude.Reexports
  ( module UnliftIO
  -- List imports from UnliftIO?
  , UnliftIO.Concurrent.ThreadId
  , UnliftIO.Concurrent.myThreadId
  , UnliftIO.Concurrent.isCurrentThreadBound
  , UnliftIO.Concurrent.threadWaitRead
  , UnliftIO.Concurrent.threadWaitWrite
  , UnliftIO.Concurrent.threadDelay
  , yieldThread
  , Control.Applicative.Alternative
  , Control.Applicative.Applicative (..)
  , Control.Applicative.liftA
#if !MIN_VERSION_base(4, 10, 0)
  , Control.Applicative.liftA2
#endif
  , Control.Applicative.liftA3
  , Control.Applicative.many
  , Control.Applicative.optional
  , Control.Applicative.some
  , (Control.Applicative.<|>)
  , Control.Arrow.first
  , Control.Arrow.second
  , (Control.Arrow.&&&)
  , (Control.Arrow.***)
  , (Control.Category.>>>)
  , Control.DeepSeq.NFData(..)
  , Control.DeepSeq.force
  , (Control.DeepSeq.$!!)
  , Control.Monad.Monad(..)
  , Control.Monad.MonadPlus(..)
  , Control.Monad.filterM
  , Control.Monad.foldM
  , Control.Monad.foldM_
  , Control.Monad.forever
  , Control.Monad.guard
  , Control.Monad.join
  , Control.Monad.liftM
  , Control.Monad.liftM2
  , Control.Monad.replicateM_
  , Control.Monad.unless
  , Control.Monad.when
  , Control.Monad.zipWithM
  , Control.Monad.zipWithM_
  , (Control.Monad.<$!>)
  , (Control.Monad.<=<)
  , (Control.Monad.=<<)
  , (Control.Monad.>=>)
  , Control.Monad.Catch.MonadThrow(..)
  , Control.Monad.Reader.MonadReader
  , Control.Monad.Reader.MonadTrans(..)
  , Control.Monad.Reader.Reader
  , Control.Monad.Reader.ReaderT(..)
  , Control.Monad.Reader.ask
  , Control.Monad.Reader.asks
  , Control.Monad.Reader.local
  , Control.Monad.Reader.runReader
  , Data.Bool.Bool(..)
  , Data.Bool.bool
  , Data.Bool.not
  , Data.Bool.otherwise
  , (Data.Bool.&&)
  , (Data.Bool.||)
  , Data.ByteString.ByteString
  , Data.ByteString.Builder.Builder
  , Data.ByteString.Short.ShortByteString
  , Data.ByteString.Short.toShort
  , Data.ByteString.Short.fromShort
  , Data.Char.Char
  , Data.Data.Data(..)
  , Data.Either.Either(..)
  , Data.Either.either
  , Data.Either.isLeft
  , Data.Either.isRight
  , Data.Either.lefts
  , Data.Either.partitionEithers
  , Data.Either.rights
  , Data.Eq.Eq(..)
  , Data.Foldable.Foldable
  , Data.Foldable.all
  , Data.Foldable.and
  , Data.Foldable.any
  , Data.Foldable.asum
  , Data.Foldable.concat
  , Data.Foldable.concatMap
  , Data.Foldable.elem
  , Data.Foldable.fold
  , Data.Foldable.foldMap
  , Data.Foldable.foldl'
  , Data.Foldable.foldr
  , Data.Foldable.forM_
  , Data.Foldable.for_
  , Data.Foldable.length
  , Data.Foldable.mapM_
  , Data.Foldable.msum
  , Data.Foldable.notElem
  , Data.Foldable.null
  , Data.Foldable.or
  , Data.Foldable.product
  , Data.Foldable.sequenceA_
  , Data.Foldable.sequence_
  , Data.Foldable.sum
  , Data.Foldable.toList
  , Data.Foldable.traverse_
  , Data.Function.const
  , Data.Function.fix
  , Data.Function.flip
  , Data.Function.id
  , Data.Function.on
  , (Data.Function.$)
  , (Data.Function.&)
  , (Data.Function..)
  , Data.Functor.Functor(..)
  , Data.Functor.void
  , (Data.Functor.$>)
  , (Data.Functor.<$>)
#if MIN_VERSION_base(4, 11, 0)
  , (Data.Functor.<&>)
#else
  , (<&>)
#endif
  , Data.Functor.Const.Const(..)
  , Data.Functor.Identity.Identity(..)
  , Data.Hashable.Hashable
  , Data.HashMap.Strict.HashMap
  , Data.HashSet.HashSet
  , Data.Int.Int
  , Data.Int.Int8
  , Data.Int.Int16
  , Data.Int.Int32
  , Data.Int.Int64
  , Data.IntMap.Strict.IntMap
  , Data.IntSet.IntSet
  , Data.List.break
  , Data.List.drop
  , Data.List.dropWhile
  , Data.List.filter
  , Data.List.lines
  , Data.List.lookup
  , Data.List.map
  , Data.List.replicate
  , Data.List.reverse
  , Data.List.span
  , Data.List.take
  , Data.List.takeWhile
  , Data.List.unlines
  , Data.List.unwords
  , Data.List.words
  , Data.List.zip
  , (Data.List.++)
  , Data.Map.Strict.Map
  , Data.Maybe.Maybe(..)
  , Data.Maybe.catMaybes
  , Data.Maybe.fromMaybe
  , Data.Maybe.isJust
  , Data.Maybe.isNothing
  , Data.Maybe.listToMaybe
  , Data.Maybe.mapMaybe
  , Data.Maybe.maybe
  , Data.Maybe.maybeToList
  , Data.Monoid.Monoid (..)
  , Data.Ord.Ord(..)
  , Data.Ord.Ordering(..)
  , Data.Ord.comparing
  , Data.Proxy.Proxy(..)
  , Data.Semigroup.Semigroup (..)
  , Data.Set.Set
  , Data.String.IsString(..)
  , Data.Text.Text
  , Data.Text.Encoding.decodeUtf8'
  , Data.Text.Encoding.decodeUtf8With
  , Data.Text.Encoding.encodeUtf8
  , Data.Text.Encoding.encodeUtf8Builder
  , Data.Text.Encoding.Error.UnicodeException(..)
  , Data.Text.Encoding.Error.lenientDecode
  , Data.Traversable.Traversable(..)
  , Data.Traversable.for
  , Data.Traversable.forM
  , Data.Vector.Vector
  , Data.Void.Void
  , Data.Void.absurd
  , Data.Word.Word
  , Data.Word.Word8
  , Data.Word.Word16
  , Data.Word.Word32
  , Data.Word.Word64
  , Data.Word.byteSwap16
  , Data.Word.byteSwap32
  , Data.Word.byteSwap64
  , Foreign.Storable.Storable
  , GHC.Generics.Generic
  , GHC.Stack.HasCallStack
  , Numeric.Natural.Natural
  , Prelude.Bounded (..)
  , Prelude.Double
  , Prelude.Enum
  , Prelude.FilePath
  , Prelude.Float
  , Prelude.Floating (..)
  , Prelude.Fractional (..)
  , Prelude.IO
  , Prelude.Integer
  , Prelude.Integral (..)
  , Prelude.Num (..)
  , Prelude.Rational
  , Prelude.Real (..)
  , Prelude.RealFloat (..)
  , Prelude.RealFrac (..)
  , Prelude.Show
  , Prelude.String
  , Prelude.asTypeOf
  , Prelude.curry
  , Prelude.error
  , Prelude.even
  , Prelude.fromEnum
  , Prelude.fromIntegral
  , Prelude.fst
  , Prelude.gcd
  , Prelude.lcm
  , Prelude.odd
  , Prelude.realToFrac
  , Prelude.seq
  , Prelude.show
  , Prelude.snd
  , Prelude.subtract
  , Prelude.uncurry
  , Prelude.undefined
  , (Prelude.$!)
  , (Prelude.^)
  , (Prelude.^^)
  , System.Exit.ExitCode(..)
  , Text.Read.Read
  , Text.Read.readMaybe
    -- * Primitive
  , PrimMonad (..)
    -- * Unbox
  , Unbox
  ) where

import           Control.Applicative      (Applicative)
import           Control.Monad            (Monad (..), liftM, (<=<))
import           Control.Monad.Catch      (MonadThrow)
import           Control.Monad.Primitive  (PrimMonad (..))
import           Control.Monad.Reader     (MonadReader, ReaderT (..), ask, asks)
import           Control.Monad.State      (MonadState(..))
import           Control.Monad.Writer     (MonadWriter (..))
import           Data.Bool                (otherwise)
import           Data.ByteString          (ByteString)
import           Data.ByteString.Builder  (Builder)
import           Data.Either              (Either (..))
import           Data.Foldable            (foldMap)
import           Data.Function            (flip, ($), (.))
import           Data.Functor             (Functor (..))
import           Data.Int                 (Int)
import           Data.Maybe               (Maybe, catMaybes, fromMaybe)
import           Data.Monoid              (Monoid (..))
import           Data.Ord                 (Ord)
import           Data.Semigroup           (Semigroup (..))
import           Data.String              (IsString (..))
import           Data.Text                (Text)
import           Data.Text.Encoding       (decodeUtf8', decodeUtf8With,
                                           encodeUtf8, encodeUtf8Builder)
import           Data.Text.Encoding.Error (UnicodeException, lenientDecode)
import           Data.Traversable         (Traversable (..))
import           Prelude                  (FilePath, IO, Show (..))
import           UnliftIO
import qualified UnliftIO.Concurrent

import           Data.Vector.Unboxed.Mutable (Unbox)




-- Reexports
import qualified Control.Applicative
import qualified Control.Arrow
import qualified Control.Category
import qualified Control.DeepSeq
import qualified Control.Monad
import qualified Control.Monad.Catch
import qualified Control.Monad.Reader
import qualified Data.Bool
import qualified Data.ByteString.Short
import qualified Data.Char
import qualified Data.Data
import qualified Data.Either
import qualified Data.Eq
import qualified Data.Foldable
import qualified Data.Function
import qualified Data.Functor
import qualified Data.Functor.Const
import qualified Data.Functor.Identity
import qualified Data.Hashable
import qualified Data.HashMap.Strict
import qualified Data.HashSet
import qualified Data.Int
import qualified Data.IntMap.Strict
import qualified Data.IntSet
import qualified Data.List
import qualified Data.Map.Strict
import qualified Data.Maybe
import qualified Data.Ord
import qualified Data.Proxy
import qualified Data.Set
import qualified Data.Text.Encoding.Error
import qualified Data.Traversable
import qualified Data.Vector
import qualified Data.Void
import qualified Data.Word
import qualified Foreign.Storable
import qualified GHC.Generics
import qualified GHC.Stack
import qualified Numeric.Natural
import qualified Prelude
import qualified System.Exit
import qualified Text.Read

yieldThread :: MonadIO m => m ()
yieldThread = UnliftIO.Concurrent.yield
{-# INLINE yieldThread #-}

#if !MIN_VERSION_base(4, 11, 0)
(<&>) :: Functor f => f a -> (a -> b) -> f b
as <&> f = f Data.Functor.<$> as

infixl 1 <&>
#endif