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

-- | base-compat with extra batteries
--   
--   Provides functions available in later versions of base to a
--   wider range of compilers, without requiring you to use CPP pragmas in
--   your code.
--   
--   This package provides the same API as the base-compat
--   library, but depends on compatibility packages (such as
--   semigroups) to offer a wider support window than
--   base-compat, which has no dependencies. Most of the modules
--   in this library have the same names as in base-compat to make
--   it easier to switch between the two. There also exist versions of each
--   module with the suffix .Repl.Batteries, which are distinct
--   from anything in base-compat, to allow for easier use in
--   GHCi.
--   
--   See here for a more comprehensive list of differences
--   between base-compat and base-compat-batteries.
@package base-compat-batteries
@version 0.11.1

module Control.Concurrent.Compat

-- | Reexports Control.Concurrent.Compat from a globally unique
--   namespace.
module Control.Concurrent.Compat.Repl.Batteries

module Control.Concurrent.MVar.Compat

-- | Reexports Control.Concurrent.MVar.Compat from a globally unique
--   namespace.
module Control.Concurrent.MVar.Compat.Repl.Batteries

module Control.Exception.Compat

-- | Reexports Control.Exception.Compat from a globally unique
--   namespace.
module Control.Exception.Compat.Repl.Batteries

module Control.Monad.Compat
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
class Monad m => MonadFail (m :: Type -> Type)
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
void :: Functor f => f a -> f ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
unless :: Applicative f => Bool -> f () -> f ()
replicateM_ :: Applicative m => Int -> m a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
forever :: Applicative f => f a -> f b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(<$!>) :: Monad m => (a -> b) -> m a -> m b
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
mzero :: MonadPlus m => m a
mplus :: MonadPlus m => m a -> m a -> m a
when :: Applicative f => Bool -> f () -> f ()
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
(=<<) :: Monad m => (a -> m b) -> m a -> m b
fail :: MonadFail m => String -> m a

-- | Reexports Control.Monad.Compat from a globally unique
--   namespace.
module Control.Monad.Compat.Repl.Batteries

module Control.Monad.Fail.Compat

-- | Reexports Control.Monad.Fail.Compat from a globally unique
--   namespace.
module Control.Monad.Fail.Compat.Repl.Batteries

module Control.Monad.IO.Class.Compat

-- | Reexports Control.Monad.IO.Class.Compat from a globally unique
--   namespace.
module Control.Monad.IO.Class.Compat.Repl.Batteries

module Control.Monad.ST.Lazy.Unsafe.Compat

-- | Reexports Control.Monad.ST.Lazy.Unsafe.Compat from a globally
--   unique namespace.
module Control.Monad.ST.Lazy.Unsafe.Compat.Repl.Batteries

module Control.Monad.ST.Unsafe.Compat

-- | Reexports Control.Monad.ST.Unsafe.Compat from a globally unique
--   namespace.
module Control.Monad.ST.Unsafe.Compat.Repl.Batteries

module Data.Bifoldable.Compat

-- | Reexports Data.Bifoldable.Compat from a globally unique
--   namespace.
module Data.Bifoldable.Compat.Repl.Batteries

module Data.Bifunctor.Compat

-- | Reexports Data.Bifunctor.Compat from a globally unique
--   namespace.
module Data.Bifunctor.Compat.Repl.Batteries

module Data.Bitraversable.Compat

-- | Reexports Data.Bitraversable.Compat from a globally unique
--   namespace.
module Data.Bitraversable.Compat.Repl.Batteries

module Data.Bits.Compat

-- | Reexports Data.Bits.Compat from a globally unique namespace.
module Data.Bits.Compat.Repl.Batteries

module Data.Bool.Compat

-- | Reexports Data.Bool.Compat from a globally unique namespace.
module Data.Bool.Compat.Repl.Batteries

module Data.Complex.Compat

-- | Reexports Data.Complex.Compat from a globally unique namespace.
module Data.Complex.Compat.Repl.Batteries

module Data.Either.Compat

-- | Reexports Data.Either.Compat from a globally unique namespace.
module Data.Either.Compat.Repl.Batteries

module Data.Foldable.Compat

-- | Reexports Data.Foldable.Compat from a globally unique
--   namespace.
module Data.Foldable.Compat.Repl.Batteries

module Data.Function.Compat

