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


-- | A more progressive alternative to the "base" package
--   
--   This package is intended for those who are tired of keeping long lists
--   of dependencies to the same essential libraries in each package as
--   well as the endless imports of the same APIs all over again. It also
--   supports the modern tendencies in the language.
--   
--   To solve those problems this package does the following:
--   
--   <ul>
--   <li>Reexport the original APIs under the "Rebase" namespace.</li>
--   <li>Export all the possible non-conflicting symbols from the
--   "Rebase.Prelude" module.</li>
--   <li>Give priority to the modern practices in the conflicting
--   cases.</li>
--   </ul>
--   
--   The policy behind the package is only to reexport the non-ambiguous
--   and non-controversial APIs, which the community has obviously settled
--   on. The package is intended to rapidly evolve with the contribution
--   from the community, with the missing features being added with
--   pull-requests.
@package rebase
@version 1.2

module Rebase.Unsafe.Coerce

module Rebase.Text.Show.Functions

module Rebase.Text.Show

module Rebase.Text.Read.Lex

module Rebase.Text.Read

module Rebase.Text.Printf

module Rebase.Text.ParserCombinators.ReadPrec

module Rebase.Text.ParserCombinators.ReadP

module Rebase.System.Timeout

module Rebase.System.Posix.Types

module Rebase.System.Posix.Internals

module Rebase.System.Mem.Weak

module Rebase.System.Mem.StableName

module Rebase.System.Mem

module Rebase.System.Info

module Rebase.System.IO.Unsafe

module Rebase.System.IO.Error

module Rebase.System.IO

module Rebase.System.Exit

module Rebase.System.Environment

module Rebase.System.Console.GetOpt

module Rebase.System.CPUTime

module Rebase.Numeric

module Rebase.Foreign.Storable

module Rebase.Foreign.StablePtr

module Rebase.Foreign.Ptr

module Rebase.Foreign.Marshal.Utils

module Rebase.Foreign.Marshal.Unsafe

module Rebase.Foreign.Marshal.Pool

module Rebase.Foreign.Marshal.Error

module Rebase.Foreign.Marshal.Array

module Rebase.Foreign.Marshal.Alloc

module Rebase.Foreign.Marshal

module Rebase.Foreign.ForeignPtr.Unsafe

module Rebase.Foreign.ForeignPtr

module Rebase.Foreign.Concurrent

module Rebase.Foreign.C.Types

module Rebase.Foreign.C.String

module Rebase.Foreign.C.Error

module Rebase.Foreign.C

module Rebase.Foreign

module Rebase.Debug.Trace

module Rebase.Data.Word

module Rebase.Data.Void.Unsafe

module Rebase.Data.Void

module Rebase.Data.Version

module Rebase.Data.Vector.Unboxed.Mutable

module Rebase.Data.Vector.Unboxed.Base

module Rebase.Data.Vector.Unboxed

module Rebase.Data.Vector.Storable.Mutable

module Rebase.Data.Vector.Storable.Internal

module Rebase.Data.Vector.Storable

module Rebase.Data.Vector.Primitive.Mutable

module Rebase.Data.Vector.Primitive

module Rebase.Data.Vector.Mutable

module Rebase.Data.Vector.Internal.Check

module Rebase.Data.Vector.Generic.New

module Rebase.Data.Vector.Generic.Mutable

module Rebase.Data.Vector.Generic.Base

module Rebase.Data.Vector.Generic

module Rebase.Data.Vector.Fusion.Util

module Rebase.Data.Vector.Fusion.Stream.Monadic

module Rebase.Data.Vector

module Rebase.Data.Unique

module Rebase.Data.UUID

module Rebase.Data.Typeable

module Rebase.Data.Type.Equality

module Rebase.Data.Type.Coercion

module Rebase.Data.Type.Bool

module Rebase.Data.Tuple

module Rebase.Data.Tree

module Rebase.Data.Traversable.Instances

module Rebase.Data.Traversable

module Rebase.Data.Time.LocalTime

module Rebase.Data.Time.Format

module Rebase.Data.Time.Clock.TAI

module Rebase.Data.Time.Clock.POSIX

module Rebase.Data.Time.Clock

module Rebase.Data.Time.Calendar.WeekDate

module Rebase.Data.Time.Calendar.OrdinalDate

module Rebase.Data.Time.Calendar.MonthDay

module Rebase.Data.Time.Calendar.Julian

module Rebase.Data.Time.Calendar.Easter

module Rebase.Data.Time.Calendar

module Rebase.Data.Time

module Rebase.Data.Text.Unsafe

module Rebase.Data.Text.Read

module Rebase.Data.Text.Lazy.Read

module Rebase.Data.Text.Lazy.IO

module Rebase.Data.Text.Lazy.Encoding

module Rebase.Data.Text.Lazy.Builder.Scientific

module Rebase.Data.Text.Lazy.Builder.RealFloat

module Rebase.Data.Text.Lazy.Builder.Int

module Rebase.Data.Text.Lazy.Builder


-- | Unifies some modules, which are separated in the original API for
--   unknown reasons.
module Rebase.Data.Text.Lazy

module Rebase.Data.Text.Internal

module Rebase.Data.Text.IO

module Rebase.Data.Text.Foreign

module Rebase.Data.Text.Encoding.Error

module Rebase.Data.Text.Encoding

module Rebase.Data.Text.Array


-- | Unifies some modules, which are separated in the original API for
--   unknown reasons.
module Rebase.Data.Text

module Rebase.Data.String

module Rebase.Data.Set

module Rebase.Data.Sequence

module Rebase.Data.Semigroupoid.Static

module Rebase.Data.Semigroupoid.Ob

module Rebase.Data.Semigroupoid.Dual

module Rebase.Data.Semigroupoid

module Rebase.Data.Semigroup.Traversable.Class

module Rebase.Data.Semigroup.Traversable

module Rebase.Data.Semigroup.Foldable.Class

module Rebase.Data.Semigroup.Foldable

module Rebase.Data.Semigroup.Bitraversable

module Rebase.Data.Semigroup.Bifoldable

module Rebase.Data.Semigroup
sappend :: Semigroup a => a -> a -> a

module Rebase.Data.Scientific

module Rebase.Data.STRef.Strict

module Rebase.Data.STRef.Lazy

module Rebase.Data.STRef

module Rebase.Data.Ratio

module Rebase.Data.Proxy

module Rebase.Data.Profunctor.Unsafe

module Rebase.Data.Profunctor.Strong

module Rebase.Data.Profunctor.Choice

module Rebase.Data.Profunctor

module Rebase.Data.Ord

module Rebase.Data.Monoid

module Rebase.Data.Maybe

module Rebase.Data.Map.Strict

module Rebase.Data.Map.Lazy

module Rebase.Data.Map


-- | This module simply provides a more meaningful name to
--   <a>Data.List.NonEmpty</a>.
module Rebase.Data.List1

-- | A more meaningful name for the non-empty list. Follows the convention
--   behind such names as <tt>foldr1</tt>.
type List1 = NonEmpty

module Rebase.Data.List.NonEmpty

module Rebase.Data.List

-- | If you're not a fan of magical or special cases, you probably have
--   already been looking for this alias.
type List = []

module Rebase.Data.Ix

module Rebase.Data.Isomorphism

module Rebase.Data.IntSet

module Rebase.Data.IntMap.Strict

module Rebase.Data.IntMap.Lazy

module Rebase.Data.IntMap

module Rebase.Data.Int

module Rebase.Data.IORef

module Rebase.Data.Hashable

module Rebase.Data.HashSet

module Rebase.Data.HashMap.Strict

module Rebase.Data.HashMap.Lazy

module Rebase.Data.Groupoid

module Rebase.Data.Graph

module Rebase.Data.Functor.Sum

module Rebase.Data.Functor.Reverse

module Rebase.Data.Functor.Product

module Rebase.Data.Functor.Plus

module Rebase.Data.Functor.Identity

module Rebase.Data.Functor.Extend

module Rebase.Data.Functor.Contravariant.Divisible

module Rebase.Data.Functor.Contravariant.Compose

module Rebase.Data.Functor.Contravariant

module Rebase.Data.Functor.Constant

module Rebase.Data.Functor.Compose

module Rebase.Data.Functor.Classes

module Rebase.Data.Functor.Bind.Trans

module Rebase.Data.Functor.Bind.Class

module Rebase.Data.Functor.Bind

module Rebase.Data.Functor.Apply

module Rebase.Data.Functor.Alt

module Rebase.Data.Functor

module Rebase.Data.Function

module Rebase.Data.Foldable

module Rebase.Data.Fixed

module Rebase.Data.Eq

module Rebase.Data.Either.Validation

module Rebase.Data.Either.Combinators

module Rebase.Data.Either

module Rebase.Data.Dynamic

module Rebase.Data.Data

module Rebase.Data.DList

module Rebase.Data.Complex

module Rebase.Data.Coerce

module Rebase.Data.Char

module Rebase.Data.ByteString.Unsafe

module Rebase.Data.ByteString.Short.Internal

module Rebase.Data.ByteString.Short

module Rebase.Data.ByteString.Lazy.Internal

module Rebase.Data.ByteString.Lazy.Char8

module Rebase.Data.ByteString.Lazy.Builder.Extras

module Rebase.Data.ByteString.Lazy.Builder.ASCII

module Rebase.Data.ByteString.Lazy.Builder

module Rebase.Data.ByteString.Lazy

module Rebase.Data.ByteString.Internal

module Rebase.Data.ByteString.Char8

module Rebase.Data.ByteString.Builder.Scientific