-- | Reexports Data.Function.Compat from a globally unique
--   namespace.
module Data.Function.Compat.Repl.Batteries

module Data.Functor.Compat
class Functor (f :: Type -> Type)
fmap :: Functor f => (a -> b) -> f a -> f b
(<$) :: Functor f => a -> f b -> f a
($>) :: Functor f => f a -> b -> f b
void :: Functor f => f a -> f ()
(<&>) :: Functor f => f a -> (a -> b) -> f b

-- | Reexports Data.Functor.Compat from a globally unique namespace.
module Data.Functor.Compat.Repl.Batteries

module Data.Functor.Compose.Compat

-- | Reexports Data.Functor.Compose.Compat from a globally unique
--   namespace.
module Data.Functor.Compose.Compat.Repl.Batteries

module Data.Functor.Const.Compat

-- | Reexports Data.Functor.Const.Compat from a globally unique
--   namespace.
module Data.Functor.Const.Compat.Repl.Batteries

module Data.Functor.Contravariant.Compat

-- | Reexports Data.Functor.Contravariant.Compat from a globally
--   unique namespace.
module Data.Functor.Contravariant.Compat.Repl.Batteries

module Data.Functor.Identity.Compat

-- | Reexports Data.Functor.Identity.Compat from a globally unique
--   namespace.
module Data.Functor.Identity.Compat.Repl.Batteries

module Data.Functor.Product.Compat

-- | Reexports Data.Functor.Product.Compat from a globally unique
--   namespace.
module Data.Functor.Product.Compat.Repl.Batteries

module Data.Functor.Sum.Compat

-- | Reexports Data.Functor.Sum.Compat from a globally unique
--   namespace.
module Data.Functor.Sum.Compat.Repl.Batteries

module Data.IORef.Compat

-- | Reexports Data.IORef.Compat from a globally unique namespace.
module Data.IORef.Compat.Repl.Batteries

module Data.List.Compat

-- | Reexports Data.List.Compat from a globally unique namespace.
module Data.List.Compat.Repl.Batteries

-- | This backports the modern Data.Semigroup interface back to
--   base-4.9/GHC 8.0.
module Data.List.NonEmpty.Compat
data NonEmpty a
(:|) :: a -> [a] -> NonEmpty a
map :: (a -> b) -> NonEmpty a -> NonEmpty b
intersperse :: a -> NonEmpty a -> NonEmpty a
scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b
scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b
scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
sortWith :: Ord o => (a -> o) -> NonEmpty a -> NonEmpty a
length :: NonEmpty a -> Int
head :: NonEmpty a -> a
tail :: NonEmpty a -> [a]
last :: NonEmpty a -> a
init :: NonEmpty a -> [a]
(<|) :: a -> NonEmpty a -> NonEmpty a
cons :: a -> NonEmpty a -> NonEmpty a
uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
sort :: Ord a => NonEmpty a -> NonEmpty a
reverse :: NonEmpty a -> NonEmpty a
inits :: Foldable f => f a -> NonEmpty [a]
tails :: Foldable f => f a -> NonEmpty [a]
iterate :: (a -> a) -> a -> NonEmpty a
repeat :: a -> NonEmpty a
cycle :: NonEmpty a -> NonEmpty a
unfold :: (a -> (b, Maybe a)) -> a -> NonEmpty b
insert :: (Foldable f, Ord a) => a -> f a -> NonEmpty a
some1 :: Alternative f => f a -> f (NonEmpty a)
take :: Int -> NonEmpty a -> [a]
drop :: Int -> NonEmpty a -> [a]
splitAt :: Int -> NonEmpty a -> ([a], [a])
takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
filter :: (a -> Bool) -> NonEmpty a -> [a]
partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
group :: (Foldable f, Eq a) => f a -> [NonEmpty a]
groupBy :: Foldable f => (a -> a -> Bool) -> f a -> [NonEmpty a]
groupWith :: (Foldable f, Eq b) => (a -> b) -> f a -> [NonEmpty a]
groupAllWith :: Ord b => (a -> b) -> [a] -> [NonEmpty a]
group1 :: Eq a => NonEmpty a -> NonEmpty (NonEmpty a)
groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupWith1 :: Eq b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
groupAllWith1 :: Ord b => (a -> b) -> NonEmpty a -> NonEmpty (NonEmpty a)
isPrefixOf :: Eq a => [a] -> NonEmpty a -> Bool
nub :: Eq a => NonEmpty a -> NonEmpty a
nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
(!!) :: NonEmpty a -> Int -> a
zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
unzip :: Functor f => f (a, b) -> (f a, f b)
fromList :: [a] -> NonEmpty a
toList :: NonEmpty a -> [a]
nonEmpty :: [a] -> Maybe (NonEmpty a)
xor :: NonEmpty Bool -> Bool