module Rebase.Data.ByteString.Builder.Prim.Internal

module Rebase.Data.ByteString.Builder.Prim

module Rebase.Data.ByteString.Builder.Internal

module Rebase.Data.ByteString.Builder.Extra

module Rebase.Data.ByteString.Builder

module Rebase.Data.ByteString

module Rebase.Data.Bool

module Rebase.Data.Bits

module Rebase.Data.Bitraversable

module Rebase.Data.Bifunctor.Wrapped

module Rebase.Data.Bifunctor.Tannen

module Rebase.Data.Bifunctor.Product

module Rebase.Data.Bifunctor.Joker

module Rebase.Data.Bifunctor.Join

module Rebase.Data.Bifunctor.Flip

module Rebase.Data.Bifunctor.Clown

module Rebase.Data.Bifunctor.Biff

module Rebase.Data.Bifunctor.Apply

module Rebase.Data.Bifunctor

-- | A more meaningful and conflict-free alias for <a>first</a>.
mapLeft :: Bifunctor p => (a -> b) -> p a c -> p b c

-- | A more meaningful and conflict-free alias for <a>second</a>.
mapRight :: Bifunctor p => (b -> c) -> p a b -> p a c

module Rebase.Data.Bifoldable

module Rebase.Data.Biapplicative

module Rebase.Control.Monad.Zip

module Rebase.Control.Monad.Writer.Strict

module Rebase.Control.Monad.Writer.Lazy

module Rebase.Control.Monad.Writer.Class

module Rebase.Control.Monad.Writer

module Rebase.Control.Monad.Trans.Writer.Strict

module Rebase.Control.Monad.Trans.Writer.Lazy

module Rebase.Control.Monad.Trans.Writer

module Rebase.Control.Monad.Trans.State.Strict

module Rebase.Control.Monad.Trans.State.Lazy

module Rebase.Control.Monad.Trans.State

module Rebase.Control.Monad.Trans.Reader

module Rebase.Control.Monad.Trans.RWS.Strict

module Rebase.Control.Monad.Trans.RWS.Lazy

module Rebase.Control.Monad.Trans.RWS

module Rebase.Control.Monad.Trans.Maybe

module Rebase.Control.Monad.Trans.List

module Rebase.Control.Monad.Trans.Identity

module Rebase.Control.Monad.Trans.Except

module Rebase.Control.Monad.Trans.Cont

module Rebase.Control.Monad.Trans.Class

module Rebase.Control.Monad.Trans

module Rebase.Control.Monad.State.Strict

module Rebase.Control.Monad.State.Lazy

module Rebase.Control.Monad.State.Class

module Rebase.Control.Monad.State

module Rebase.Control.Monad.Signatures

module Rebase.Control.Monad.STM

module Rebase.Control.Monad.ST.Unsafe

module Rebase.Control.Monad.ST.Strict

module Rebase.Control.Monad.ST.Lazy.Unsafe

module Rebase.Control.Monad.ST.Lazy

module Rebase.Control.Monad.ST

module Rebase.Control.Monad.Reader.Class

module Rebase.Control.Monad.Reader

module Rebase.Control.Monad.RWS.Strict

module Rebase.Control.Monad.RWS.Lazy

module Rebase.Control.Monad.RWS.Class

module Rebase.Control.Monad.RWS

module Rebase.Control.Monad.List

module Rebase.Control.Monad.Identity

module Rebase.Control.Monad.IO.Class

module Rebase.Control.Monad.Fix

module Rebase.Control.Monad.Fail

module Rebase.Control.Monad.Error.Class

module Rebase.Control.Monad.Cont.Class

module Rebase.Control.Monad.Cont

module Rebase.Control.Monad

module Rebase.Control.Exception.Base

module Rebase.Control.Exception

module Rebase.Control.DeepSeq

module Rebase.Control.Concurrent.STM.TVar

module Rebase.Control.Concurrent.STM.TSem

module Rebase.Control.Concurrent.STM.TQueue

module Rebase.Control.Concurrent.STM.TMVar

module Rebase.Control.Concurrent.STM.TChan

module Rebase.Control.Concurrent.STM.TBQueue

module Rebase.Control.Concurrent.STM.TArray

module Rebase.Control.Concurrent.STM

module Rebase.Control.Concurrent.QSemN

module Rebase.Control.Concurrent.QSem

module Rebase.Control.Concurrent.MVar

module Rebase.Control.Concurrent.Chan

module Rebase.Control.Concurrent

module Rebase.Control.Category

module Rebase.Control.Arrow

module Rebase.Control.Applicative.Lift

module Rebase.Control.Applicative.Backwards

module Rebase.Control.Applicative

module Rebase.Contravariant.Extras


-- | This module reexports the non-conflicting definitions from the modules
--   exported by this package, providing a much more featureful alternative
--   to the standard Prelude.
--   
--   For details check out the source.
module Rebase.Prelude