-- | Reexports Data.List.NonEmpty.Compat from a globally unique
--   namespace.
module Data.List.NonEmpty.Compat.Repl.Batteries

module Data.Monoid.Compat
class Semigroup a => Monoid a
mempty :: Monoid a => a
mappend :: Monoid a => a -> a -> a
mconcat :: Monoid a => [a] -> a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Ap (f :: k -> Type) (a :: k)
Ap :: f a -> Ap (f :: k -> Type) (a :: k)
[getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
newtype Alt (f :: k -> Type) (a :: k)
Alt :: f a -> Alt (f :: k -> Type) (a :: k)
[getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
(<>) :: Semigroup a => a -> a -> a

-- | Reexports Data.Monoid.Compat from a globally unique namespace.
module Data.Monoid.Compat.Repl.Batteries

module Data.Proxy.Compat

-- | Reexports Data.Proxy.Compat from a globally unique namespace.
module Data.Proxy.Compat.Repl.Batteries

module Data.Ratio.Compat

-- | Reexports Data.Ratio.Compat from a globally unique namespace.
module Data.Ratio.Compat.Repl.Batteries

module Data.STRef.Compat

-- | Reexports Data.STRef.Compat from a globally unique namespace.
module Data.STRef.Compat.Repl.Batteries

module Data.Semigroup.Compat
class Semigroup a
(<>) :: Semigroup a => a -> a -> a
sconcat :: Semigroup a => NonEmpty a -> a
stimes :: (Semigroup a, Integral b) => b -> a -> a
stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
stimesIdempotent :: Integral b => b -> a -> a
stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
newtype Min a
Min :: a -> Min a
[getMin] :: Min a -> a
newtype Max a
Max :: a -> Max a
[getMax] :: Max a -> a
newtype First a
First :: a -> First a
[getFirst] :: First a -> a
newtype Last a
Last :: a -> Last a
[getLast] :: Last a -> a
newtype WrappedMonoid m
WrapMonoid :: m -> WrappedMonoid m
[unwrapMonoid] :: WrappedMonoid m -> m
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a
newtype Endo a
Endo :: (a -> a) -> Endo a
[appEndo] :: Endo a -> a -> a
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
newtype Option a
Option :: Maybe a -> Option a
[getOption] :: Option a -> Maybe a
option :: b -> (a -> b) -> Option a -> b
diff :: Semigroup m => m -> Endo m
cycle1 :: Semigroup m => m -> m
data Arg a b
Arg :: a -> b -> Arg a b
type ArgMin a b = Min Arg a b
type ArgMax a b = Max Arg a b

-- | Reexports Data.Semigroup.Compat from a globally unique
--   namespace.
module Data.Semigroup.Compat.Repl.Batteries

module Data.String.Compat

-- | Reexports Data.String.Compat from a globally unique namespace.
module Data.String.Compat.Repl.Batteries

module Data.Type.Coercion.Compat

-- | Reexports Data.Type.Coercion.Compat from a globally unique
--   namespace.
module Data.Type.Coercion.Compat.Repl.Batteries

module Data.Type.Equality.Compat
data (a :: k) :~: (b :: k)
[Refl] :: forall k (a :: k). a :~: a
class a ~# b => (a :: k0) ~~ (b :: k1)
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall k1 (a :: k1). a :~~: a
sym :: forall k (a :: k) (b :: k). (a :~: b) -> b :~: a
trans :: forall k (a :: k) (b :: k) (c :: k). (a :~: b) -> (b :~: c) -> a :~: c
castWith :: (a :~: b) -> a -> b
gcastWith :: forall k (a :: k) (b :: k) r. (a :~: b) -> (a ~ b => r) -> r
apply :: forall k1 k2 (f :: k1 -> k2) (g :: k1 -> k2) (a :: k1) (b :: k1). (f :~: g) -> (a :~: b) -> f a :~: g b
inner :: forall k1 k2 (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> a :~: b
outer :: forall k1 k2 (f :: k1 -> k2) (a :: k1) (g :: k1 -> k2) (b :: k1). (f a :~: g b) -> f :~: g
class TestEquality (f :: k -> Type)
testEquality :: forall (a :: k) (b :: k). TestEquality f => f a -> f b -> Maybe (a :~: b)
type family (a :: k) == (b :: k) :: Bool

-- | Reexports Data.Type.Equality.Compat from a globally unique
--   namespace.
module Data.Type.Equality.Compat.Repl.Batteries

module Data.Version.Compat

-- | Reexports Data.Version.Compat from a globally unique namespace.
module Data.Version.Compat.Repl.Batteries

module Data.Void.Compat
data Void
absurd :: Void -> a
vacuous :: Functor f => f Void -> f a

-- | Reexports Data.Void.Compat from a globally unique namespace.
module Data.Void.Compat.Repl.Batteries

module Data.Word.Compat

-- | Reexports Data.Word.Compat from a globally unique namespace.
module Data.Word.Compat.Repl.Batteries

module Debug.Trace.Compat

-- | Reexports Debug.Trace.Compat from a globally unique namespace.
module Debug.Trace.Compat.Repl.Batteries

module Foreign.Compat

-- | Reexports Foreign.Compat from a globally unique namespace.
module Foreign.Compat.Repl.Batteries

module Foreign.ForeignPtr.Compat

-- | Reexports Foreign.ForeignPtr.Compat from a globally unique
--   namespace.
module Foreign.ForeignPtr.Compat.Repl.Batteries

module Foreign.ForeignPtr.Safe.Compat

-- | Reexports Foreign.ForeignPtr.Safe.Compat from a globally unique
--   namespace.
module Foreign.ForeignPtr.Safe.Compat.Repl.Batteries

module Foreign.ForeignPtr.Unsafe.Compat

-- | Reexports Foreign.ForeignPtr.Unsafe.Compat from a globally
--   unique namespace.
module Foreign.ForeignPtr.Unsafe.Compat.Repl.Batteries

module Foreign.Marshal.Alloc.Compat

-- | Reexports Foreign.Marshal.Alloc.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Alloc.Compat.Repl.Batteries

module Foreign.Marshal.Array.Compat

-- | Reexports Foreign.Marshal.Array.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Array.Compat.Repl.Batteries

module Foreign.Marshal.Compat

-- | Reexports Foreign.Marshal.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Compat.Repl.Batteries

module Foreign.Marshal.Safe.Compat

-- | Reexports Foreign.Marshal.Safe.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Safe.Compat.Repl.Batteries

module Foreign.Marshal.Unsafe.Compat

-- | Reexports Foreign.Marshal.Unsafe.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Unsafe.Compat.Repl.Batteries

module Foreign.Marshal.Utils.Compat

-- | Reexports Foreign.Marshal.Utils.Compat from a globally unique
--   namespace.
module Foreign.Marshal.Utils.Compat.Repl.Batteries

module Numeric.Compat

-- | Reexports Numeric.Compat from a globally unique namespace.
module Numeric.Compat.Repl.Batteries

module Numeric.Natural.Compat

-- | Reexports Numeric.Natural.Compat from a globally unique
--   namespace.
module Numeric.Natural.Compat.Repl.Batteries

module Prelude.Compat

-- | Reexports Prelude.Compat from a globally unique namespace.
module Prelude.Compat.Repl.Batteries

module System.Environment.Compat

-- | Reexports System.Environment.Compat from a globally unique
--   namespace.
module System.Environment.Compat.Repl.Batteries

module System.Exit.Compat

-- | Reexports System.Exit.Compat from a globally unique namespace.
module System.Exit.Compat.Repl.Batteries

module System.IO.Error.Compat

-- | Reexports System.IO.Error.Compat from a globally unique
--   namespace.
module System.IO.Error.Compat.Repl.Batteries

module System.IO.Unsafe.Compat

-- | Reexports System.IO.Unsafe.Compat from a globally unique
--   namespace.
module System.IO.Unsafe.Compat.Repl.Batteries

module Text.Read.Compat

-- | Reexports Text.Read.Compat from a globally unique namespace.
module Text.Read.Compat.Repl.Batteries

module Type.Reflection.Compat

-- | Reexports Type.Reflection.Compat from a globally unique
--   namespace.
module Type.Reflection.Compat.Repl.Batteries
